# noexcept operator (since C++11)

From cppreference.com
< cpp‎ | language

The `noexcept` operator performs a compile-time check that returns true if an expression is declared to not throw any exceptions.

It can be used within a function template's noexcept specifier to declare that the function will throw exceptions for some types but not others.

### Syntax

`noexcept(` expression `)` |  |

Returns a prvalue of type bool.

### Explanation

The `noexcept` operator does not evaluate expression.

The result is `false` if the expression contains at least one of the following potentially evaluated constructs:

  - call to any type of function that does not have non-throwing exception specification, unless it is a constant expression.
  - `throw` expression.
  - `dynamic_cast` expression when the target type is a reference type, and conversion needs a run time check
  - `typeid` expression when argument type is polymorphic class type

In all other cases the result is `true`.

(until C++17)

The result is `true` if the set of potential exceptions of the expression is empty, and `false` otherwise. | (since C++17)

### Keywords

`noexcept`

### Example

Run this code

    #include <iostream>
    #include <utility>
    #include <vector>

    void may_throw();
    void no_throw() noexcept;
    auto lmay_throw = []{};
    auto lno_throw = []() noexcept {};
    class T{
    public:
      ~T(){} // dtor prevents move ctor
             // copy ctor is noexcept
    };
    class U{
    public:
      ~U(){} // dtor prevents move ctor
             // copy ctor is noexcept(false)
      std::vector<int> v;
    };
    class V{
    public:
      std::vector<int> v;
    };

    int main()
    {
     T t;
     U u;
     V v;

     std::cout << std::boolalpha
               << "Is may_throw() noexcept? " << noexcept(may_throw()) << '\n'
               << "Is no_throw() noexcept? " << noexcept(no_throw()) << '\n'
               << "Is lmay_throw() noexcept? " << noexcept(lmay_throw()) << '\n'
               << "Is lno_throw() noexcept? " << noexcept(lno_throw()) << '\n'
               << "Is ~T() noexcept? " << noexcept(std::declval<T>().~T()) << '\n'
               // note: the following tests also require that ~T() is noexcept because
               // the expression within noexcept constructs and destroys a temporary
               << "Is T(rvalue T) noexcept? " << noexcept(T(std::declval<T>())) << '\n'
               << "Is T(lvalue T) noexcept? " << noexcept(T(t)) << '\n'
               << "Is U(rvalue U) noexcept? " << noexcept(U(std::declval<U>())) << '\n'
               << "Is U(lvalue U) noexcept? " << noexcept(U(u)) << '\n'
               << "Is V(rvalue V) noexcept? " << noexcept(V(std::declval<V>())) << '\n'
               << "Is V(lvalue V) noexcept? " << noexcept(V(v)) << '\n';
    }

Output:

    Is may_throw() noexcept? false
    Is no_throw() noexcept? true
    Is lmay_throw() noexcept? false
    Is lno_throw() noexcept? true
    Is ~T() noexcept? true
    Is T(rvalue T) noexcept? true
    Is T(lvalue T) noexcept? true
    Is U(rvalue U) noexcept? false
    Is U(lvalue U) noexcept? false
    Is V(rvalue V) noexcept? true
    Is V(lvalue V) noexcept? false

### See also

noexcept specifier | requires a function to not throw any exceptions (C++11)
exception specification | specifies what exceptions are thrown by a function (deprecated)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/language/noexcept&oldid=104434"