Punctuation

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

C++ language

General topics
Preprocessor Comments	Keywords Escape sequences
Flow control
Conditional execution statements
if	switch
Iteration statements (loops)
for range-for (C++11)	while do-while
Jump statements
continue - break	goto - return
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications (until C++17*)
noexcept specifier (C++11)
Exceptions
throw-expression	try-catch block
Namespaces
Namespace declaration	Namespace aliases
Types
Fundamental types Enumeration types Function types	Class/struct types Union types
Specifiers
decltype (C++11) auto (C++11) alignas (C++11)	const/volatile constexpr (C++11)
Storage duration specifiers
Initialization
Default initialization Value initialization Zero initialization Copy initialization Direct initialization	Aggregate initialization     List initialization (C++11) Constant initialization Reference initialization

Expressions
Value categories Order of evaluation	Operators Operator precedence
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Implicit conversions - Explicit conversions
static_cast - dynamic_cast
const_cast - reinterpret_cast
Memory allocation
new expression	delete expression
Classes
Class declaration Constructors this pointer	Access specifiers friend specifier
Class-specific function properties
Virtual function override specifier (C++11)       final specifier (C++11)	explicit (C++11) static
Special member functions
Default constructor Copy constructor Move constructor (C++11)	Copy assignment Move assignment (C++11) Destructor
Templates
Class template Function template	Template specialization Parameter packs (C++11)
Miscellaneous
Inline assembly	History of C++

 

Basic Concepts

Comments

ASCII

Punctuation

Names and identifiers

Types

Fundamental types

Objects

Scope

Object lifetime

Storage duration and linkage

Definitions and ODR

Name lookup

Qualified name lookup

Unqualified name lookup

The as-if rule

Undefined behavior

Memory model

Character sets and encodings

Phases of translation

The main function

Modules (C++20)

 

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

{ }

• In a class/struct or union definition, delimit the member specification.
• In an enum definition, delimit the enumerator list.
• Delimit a compound statement. The compound statement may be part of

• a function definition
• a try block or catch clause
• a function-try-block
• a lambda expression (since C++11)

• In initialization, delimit the initializers. This kind of initialization is called list-initialization. (since C++11)
• In a namespace definition, delimit the namespace body.
• In a language linkage specification, delimit the declarations.
• In a requires-expression, delimit the requirements. (since C++20)
• In a compound requirement, delimit the expression. (since C++20)
• In an export declaration, delimit the declarations. (since C++20)

[ ]

• 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).
• In a lambda expression, delimit the captures. (since C++11)
• In an attribute specifier, delimit the attributes. (since C++11)
• In a structured binding declaration, delimit the identifier list. (since C++17)

#

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

##

• The preprocessing operator for token pasting.

( )

• 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.
• In a typeid, sizeof, sizeof..., alignof, or noexcept (since C++11) expression, delimit the operand.
• 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)

• In direct-initialization, delimit the initializers.
• In an asm declaration, delimit the string literal.
• In a member initializer list, delimit the initializers to a base or member.
• In an if (including constexpr if) (since C++17), switch, while, do-while, or for(including range-based for) (since C++11) statement, delimit the controlling clause.
• In a catch clause, 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.
• In a static_assert declaration, delimit the operands. (since C++11)
• In a decltype specifier, noexcept specifier, alignas specifier, conditional explicit specifier (since C++20), delimit the operand. (since C++11)
• In an attribute, delimit the attribute arguments. (since C++11)
• Part of decltype(auto) specifier. (since C++14)
• Delimit a fold expression. (since C++17)
• Part of __VA_OPT__ replacement in a variadic macro definition. (since C++20)

;

• Indicate the end of

• a statement (including the init-statement of a for statement)
• a declaration or member declaration
• a module declaration, import declaration, global module fragment introducer, or private module fragment introducer (since C++20)
• a requirement (since C++20)

• Separate the second and third clauses of a for statement.

:

• Part of conditional operator.
• Part of label declaration.
• In the class-head of a class definition, introduce the base-clause.
• 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.
• In a range-based for statement, separate the range-declaration and the range-initializer. (since C++11)
• Introduce an enum base, which specifies the underlying type of the enum. (since C++11)
• In an attribute specifier, separate the attribute-using-prefix and the attribute list. (since C++17)
• In a module declaration or import declaration of module partition, introduce the module partition name. (since C++20)
• Part of a private module fragment introducer (module :private;). (since C++20)

...

• 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 catch-clause, signify catch-all handler.
• In a macro definition, signify a variadic macro. (since C++11)
• Indicate pack declaration and expansion. (since C++11)

?

• Part of conditional operator.

::

• 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

• In an attribute, indicate attribute scope. (since C++11)
• Part of nested namespace definition. (since C++17)

.

• Member access operator.
• In aggregate initialization, introduce a designator. (since C++20)
• Part of module name or module partition name. (since C++20)

.*

• Pointer-to-member access operator.

->

• Member access operator; part of operator-> in operator overloading.
• In a function declarator or lambda expression, introduce the trailing return type. (since C++11)
• In a user-defined deduction guide, introduce the result type. (since C++17)
• In a compound requirement, introduce the return type requirement. (since C++20)

->*

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

~

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

!

• Logical not operator; part of operator! in operator overloading.
• Part of reversed variant of a consteval if statement. (since C++23)

+

• 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.
• Part of *this in a lambda capture list, to capture the current object by copy. (since C++17)

/

• Division operator; part of operator/ in operator overloading.

%

• Modulo operator; part of operator% in operator overloading.

^

• Bitwise xor operator; part of operator^ in operator overloading.

&

• 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.
• In a lambda capture, indicate by-reference capture. (since C++11)
• Ref-qualifier in member function declaration. (since C++11)

|

• 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)).
• In initialization, indicate copy-initializationor copy-list-initialization (since C++11).
• 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.
• Capture default in lambda capture, to indicate by-copy capture. (since C++11)
• Part of defaulted definition (=default;) or deleted definition (=delete;) in function definition. (since C++11)
• In a type alias declaration, separate the alias and the aliased type. (since C++11)
• In a concept definition, separate the concept name and the constraint expression. (since C++20)

+=

• 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.

^=

• 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.

==

• Equality operator; part of operator== in operator overloading.

!=

• Inequality operator; part of operator!= in operator overloading.

<

• 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)

<=

• 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.

&&

• Logical and operator; part of operator&& in operator overloading.
• Rvalue-reference operator in a declarator or in a type-id. (since C++11)
• Ref-qualifier in member function declaration. (since C++11)

||

• 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).
• Can be reparsed as two > in a static_cast, const_cast, reinterpret_cast, or dynamic_cast, a template argument list, or a template parameter list. (since C++11)

<<=

• 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.

,

• 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 argument list in a multi-argument subscript expression (since C++23)
• 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
• the macro parameter list in a function-like macro definition
• the macro argument list in a function-like macro invocation, unless found between an inner set of parentheses
• a lambda capture list (since C++11)
• an attribute list (since C++11)
• the declarator list in a using-declaration (since C++17)
• the identifier list in a structured binding declaration (since C++17)

• In a static_assert declaration, separate the arguments. (since C++11)

References

• C++23 standard (ISO/IEC 14882:2023):

• 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

alternative spellings for certain operators