# Punctuation

> C++ Atlas: `cppatlas.com/w/cpp/language/punctuators` | Source: https://en.cppreference.com/w/cpp/language/punctuators | Domain: Language | Standards: C++11, C++14, C++17, C++20, C++23, C++26

These are the punctuation symbols in C++. The meaning of each symbol is detailed in the linked pages.

## Official Specification Summary (cppreference)

These are the punctuation symbols in C++. The meaning of each symbol is detailed in the linked pages.

### Preprocessing operators

Preprocessing operators are recognized by preprocessors.

#### `#` (including `%:`)

- Introduce a preprocessing directive.
- The preprocessing operator for stringification.

#### `##`(including `%:%:`)

- The preprocessing operator for token pasting.

### Single-character operators and punctuators

#### `{` and `}` (including `<%` and `%>`)

- In a class definition, delimit the member specification.
- In an enumeration definition, delimit the enumerator list.
- Delimit a compound statement. The compound statement may be part of

  - a function definition
  - a `try` block

  - a lambda expression (since C++11)

- Part of the aggregate initialization (until C++11) list-initialization (since C++11) syntax of an initializer.
- In a namespace definition, delimit the namespace body.
- In a language linkage specification, delimit the declarations.

(since C++20):

- In a `requires` expression, delimit the requirements.
- In a compound requirement, delimit the expression.
- In an export declaration, delimit the declarations.

#### `[` and `]` (including `<:` and `:>`)

- Subscript operator; part of `operator[]` in operator overloading.
- Part of array declarator in a declaration or a type-id (e.g. in a `new` expression).
- Part of `new[]` operator in operator overloading (allocation function).
- Part of `delete[]` operator in delete expression and operator overloading (deallocation function).

(since C++11):

- In a lambda expression, delimit the captures.
- In an attribute specifier, delimit the attributes.

(since C++17):

- In a structured binding declaration, delimit the identifier list.

(since C++26):

- In a pack indexing, delimit converted constant expression representing an index.

#### `(` and `)`

- In an expression, indicate grouping.
- Function call operator; part of `operator()` in operator overloading.
- In a function-style type cast, delimit the expression/initializers.
- In a `static_cast`, `const_cast`, `reinterpret_cast`, or `dynamic_cast`, delimit the expression.
- Delimit the operand of the following operators:

  - `typeid`
  - `sizeof`

  - `sizeof...`
  - `alignof`
  - `noexcept` (since C++11)

- In a placement `new` expression, delimit the placement arguments.
- In a `new` expression, optionally delimit the type-id.
- In a `new` expression, delimit the initializers.
- In a C-style cast, delimit the type-id.
- In a declaration or a type-id, indicate grouping.
- Delimit the parameter list in

  - a function declarator (in a declaration or a type-id)

  - a lambda expression (since C++11)

  - a user-defined deduction guide (since C++17)

  - a `requires` expression (since C++20)

- Part of the direct-initialization syntax of an initializer.
- In an asm declaration, delimit the string literal.
- In a member initializer list, delimit the initializers to a base or member.
- Delimit the controlling clause of a selection statement or iteration statement, including:

  - `if` (except consteval if) (since C++23)
  - `switch`
  - `while`
  - `do-while`
  - `for`

  - range-based `for` (since C++11)

- In a handler, delimit the parameter declaration.
- In a function-like macro definition, delimit the macro parameters.
- In a function-like macro invocation, delimit the macro arguments or prevent commas from being interpreted as argument separators.
- Part of a `defined`, `__has_include` (since C++17), `__has_cpp_attribute` (since C++20) preprocessing operator.

(since C++11):

- In a `static_assert` declaration, delimit the operands.
- Delimit the operand of the following specifiers:

  - `decltype`
  - `noexcept`
  - `alignas`

  - `explicit` (since C++20)

- In an attribute, delimit the attribute arguments.

(since C++14):

- Part of `decltype(auto)` specifier.

(since C++17):

- Delimit a fold expression.

(since C++20):

- Part of `__VA_OPT__` replacement in a variadic macro definition.

#### `;`

- Indicate the end of

  - a statement
  - a declaration or member declaration

  - a module declaration, import declaration, global module fragment introducer, or private module fragment introducer
  - a requirement (since C++20)

- Separate the *condition* and *statement* of a `for` statement.

#### `:`

- Part of conditional operator.
- Part of label declaration.
- In the *base-clause* of a class definition, introduce the base class.
- Part of access specifier in member specification.
- In a bit-field member declaration, introduce the width.
- In a constructor definition, introduce the member initializer list.

(since C++11):

