.CPP File Format – Expressions

Precedence and associativity

The standard defines these through its grammar and gives no numbered levels. The levels below are the conventional numbering. Each line binds tighter than the ones below.

• The expression between ? and : is parsed as if parenthesised.
• sizeof (int) * p parses as (sizeof(int)) * p, because the operand of sizeof cannot be a C-style cast.
• *p++ is *(p++), and a = b = c is a = (b = c).
• std::cout << a & b parses as (std::cout << a) & b.
• The cast keywords, typeid, alignof, noexcept and sizeof... are not listed because their syntax is never ambiguous.
• The named alternative tokens, such as and, behave like the operators they spell.

Evaluation order

Precedence controls grouping, not when operands run. Evaluation order is mostly unspecified, but C++17 added rules for many operators [intro.execution], [expr.call].

A full-expression finishes before the next one starts. Within one, the rules below say what is sequenced before what. If two side effects on the same scalar object, or a side effect and a value computation of it, are not sequenced, the behaviour is undefined.

i = i++ + 1;      // defined since C++17
a[i] = i++;       // defined since C++17: i++ runs first
i + i++;          // undefined: value computation and side effect are unsequenced
f(i++, i++);      // not undefined since C++17, but the order is unspecified
g(h(), j());      // h and j run in an unspecified order

An overloaded operator used with operator notation follows the sequencing of the built-in operator [over.match.oper].

Operator details

new and delete

A new-expression obtains storage for an object from an allocation function, then constructs it [expr.new]. A delete-expression reverses this [expr.delete].

int*    a = new int;            // default-initialised
int*    b = new int(5);         // direct-initialised
int*    c = new int{5};         // list-initialised
int*    d = new int[3]{1, 2};   // array: the last element is zero-initialised
int*    e = new int[]{1, 2, 3}; // bound deduced (C++20)
int*    f = new (std::nothrow) int;     // null on failure instead of throwing
Widget* g = new (buffer) Widget();      // placement new

delete a;
delete[] d;
g->~Widget();                   // placement new needs an explicit destructor call

• Allocation failure throws std::bad_alloc, unless the form is nothrow.
• delete on a pointer from new[], or delete[] on one from new, is undefined behaviour.
• Deleting a null pointer does nothing.
• A class can define its own operator new and operator delete. Replacing the global ones is allowed too.
• A size-taking operator delete exists since C++14.
• Since C++14, a compiler may combine or omit calls to the replaceable allocation functions.
• If a constructor throws, the matching deallocation function is called on the storage.

Casts

std::bit_cast<T>(e) (C++20) from <bit> reinterprets an object’s bytes as another trivially copyable type of the same size. It is not an operator, but it is usually a better choice than reinterpret_cast, which can break aliasing rules.