When should I really use noexcept?
c++, c++11, exception, noexcept
Solution
I think it is too early to give a "best practices" answer for this as there hasn't been enough time to use it in practice. If this was asked about throw specifiers right after they came out then the answers would be very different to now.
Having to think about whether or not I need to append `noexcept` after every function declaration would greatly reduce programmer productivity (and frankly, would be a pain).
Well, then use it when it's obvious that the function will never throw.
When can I realistically expect to observe a performance improvement after using `noexcept`? [...] Personally, I care about `noexcept` because of the increased freedom provided to the compiler to safely apply certain kinds of optimizations.
It seems like the biggest optimization gains are from user optimizations, not compiler ones due to the possibility of checking `noexcept` and overloading on it. Most compilers follow a no-penalty-if-you-don't-throw exception handling method, so I doubt it would change much (or anything) on the machine code level of your code, although perhaps reduce the binary size by removing the handling code.
Using `noexcept` in the big four (constructors, assignment, not destructors as they're already `noexcept`) will likely cause the best improvements as `noexcept` checks are 'common' in template code such as in `std` containers. For instance, `std::vector` won't use your class's move unless it's marked `noexcept` (or the compiler can deduce it otherwise).
Problem
The `noexcept` keyword can be appropriately applied to many function signatures, but I am unsure as to when I should consider using it in practice. Based on what I have read so far, the last-minute addition of `noexcept` seems to address some important issues that arise when move constructors throw. However, I am still unable to provide satisfactory answers to some practical questions that led me to read more about `noexcept` in the first place. There are many examples of functions that I know will never throw, but for which the compiler cannot determine so on its own. Should I append `noexcept` to the function declaration in all such cases? Having to think about whether or not I need to append `noexcept` after every function declaration would greatly reduce programmer productivity (and frankly, would be a pain in the neck). For which situations should I be more careful about the use of `noexcept`, and for which situations can I get away with the implied `noexcept(false)`? When can I realistically expect to observe a performance improvement after using `noexcept`? In particular, give an example of code for which a C++ compiler is able to generate better machine code after the addition of `noexcept`. Personally, I care about `noexcept` because of the increased freedom provided to the compiler to safely apply certain kinds of optimizations. Do modern compilers take advantage of `noexcept` in this way? If not, can I expect some of them to do so in the near future?
Related problems
- Is the default Move constructor defined as noexcept?
- noexcept, stack unwinding and performance
- Why does reallocating a vector copy instead of moving the elements?
- Should I use an exception specifier in C++?
- Why does the Java compiler allow exceptions to be listed in the throws section that it is impossible for the method to throw