noexcept

For example, it's pretty common to have two separate ways to access elements of a private array, overloading the array subscripting operator, or defining at : T& operator[](size_t i) { return v[i]; } T const& operator[](size_t i) const { return v[i]; } T& at(size_t i) { if (i >= length) throw out_of_range("You shall not pass!"); return v[i]; } T const& at(size_t i) const { if (i >= length) throw out_of_range("You shall not pass!"); return v[i]; } The at version can throw an exception, but the array subscripting operator can't. My question is, altough the operator[] doesn't throw an exception,

Please consider the following code snippet: template<class Tuple> class vector { public: typename Tuple::size_type size() const noexcept(noexcept(m_elements.size())) { return m_elements.size(); } private: Tuple m_elements; }; class tuple { public: using size_type = std::size_t; size_type size() const { return 0; } size_type size() noexcept { return 0; } }; int main() { vector<tuple> x; static_assert(noexcept(x.size()), "x.size() might throw"); return 0; } Is the use of the member variable m_elements inside the noexcept specifier legal? GCC 5.2 (C++17) yields the compiler error m_elements was

I am a little bit confused with destructors and noexcept . My understanding was that in C++11 any destructor, including user-defined, is implicitly noexcept(true) , even if we throw from it. And one has to specify explicitly noexcept(false) if they want it to be that way for some reason. I'm seeing quite the opposite - with GCC 4.7.2, the user-defined destructor, no matter how primitive the class and destructor are, is implicitly noexcept(false) . What am I missing here? Is there some hidden gotcha with user-defined destructors? Andy Prowl This is a known bug (credits to the OP for finding the

I have the following code: class MyClass { static constexpr bool foo() { return true; } void bar() noexcept(foo()) { } }; I would expect that since foo() is a static constexpr function, and since it's defined before bar is declared, this would be perfectly acceptable. However, g++ gives me the following error: error: ‘static constexpr bool MyClass::foo()’ called in a constant expression This is...less than helpful, since the ability to call a function in a constant expression is the entire point of constexpr . clang++ is a little more helpful. In addition to an error message stating that the

Why std::vector 's operator[] , front and back member functions are not specified as noexcept ? The standard's policy on noexcept is to only mark functions that cannot or must not fail, but not those that simply are specified not to throw exceptions. In other words, all functions that have a limited domain (pass the wrong arguments and you get undefined behavior) are not noexcept , even when they are not specified to throw. Functions that get marked are things like swap (must not fail, because exception safety often relies on that) and numeric_limits::min (cannot fail, returns a constant of a

The following draft from Scott Meyers new C++11 book says(page 2, lines 7-21) The difference between unwinding the call stack and possibly unwinding it has a surprisingly large impact on code generation. In a noexcept function, optimizers need not keep the runtime stack in an unwindable state if an exception would propagate out of the function, nor must they ensure that objects in a noexcept function are destroyed in the inverse order of construction should an exception leave the function. The result is more opportunities for optimization, not only within the body of a noexcept function, but

I've heard that noexcept keyword is more like 'it should never throw an exception' rather than 'it doesn't'. I don't think it's good to use noexcept keyword if I'm not sure it throws an exception or not, but noexcept keyword is sometimes related to the performance like in a move constructor. So I tried to use noexcept qualifiers, but it gets harder if it has multiple statements in the definition and it becomes a kind of copy-and-paste thing. template <class T> void f(T&& t) noexcept(noexcept(statement_1) && noexcept(statement_2) && noexcept(statement_3) && noexcept(statement_4) && noexcept