C++20

Related information
[lex.charset] ↑
universal-character-name:
[lex.pptoken] ↑
[lex.token] ↑
[lex.header] ↑
header-name:
h-char-sequence:
h-char:
any member of the source character set except new-line and >
q-char-sequence:
q-char:
any member of the source character set except new-line and "
[lex.ppnumber] ↑
[lex.name] ↑
identifier-nondigit:
nondigit:
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
_
digit:
0
1
2
3
4
5
6
7
8
9
[lex.key] ↑
keyword:
alignas
alignof
asm
auto
bool
break
case
catch
char
char8_t
char16_t
char32_t
class
concept
const
consteval
constexpr
constinit
const_cast
continue
co_await
co_return
co_yield
decltype
default
delete
do
double
dynamic_cast
else
enum
explicit
export
extern
false
float
for
friend
goto
if
inline
int
long
mutable
namespace
new
noexcept
nullptr
operator
private
protected
public
register
reinterpret_cast
requires
return
short
signed
sizeof
static
static_assert
static_cast
struct
switch
template
this
thread_local
throw
true
try
typedef
typeid
typename
union
unsigned
using
virtual
void
volatile
wchar_t
while
[lex.operators] ↑
preprocessing-operator:
#
##
%:
%:%:
operator-or-punctuator:
{
}
[
]
(
)
<:
:>
<%
%>
;
:
...
?
::
.
.*
->
->*
~
!
+
-
*
/
%
^
&
|
=
+=
-=
*=
/=
%=
^=
&=
|=
==
!=
<
>
<=
>=
<=>
&&
||
<<
>>
<<=
>>=
++
--
,
and
or
xor
not
bitand
bitor
compl
and_eq
or_eq
xor_eq
not_eq
[lex.literal.kinds] ↑
[lex.icon] ↑
octal-literal:
0
decimal-literal:
binary-digit:
0
1
octal-digit:
0
1
2
3
4
5
6
7
nonzero-digit:
1
2
3
4
5
6
7
8
9
hexadecimal-prefix:
0x
0X
hexadecimal-digit:
0
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
A
B
C
D
E
F
unsigned-suffix:
u
U
long-suffix:
l
L
long-long-suffix:
ll
LL
[lex.ccon] ↑
character-literal:
encoding-prefix:
u8
u
U
L
c-char-sequence:
c-char:
any member of the source character set except the single quote ', backslash \, or new-line character
simple-escape-sequence:
\'
\"
\?
\\
\a
\b
\f
\n
\r
\t
\v
[lex.fcon] ↑
fractional-constant:
exponent-part:
binary-exponent-part:
sign:
+
-
digit-sequence:
floating-point-suffix:
f
l
F
L
[lex.string] ↑
s-char-sequence:
s-char:
any member of the source character set except the double-quote ", backslash \, or new-line character
raw-string:
r-char-sequence:
r-char:
any member of the source character set, except a right parenthesis ) followed by the initial d-char-sequence (which may be empty) followed by a double quote ".
d-char-sequence:
d-char:
any member of the basic source character set, except: space, the left parenthesis (, the right parenthesis ), the backslash \, and the control characters representing horizontal tab, vertical tab, form feed, and newline.
[lex.bool] ↑
boolean-literal:
false
true
[lex.nullptr] ↑
pointer-literal:
nullptr
[lex.ext] ↑
user-defined-string-literal:
user-defined-character-literal:
ud-suffix:
[basic.link] ↑
[expr.prim] ↑
[expr.prim.id] ↑
id-expression:
[expr.prim.id.unqual] ↑
[expr.prim.id.qual] ↑
qualified-id:
[expr.prim.lambda] ↑
lambda-introducer:
[expr.prim.lambda.capture] ↑
capture-default:
&
=
capture-list:
simple-capture:
identifier ...opt
& identifier ...opt
this
* this
init-capture:
[expr.prim.fold] ↑
fold-operator:
+
-
*
/
%
^
&
|
<<
>>
+=
-=
*=
/=
%=
^=
&=
|=
<<=
>>=
=
==
!=
<
>
<=
>=
&&
||
,
.*
<<=
->*
[expr.prim.req] ↑
requires-expression:
requirement-parameter-list:
requirement-body:
[expr.prim.req.simple] ↑
simple-requirement:
[expr.prim.req.type] ↑
type-requirement:
[expr.prim.req.compound] ↑
compound-requirement:
{ expression } noexceptopt return-type-requirementopt ;
return-type-requirement:
[expr.prim.req.nested] ↑
nested-requirement:
[expr.post] ↑
expression-list:
[expr.unary] ↑
unary-operator:
*
&
+
-
!
~
[expr.await] ↑
await-expression:
co_await cast-expression
[expr.unary.noexcept] ↑
noexcept-expression:
noexcept ( expression )
[expr.new] ↑
new-expression:
::opt new new-placementopt ( type-id ) new-initializeropt
new-placement:
new-initializer:
[expr.delete] ↑
delete-expression:
::opt delete cast-expression
::opt delete [ ] cast-expression
[expr.cast] ↑
[expr.mptr.oper] ↑
[expr.mul] ↑
[expr.add] ↑
[expr.shift] ↑
[expr.spaceship] ↑
[expr.rel] ↑
[expr.eq] ↑
[expr.bit.and] ↑
[expr.xor] ↑
[expr.or] ↑
[expr.log.and] ↑
[expr.log.or] ↑
[expr.cond] ↑
[expr.yield] ↑
yield-expression:
co_yield braced-init-list
[expr.throw] ↑
throw-expression:
[expr.ass] ↑
assignment-operator:
=
*=
/=
%=
+=
-=
>>=
<<=
&=
^=
|=
[expr.comma] ↑
[expr.const] ↑
constant-expression:
[stmt.pre] ↑
[stmt.label] ↑
[stmt.expr] ↑
expression-statement:
expressionopt ;
[stmt.block] ↑
compound-statement:
{ statement-seqopt }
[stmt.select] ↑
selection-statement:
if constexpropt ( init-statementopt condition ) statement
if constexpropt ( init-statementopt condition ) statement else statement
[stmt.iter] ↑
for-range-initializer:
[stmt.jump] ↑
jump-statement:
break ;
continue ;
goto identifier ;
[stmt.return.coroutine] ↑
coroutine-return-statement:
co_return expr-or-braced-init-listopt ;
[stmt.dcl] ↑
declaration-statement:
[dcl.pre] ↑
nodeclspec-function-declaration:
alias-declaration:
static_assert-declaration:
static_assert ( constant-expression ) ;
static_assert ( constant-expression , string-literal ) ;
empty-declaration:
;
attribute-declaration:
[dcl.spec] ↑
decl-specifier:
friend
typedef
constexpr
consteval
constinit
inline
[dcl.stc] ↑
storage-class-specifier:
static
thread_local
extern
mutable
[dcl.fct.spec] ↑
function-specifier:
virtual
explicit-specifier:
explicit ( const-expression )
explicit
[dcl.typedef] ↑
[dcl.type] ↑
defining-type-specifier:
[dct.type.simple] ↑
simple-type-specifier:
char
char8_t
char16_t
char32_t
wchar_t
bool
short
int
long
signed
unsigned
float
double
void
[dcl.type.elab] ↑
elaborated-enum-specifier:
[dcl.type.decltype] ↑
decltype-specifier:
decltype ( expression )
[dcl.spec.auto] ↑
placeholder-type-specifier:
type-constraintopt auto
type-constraintopt decltype ( auto )
[dcl.decl] ↑
trailing-return-type:
-> type-id
cv-qualifier-seq:
cv-qualifier:
const
volatile
ref-qualifier:
&
&&
declarator-id:
...opt id-expression
[dcl.name] ↑
[dcl.fct] ↑
parameter-declaration-clause:
[dcl.init] ↑
brace-or-equal-initializer:
braced-init-list:
{ initializer-list ,opt }
{ }
initializer-list:
designated-initializer-clause:
designator:
expr-or-braced-init-list:
[dcl.fct.def.general] ↑
function-body:
= default ;
= delete ;
[dcl.enum] ↑
enum-name:
enum-specifier:
enum-head-name:
opaque-enum-declaration:
enum-key:
enum
enum class
enum struct
enum-base:
enumerator-definition:
[enum.udecl] ↑
using-enum-declaration:
[namespace.def] ↑
namespace-name:
named-namespace-definition:
unnamed-namespace-definition:
inlineopt namespace attribute-specifier-seqopt { namespace-body }
nested-namespace-definition:
enclosing-namespace-specifier:
namespace-body:
[namespace.alias] ↑
namespace-alias:
namespace-alias-definition:
qualified-namespace-specifier:
[namespace.udir] ↑
using-directive:
[namespace.udecl] ↑
using-declaration:
using-declarator-list:
using-declarator:
[dcl.asm] ↑
asm-declaration:
[dcl.link] ↑
linkage-specification:
[dcl.attr.grammar] ↑
attribute-specifier-seq:
attribute-using-prefix:
alignment-specifier:
alignas ( type-id ...opt )
alignas ( constant-expression ...opt )
attribute-scoped-token:
attribute-namespace:
attribute-argument-clause:
balanced-token:
[module.unit] ↑
module-partition:
module-name-qualifier:
[module.interface] ↑
export-declaration:
export declaration
export { declaration-seqopt }
[module.import] ↑
[module.global.frag] ↑
global-module-fragment:
[module.private.frag] ↑
private-module-fragment:
[class] ↑
class-specifier:
class-head-name:
class-virt-specifier:
final
class-key:
class
struct
union
[class.mem] ↑
virt-specifier:
override
final
pure-specifier:
= 0
[class.conv.fct] ↑
conversion-function-id:
conversion-type-id:
conversion-declarator:
[class.derived] ↑
base-clause:
base-specifier-list:
access-specifier:
private
protected
public
[class.base.init] ↑
ctor-initializer:
mem-initializer-list:
mem-initializer-id:
[over.oper] ↑
operator-function-id:
operator operator
operator:
new
delete
new [ ]
delete [ ]
co_await
+
-
*
/
%
^
&
|
~
!
=
<
>
<=>
+=
-=
*=
/=
%=
^=
&=
|=
<<
>>
>>=
<<=
==
!=
<=
>=
&&
||
++
--
,
->*
->
()
[]
[over.literal] ↑
literal-operator-id:
[temp.pre] ↑
template-head:
requires-clause:
[temp.constr.decl] ↑
constraint-expression:
[temp.deduct.guide] ↑
[temp.concept] ↑
concept-definition:
concept-name:
[temp.param] ↑
type-parameter-key:
class
typename
[temp.names] ↑
simple-template-id:
template-name:
template-argument-list:
[temp.res] ↑
typename-specifier:
[temp.explicit] ↑
explicit-instantiation:
externopt template declaration
[temp.expl.spec] ↑
explicit-specialization:
template < > declaration
[except.pre] ↑
function-try-block:
handler-seq:
[except.throw] ↑
throw-expression:
[except.spec] ↑
noexcept-specification:
noexcept ( constant-expression )
noexcept
[cpp] ↑
preprocessing-file:
groupopt
pp-global-module-fragment:
module ; new-line groupopt
pp-private-module-fragment:
module : private ; new-line groupopt
elif-group:
else-group:
# else new-line groupopt
endif-line:
# endif new-line
text-line:
conditionally-supported-directives:
lparen:
a ( character not immediately preceded by white-space
replacement-list:
new-line:
the new-line character
[cpp.cond] ↑
defined-macro-expression:
defined identifier
defined ( identifier )
h-preprocessing-token:
header-name-tokens:
has-include-expression:
__has_include ( header-name )
__has_include ( header-name-tokens )
has-attribute-expression:
__has_cpp_attribute ( pp-tokens )
[cpp.module] ↑
pp-module:
exportopt module pp-tokensopt ; new-line
[cpp.import] ↑
pp-import:
exportopt import header-name pp-tokensopt ; new-line
exportopt import header-name-tokens pp-tokensopt ; new-line
exportopt import pp-tokens ; new-line
[cpp.subst] ↑
va-opt-replacement:
__VA_OPT__ ( pp-tokensopt )