- In a range-based `for` statement, separate the *item-declaration* and the *range-initializer*.
- In the *enum-base* of an enumeration declaration, introduce the underlying type.

(since C++17):

- In an attribute specifier, separate the *attribute-namespace* and the *attribute-list*.

(since C++20):

- In a module declaration or import declaration of module partition, introduce the module partition name.
- Part of a private module fragment introducer (`module:private;`).

#### `?`

- Part of conditional operator.

#### `.`

- Member access operator.

(since C++20):

- In aggregate initialization, introduce a designator.
- Part of module name or module partition name.

#### `~` (including `compl`)

- Unary complement operator (a.k.a. bitwise not operator); part of `operator~` in operator overloading.
- Part of an identifier expression to name a destructor or pseudo-destructor.

#### `!` (including `not`)

- Logical not operator; part of `operator!` in operator overloading.

(since C++23):

- Part of consteval if statement.

#### `+`

- Unary plus operator; part of `operator+` in operator overloading.
- Binary plus operator; part of `operator+` in operator overloading.

#### `-`

- Unary minus operator; part of `operator-` in operator overloading.
- Binary minus operator; part of `operator-` in operator overloading.

#### `*`

- Indirection operator; part of `operator*` in operator overloading.
- Multiplication operator; part of `operator*` in operator overloading.
- Pointer operator or part of pointer-to-member operator in a declarator or in a type-id.

(since C++17):

- Part of `*this` in a lambda capture list, to capture the current object by copy.

#### `/`

- Division operator; part of `operator/` in operator overloading.

#### `%`

- Modulo operator; part of `operator%` in operator overloading.

#### `^` (including `xor`)

- Bitwise xor operator; part of `operator^` in operator overloading.

#### `&` (including `bitand`)

- Address-of operator; part of `operator&` in operator overloading.
- Bitwise and operator; part of `operator&` in operator overloading.
- Lvalue-reference operator in a declarator or in a type-id.

(since C++11):

- In a lambda capture, indicate by-reference capture.
- Ref-qualifier in member function declaration.

#### `|` (including `bitor`)

- Bitwise or operator; part of `operator|` in operator overloading.

#### `=`

- Simple assignment operator; part of `operator=` in operator overloading, which might be a special member function (copy assignment operatoror move assignment operator (since C++11)).
- Part of the copy-initialization and aggregate initialization (until C++11) copy-list-initialization (since C++11) syntax of an initializer.
- In a function declaration, introduce a default argument.
- In a template parameter list, introduce a default template argument.
- In a namespace alias definition, separate the alias and the aliased namespace.
- In an enum definition, introduce the value of enumerator.
- Part of *pure-specifier* in a pure virtual function declaration.

(since C++11):

- Capture default in lambda capture, to indicate by-copy capture.
- Part of defaulted definition (`=default;`) or deleted definition (`=delete;`) in function definition.
- In a type alias declaration, separate the alias and the aliased type.

(since C++20):

- In a concept definition, separate the concept name and the constraint expression.

#### `<`

- Less-than operator; part of `operator<` in operator overloading.
- In a `static_cast`, `const_cast`, `reinterpret_cast`, or `dynamic_cast`, introduce the type-id.
- Introduce a template argument list.
- Introduce a template parameter list in

  - a template declaration
  - a partial specialization

  - a lambda expression (since C++20)

- Part of `template<>` in template specialization declaration.
- Introduce a header name in

  - a `#include` directive

  - a `__has_include` preprocessing expression (since C++17)

  - an `import` declaration (since C++20)

#### `>`

- Greater-than operator; part of `operator>` in operator overloading.
- `static_cast`, `const_cast`, `reinterpret_cast`, or `dynamic_cast`, indicate the end of type-id.
- Indicate the end of a template argument list.
- Indicate the end of a template parameter list in

  - a template declaration
  - a partial specialization

  - a lambda expression (since C++20)

- Part of `template<>` in template specialization declaration.
- Indicate the end of a header name in

  - a `#include` directive

  - a `__has_include` preprocessing expression (since C++17)

  - an `import` declaration (since C++20)

#### `,`

- Comma operator; part of `operator,` in operator overloading.
- List separator in

  - the declarator list in a declaration
  - initializer list in initialization
  - the placement argument list in a placement new
  - the argument list in a function call expression
  - the enumerator list in an enum declaration
  - the base class list in a class declaration
  - the member initializer list in a constructor definition
  - a function parameter list
  - a template parameter list
  - a template argument list

  - a lambda capture list
  - an attribute list (since C++11)

  - the declarator list in a using-declaration
  - the identifier list in a structured binding declaration (since C++17)

  - the argument list in a multi-argument subscript expression (since C++23)

  - the macro parameter list in a function-like macro definition
  - the macro argument list in a function-like macro invocation, unless found between the parentheses of an argument

