When to Use noexcept in C++: Practical Rules, Performance, and Best Practices

By the end of this page, you will understand what noexcept means in C++, when it is worth adding, why it matters for move constructors and standard containers, and where it usually does not produce meaningful speedups. You will also learn practical rules for using it safely in real codebases.

noexcept is a promise: this function will not allow an exception to escape.

A function marked noexcept can still contain code that might throw internally, but if an exception does escape the function, the program calls std::terminate() instead of normal exception propagation.

void f() noexcept {
    throw 42; // Compiles, but if this exception escapes, the program terminates.
}

That means noexcept is not just documentation. It changes program behavior.

Why noexcept matters

In modern C++, noexcept is most important in places where the standard library or generic code needs to decide between:

• moving an object
• copying an object
• or refusing an operation entirely

A classic example is std::vector. When a vector grows and must relocate its elements, it prefers moving them for efficiency. But if moving might throw and copying is available, the vector may choose copying instead, because copying can preserve stronger exception safety guarantees.

If a type has a move constructor marked noexcept, containers can safely use it during reallocation.

Think of noexcept as putting a sealed "no exceptions may leave this room" sign on a function.

• Without the sign, an exception can leave the room and be handled somewhere else.
• With the sign, if an exception tries to leave, the building alarm goes off and the program is immediately stopped with std::terminate().

Why would you ever want that sign?

Because other parts of the program can trust it.

For example, a std::vector moving elements during resize wants to know:

• "If I move these objects, can something fail halfway through?"
• If the answer is no, it can move confidently.
• If the answer is maybe, it may choose a safer but slower strategy, such as copying.

So noexcept is not mainly about saving a few CPU instructions. It is about giving strong guarantees that other code can rely on.

Basic syntax

void logMessage() noexcept {
    // guaranteed not to let exceptions escape
}

You can also make it conditional:

template <typename T>
void swapValues(T& a, T& b) noexcept(noexcept(T(std::move(a)))) {
    T temp = std::move(a);
    a = std::move(b);
    b = std::move(temp);
}

The inner noexcept(...) checks whether an expression can throw. The outer noexcept(...) uses that result to declare whether the function itself is non-throwing.

Beginner-friendly example

#include <iostream>

class Counter {
public:
    Counter(int v) noexcept : value(v) {}

        {
         value;
    }

    {
        ++value;
    }

:
     value;
};

{
    ;
    c.();
    std::cout << c.() << ;
}

Consider this example:

#include <iostream>
#include <vector>

class Item {
public:
    Item() = default;

    Item(const Item&) {
        std::cout << "copy\n";
    }

    Item(Item&&) noexcept {
        std::cout << "move\n";
    }
};

int main() {
    std::vector<Item> items;
    items.reserve(1);

    items.push_back(Item{});
    items.push_back(Item{});
}

What happens step by step

1. items.reserve(1);

The vector allocates enough space for 1 Item.

2. items.push_back(Item{});

A temporary Item is created.

The vector places it into its storage. Since the temporary is an rvalue, moving is used.

Output:

1. Move-enabled classes stored in containers

If you write a class that owns resources and instances will live inside std::vector, std::deque, or similar containers, noexcept on move operations is often important.

Examples:

• file buffer wrappers
• image or audio buffers
• network packet objects
• parsed data records

2. swap functions

A custom swap is often expected to be non-throwing.

class Widget {
public:
    void swap(Widget& other) noexcept {
        std::swap(id, other.id);
    }

private:
    int id{};
};

Algorithms and generic code often work better when swap is known not to throw.

3. Destructors and cleanup logic

Destructors should not throw. In modern C++, destructors are effectively non-throwing by default unless declared otherwise, and throwing from a destructor during stack unwinding is dangerous.

Typical examples:

• releasing memory
• closing file handles
• unlocking mutexes

In real projects, developers usually do not try to mark every function noexcept.

Instead, they focus on places where it matters most.

Common patterns

1. Mark move operations noexcept when true

class Session {
public:
    Session(Session&&) noexcept = default;
    Session& operator=(Session&&) noexcept = default;
};

This is one of the most common and valuable uses.

2. Mark swap as noexcept

class Session {
public:
    void swap(Session& other) noexcept {
        std::swap(handle, other.handle);
    }

private:
    int handle{};
};

3. Use conditional noexcept in templates

1. Marking a function noexcept just because it usually does not throw

A function should be noexcept only if you are willing to make a strong promise that exceptions will never escape.

Broken example:

std::string readFile(const std::string& path) noexcept {
    std::ifstream file(path);
    if (!file) {
        throw std::runtime_error("Cannot open file");
    }
    return "data";
}

If an exception escapes, the program terminates.

Better:

std::string readFile(const std::string& path) {
    std::ifstream file(path);
    if (!file) {
        throw std::runtime_error("Cannot open file");
    }
    return "data";
}

2. Assuming noexcept automatically makes code faster

noexcept vs old-style throw()

Quick rules

• noexcept means: no exception may escape this function.
• If an exception does escape, the program calls std::terminate().
• Use it when non-throwing behavior is part of the function contract.
• Most valuable for move operations, swap, destructors, and trivial accessors.
• Do not add it to functions that may reasonably need to throw.

Syntax

void f() noexcept;

void g() noexcept(true);
void h() noexcept(false);

template <typename T>
void func() noexcept(noexcept(T{}));

Best candidates

class A {
:
    (A&&)  = ;
    A& =(A&&)  = ;

    {  v; }

    {
        std::(v, other.v);
    }

:
     v{};
};

What does noexcept do in C++?

It declares that a function will not let exceptions escape. If one does, the program terminates instead of propagating the exception.

Should I mark every non-throwing function noexcept?

No. Focus on functions where the guarantee matters: move operations, swap, destructors, and simple accessors. For many ordinary functions, leaving it off is fine.

Does noexcept improve performance?

Sometimes, but usually indirectly. The most important real effect is that standard containers may use move operations more aggressively when those moves are noexcept.

Why does std::vector care about noexcept?

During reallocation, vector wants to preserve exception safety. If moving elements might throw, it may choose copying instead. If moving is noexcept, moving becomes safer to use.

Can a noexcept function still contain code that throws?

Yes. But if an exception escapes the function, std::terminate() is called.

Is noexcept checked at compile time?

The declaration is checked syntactically, but the compiler does not prove all code paths are non-throwing in the general case. You are making a promise.

• Move semantics — noexcept is especially important for move constructors and move assignment operators.
• RAII — resource-managing classes often use non-throwing destructors and sometimes non-throwing moves.
• Exception safety — noexcept directly affects strong and basic exception guarantees.
• Copy vs move constructors — standard containers may choose between them based on noexcept.
• std::move — often appears together with noexcept in move operations.
• swap — custom swap functions are commonly marked noexcept.
• Templates — generic code often uses conditional noexcept.
• std::terminate — called when an exception escapes a noexcept function.