(since C++11):

- In a `static_assert` declaration, separate the arguments.

### Multi-character operators and punctuators

#### `...`

- In the parameter list of a function declaratoror lambda expression (since C++11) or user-defined deduction guide (since C++17), signify a variadic function.
- In a handler, signify catch-all handler.

(since C++11):

- In a macro definition, signify a variadic macro.
- Indicate pack declaration and expansion.

(since C++26):

- In pack indexing expression and specifier.

#### `::`

- Scope resolution operator in

  - a qualified name
  - a pointer-to-member declaration
  - a `new` or `delete` expression, to indicate that only global allocation or deallocation functions are looked up

(since C++11):

- In an attribute, indicate attribute scope.

(since C++17):

- Part of nested namespace definition.

#### `.*`

- Pointer-to-member access operator.

#### `->`

- Member access operator; part of `operator->` in operator overloading.

(since C++11):

- In a function declarator or lambda expression, introduce the trailing return type.

(since C++17):

- In a user-defined deduction guide, introduce the result type.

(since C++20):

- In a compound requirement, introduce the return type requirement.

#### `->*`

- Pointer-to-member access operator; part of `operator->*` in operator overloading.

#### `+=`

- Compound assignment operator; part of `operator+=` in operator overloading.

#### `-=`

- Compound assignment operator; part of `operator-=` in operator overloading.

#### `*=`

- Compound assignment operator; part of `operator*=` in operator overloading.

#### `/=`

- Compound assignment operator; part of `operator/=` in operator overloading.

#### `%=`

- Compound assignment operator; part of `operator%=` in operator overloading.

#### `^=` (including `xor_eq`)

- Compound assignment operator; part of `operator^=` in operator overloading.

#### `&=` (including `and_eq`)

- Compound assignment operator; part of `operator&=` in operator overloading.

#### `|=` (including `or_eq`)

- Compound assignment operator; part of `operator|=` in operator overloading.

#### `==`

- Equality operator; part of `operator==` in operator overloading.

#### `!=` (including `not_eq`)

- Inequality operator; part of `operator!=` in operator overloading.

#### `<=`

- Less-than-or-equal-to operator; part of `operator<=` in operator overloading.

#### `>=`

- Greater-than-or-equal-to operator; part of `operator>=` in operator overloading.

(since C++20):

#### `<=>`

- Three-way comparison (spaceship) operator; part of `operator<=>` in operator overloading.

#### `&&` (including `and`)

- Logical and operator; part of `operator&&` in operator overloading.

(since C++11):

- Rvalue-reference operator in a declarator or in a type-id.
- Ref-qualifier in member function declaration.

#### `||` (including `or`)

- Logical or operator; part of `operator||` in operator overloading.

#### `<<`

- Bitwise shift operator; part of `operator<<` in operator overloading (bitwise operator or stream insertion operator).

#### `>>`

- Bitwise shift operator; part of `operator>>` in operator overloading (bitwise operator or stream extraction operator).

#### `<<=`

- Compound assignment operator; part of `operator<<=` in operator overloading.

#### `>>=`

- Compound assignment operator; part of `operator>>=` in operator overloading.

#### `++`

- Increment operator; part of `operator++` in operator overloading.

#### `--`

- Decrement operator; part of `operator--` in operator overloading.

### References

- C++23 standard (ISO/IEC 14882:2024):

  - 5.12 Operators and punctuators [lex.operators]

- C++20 standard (ISO/IEC 14882:2020):

  - 5.12 Operators and punctuators [lex.operators]

- C++17 standard (ISO/IEC 14882:2017):

  - 5.12 Operators and punctuators [lex.operators]

- C++14 standard (ISO/IEC 14882:2014):

  - 2.13 Operators and punctuators [lex.operators]

- C++11 standard (ISO/IEC 14882:2011):

  - 2.13 Operators and punctuators [lex.operators]

- C++03 standard (ISO/IEC 14882:2003):

  - 2.12 Operators and punctuators [lex.operators]

- C++98 standard (ISO/IEC 14882:1998):

  - 2.12 Operators and punctuators [lex.operators]

### See also

- [Alternative representations](https://en.cppreference.com/w/cpp/language/operator_alternative): alternative spellings for certain operators
- [C documentation for Punctuation](https://en.cppreference.com/w/c/language/punctuators)

---
Attribution: content from https://en.cppreference.com/w/cpp/language/punctuators (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.