Annex A (informative) Grammar summary [gram]

This summary of C++  grammar is intended to be an aid to comprehension. It is not an exact statement of the language. In particular, the grammar described here accepts a superset of valid C++  constructs. Disambiguation rules ([stmt.ambig], [dcl.spec], [class.member.lookup]) must be applied to distinguish expressions from declarations. Further, access control, ambiguity, and type rules must be used to weed out syntactically valid but meaningless constructs.

A.1 Keywords [gram.key]

A.2 Lexical conventions [gram.lex]

hex-quad:
	hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit
universal-character-name:
	\u hex-quad
	\U hex-quad hex-quad
preprocessing-token:
	header-name
	identifier
	pp-number
	character-literal
	user-defined-character-literal
	string-literal
	user-defined-string-literal
	preprocessing-op-or-punc
	each non-white-space character that cannot be one of the above
token:
	identifier
	keyword
	literal
	operator
	punctuator
header-name:
	< h-char-sequence >
	" q-char-sequence "
h-char-sequence:
	h-char
	h-char-sequence h-char
h-char:
	any member of the source character set except new-line and >
q-char-sequence:
	q-char
	q-char-sequence q-char
q-char:
	any member of the source character set except new-line and "
pp-number:
	digit
	. digit
	pp-number digit
	pp-number identifier-nondigit
	pp-number ' digit
	pp-number ' nondigit
	pp-number e sign
	pp-number E sign
	pp-number p sign
	pp-number P sign
	pp-number .
identifier:
	identifier-nondigit
	identifier identifier-nondigit
	identifier digit
identifier-nondigit:
	nondigit
	universal-character-name
nondigit: one of
	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: one of
	0 1 2 3 4 5 6 7 8 9
preprocessing-op-or-punc: one of
	{ 	} 	[ 	] 	# 	## 	( 	)
	<: 	:> 	<% 	%> 	%: 	%:%: 	; 	: 	...
	new 	delete 	? 	:: 	. 	.*
	+ 	- 	* 	/ 	% 	^	& 	| 	~
	! 	= 	< 	> 	+= 	-= 	*= 	/= 	%=
	^= 	&= 	|= 	<< 	>> 	>>= 	<<= 	== 	!=
	<= 	>= 	&& 	|| 	++ 	-- 	, 	->* 	->
	and 	and_eq 	bitand 	bitor 	compl 	not 	not_eq
	or 	or_eq 	xor 	xor_eq
literal:
	integer-literal
	character-literal
	floating-literal
	string-literal
	boolean-literal
	pointer-literal
	user-defined-literal
integer-literal:
	binary-literal integer-suffix
	octal-literal integer-suffix
	decimal-literal integer-suffix
	hexadecimal-literal integer-suffix
binary-literal:
	0b binary-digit
	0B binary-digit
	binary-literal ' binary-digit
octal-literal:
	0
	octal-literal ' octal-digit
decimal-literal:
	nonzero-digit
	decimal-literal ' digit
hexadecimal-literal:
	hexadecimal-prefix hexadecimal-digit-sequence
binary-digit:
	0
	1
octal-digit: one of
	0  1  2  3  4  5  6  7
nonzero-digit: one of
	1  2  3  4  5  6  7  8  9
hexadecimal-prefix: one of
	0x  0X
hexadecimal-digit-sequence:
	hexadecimal-digit
	hexadecimal-digit-sequence ' hexadecimal-digit
hexadecimal-digit: one of
	0  1  2  3  4  5  6  7  8  9
	a  b  c  d  e  f
	A  B  C  D  E  F
integer-suffix:
	unsigned-suffix long-suffix 
	unsigned-suffix long-long-suffix 
	long-suffix unsigned-suffix 
	long-long-suffix unsigned-suffix
unsigned-suffix: one of
	u  U
long-suffix: one of
	l  L
long-long-suffix: one of
	ll  LL
character-literal:
	encoding-prefix ' c-char-sequence '
encoding-prefix: one of
	u8  u  U  L
c-char-sequence:
	c-char
	c-char-sequence c-char
c-char:
	any member of the source character set except
		the single-quote ', backslash \, or new-line character
	escape-sequence
	universal-character-name
escape-sequence:
	simple-escape-sequence
	octal-escape-sequence
	hexadecimal-escape-sequence
simple-escape-sequence: one of
	\'  \"  \?  \\
	\a  \b  \f  \n  \r  \t  \v
octal-escape-sequence:
	\ octal-digit
	\ octal-digit octal-digit
	\ octal-digit octal-digit octal-digit
hexadecimal-escape-sequence:
	\x hexadecimal-digit
	hexadecimal-escape-sequence hexadecimal-digit
floating-literal:
	decimal-floating-literal
	hexadecimal-floating-literal
decimal-floating-literal:
	fractional-constant exponent-part floating-suffix
	digit-sequence exponent-part floating-suffix
hexadecimal-floating-literal:
	hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part floating-suffix
	hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part floating-suffix
fractional-constant:
	digit-sequence . digit-sequence
	digit-sequence .
hexadecimal-fractional-constant:
	hexadecimal-digit-sequence . hexadecimal-digit-sequence
	hexadecimal-digit-sequence .
exponent-part:
	e sign digit-sequence
	E sign digit-sequence
binary-exponent-part:
	p sign digit-sequence
	P sign digit-sequence
sign: one of
	+  -
digit-sequence:
	digit
	digit-sequence ' digit
floating-suffix: one of
	f  l  F  L
string-literal:
	encoding-prefix " s-char-sequence "
	encoding-prefix R raw-string
s-char-sequence:
	s-char
	s-char-sequence s-char
s-char:
	any member of the source character set except
		the double-quote ", backslash \, or new-line character
	escape-sequence
	universal-character-name
raw-string:
	" d-char-sequence ( r-char-sequence ) d-char-sequence "
r-char-sequence:
	r-char
	r-char-sequence r-char
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
	d-char-sequence d-char
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.
boolean-literal:
	false
	true
pointer-literal:
	nullptr
user-defined-literal:
	user-defined-integer-literal
	user-defined-floating-literal
	user-defined-string-literal
	user-defined-character-literal
user-defined-integer-literal:
	decimal-literal ud-suffix
	octal-literal ud-suffix
	hexadecimal-literal ud-suffix
	binary-literal ud-suffix
user-defined-floating-literal:
	fractional-constant exponent-part ud-suffix
	digit-sequence exponent-part ud-suffix
	hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part ud-suffix
	hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part ud-suffix
user-defined-string-literal:
	string-literal ud-suffix
user-defined-character-literal:
	character-literal ud-suffix
ud-suffix:
	identifier

A.3 Basic concepts [gram.basic]

translation-unit:
	declaration-seq

A.4 Expressions [gram.expr]

primary-expression:
	literal
	this
	( expression )
	id-expression
	lambda-expression
	fold-expression
id-expression:
	unqualified-id
	qualified-id
unqualified-id:
	identifier
	operator-function-id
	conversion-function-id
	literal-operator-id
	~ class-name
	~ decltype-specifier
	template-id
qualified-id:
	nested-name-specifier template unqualified-id
nested-name-specifier:
	::
	type-name ::
	namespace-name ::
	decltype-specifier ::
	nested-name-specifier identifier ::
	nested-name-specifier template simple-template-id ::
lambda-expression:
	lambda-introducer lambda-declarator compound-statement
lambda-introducer:
	[ lambda-capture ]
lambda-declarator:
	( parameter-declaration-clause ) decl-specifier-seq
	noexcept-specifier attribute-specifier-seq trailing-return-type
lambda-capture:
	capture-default
	capture-list
	capture-default , capture-list
capture-default:
	&
	=
capture-list:
	capture ...
	capture-list , capture ...
capture:
	simple-capture
	init-capture
simple-capture:
	identifier
	& identifier
	this
	* this
init-capture:
	identifier initializer
	& identifier initializer
fold-expression:
	( cast-expression fold-operator ... )
	( ... fold-operator cast-expression )
	( cast-expression fold-operator ... fold-operator cast-expression )
fold-operator: one of
	+   -   *   /   %   ^   &   |   <<   >> 
	+=  -=  *=  /=  %=  ^=  &=  |=  <<=  >>=  =
	==  !=  <   >   <=  >=  &&  ||  ,    .*   ->*
postfix-expression:
	primary-expression
	postfix-expression [ expr-or-braced-init-list ]
	postfix-expression ( expression-list )
	simple-type-specifier ( expression-list )
	typename-specifier ( expression-list )
	simple-type-specifier braced-init-list
	typename-specifier braced-init-list
	postfix-expression . template id-expression
	postfix-expression -> template id-expression
	postfix-expression . pseudo-destructor-name
	postfix-expression -> pseudo-destructor-name
	postfix-expression ++
	postfix-expression --
	dynamic_cast < type-id > ( expression )
	static_cast < type-id > ( expression )
	reinterpret_cast < type-id > ( expression )
	const_cast < type-id > ( expression )
	typeid ( expression )
	typeid ( type-id )
expression-list:
	initializer-list
pseudo-destructor-name:
	nested-name-specifier type-name ::~ type-name
	nested-name-specifier template simple-template-id ::~ type-name
	~ type-name
	~ decltype-specifier
unary-expression:
	postfix-expression
	++ cast-expression
	-- cast-expression
	unary-operator cast-expression
	sizeof unary-expression
	sizeof ( type-id )
	sizeof ... ( identifier )
	alignof ( type-id )
	noexcept-expression
	new-expression
	delete-expression
unary-operator: one of
	*  &  +  -  !  ~
new-expression:
	:: new new-placement new-type-id new-initializer 
	:: new new-placement ( type-id ) new-initializer
new-placement:
	( expression-list )
new-type-id:
	type-specifier-seq new-declarator
new-declarator:
	ptr-operator new-declarator 
	noptr-new-declarator
noptr-new-declarator:
	[ expression ] attribute-specifier-seq
	noptr-new-declarator [ constant-expression ] attribute-specifier-seq
new-initializer:
	( expression-list )
	braced-init-list
delete-expression:
	:: delete cast-expression
	:: delete [ ] cast-expression
noexcept-expression:
	noexcept ( expression )
cast-expression:
	unary-expression
	( type-id ) cast-expression
pm-expression:
	cast-expression
	pm-expression .* cast-expression
	pm-expression ->* cast-expression
multiplicative-expression:
	pm-expression
	multiplicative-expression * pm-expression
	multiplicative-expression / pm-expression
	multiplicative-expression % pm-expression
additive-expression:
	multiplicative-expression
	additive-expression + multiplicative-expression
	additive-expression - multiplicative-expression
shift-expression:
	additive-expression
	shift-expression << additive-expression
	shift-expression >> additive-expression
relational-expression:
	shift-expression
	relational-expression < shift-expression
	relational-expression > shift-expression
	relational-expression <= shift-expression
	relational-expression >= shift-expression
equality-expression:
	relational-expression
	equality-expression == relational-expression
	equality-expression != relational-expression
and-expression:
	equality-expression
	and-expression & equality-expression
exclusive-or-expression:
	and-expression
	exclusive-or-expression ^ and-expression
inclusive-or-expression:
	exclusive-or-expression
	inclusive-or-expression | exclusive-or-expression
logical-and-expression:
	inclusive-or-expression
	logical-and-expression && inclusive-or-expression
logical-or-expression:
	logical-and-expression
	logical-or-expression || logical-and-expression
conditional-expression:
	logical-or-expression
	logical-or-expression ? expression : assignment-expression
throw-expression:
	throw  assignment-expression
assignment-expression:
	conditional-expression
	logical-or-expression assignment-operator initializer-clause
	throw-expression
assignment-operator: one of
	=  *=  /=  %=   +=  -=  >>=  <<=  &=  ^=  |=
expression:
	assignment-expression
	expression , assignment-expression
constant-expression:
	conditional-expression

A.5 Statements [gram.stmt]

statement:
	labeled-statement
	attribute-specifier-seq expression-statement
	attribute-specifier-seq compound-statement
	attribute-specifier-seq selection-statement
	attribute-specifier-seq iteration-statement
	attribute-specifier-seq jump-statement
	declaration-statement
	attribute-specifier-seq try-block

init-statement:
	expression-statement
	simple-declaration

condition:
	expression
	attribute-specifier-seq decl-specifier-seq declarator brace-or-equal-initializer
labeled-statement:
	attribute-specifier-seq identifier : statement
	attribute-specifier-seq case constant-expression : statement
	attribute-specifier-seq default : statement
expression-statement:
	expression ;
compound-statement:
	{ statement-seq }
statement-seq:
	statement
	statement-seq statement
selection-statement:
	if constexpr ( init-statement condition ) statement
	if constexpr ( init-statement condition ) statement else statement
	switch ( init-statement condition ) statement
iteration-statement:
	while ( condition ) statement
	do statement while ( expression ) ;
	for ( init-statement condition ; expression ) statement
	for ( for-range-declaration : for-range-initializer ) statement
for-range-declaration:
	attribute-specifier-seq decl-specifier-seq declarator
	attribute-specifier-seq decl-specifier-seq ref-qualifier [ identifier-list ]
for-range-initializer:
	expr-or-braced-init-list
jump-statement:
	break ;
	continue ;
	return expr-or-braced-init-list ;
	goto identifier ;
declaration-statement:
	block-declaration

A.6 Declarations [gram.dcl]

declaration-seq:
	declaration
	declaration-seq declaration
declaration:
	block-declaration
	nodeclspec-function-declaration
	function-definition
	template-declaration
	deduction-guide
	explicit-instantiation
	explicit-specialization
	linkage-specification
	namespace-definition
	empty-declaration
	attribute-declaration
block-declaration:
	simple-declaration
	asm-definition
	namespace-alias-definition
	using-declaration
	using-directive
	static_assert-declaration
	alias-declaration
	opaque-enum-declaration
nodeclspec-function-declaration:
	attribute-specifier-seq declarator ;
alias-declaration:
	using identifier attribute-specifier-seq = defining-type-id ;
simple-declaration:
	decl-specifier-seq init-declarator-list ;
	attribute-specifier-seq decl-specifier-seq init-declarator-list ;
	attribute-specifier-seq decl-specifier-seq ref-qualifier [ identifier-list ] initializer ;
static_assert-declaration:
	static_assert ( constant-expression ) ;
	static_assert ( constant-expression , string-literal ) ;
empty-declaration:
	;
attribute-declaration:
	attribute-specifier-seq ;
decl-specifier:
	storage-class-specifier
	defining-type-specifier
	function-specifier
	friend
	typedef
	constexpr
	inline
decl-specifier-seq:
	decl-specifier attribute-specifier-seq
	decl-specifier decl-specifier-seq
storage-class-specifier:
	static
	thread_local
	extern
	mutable
function-specifier:
	virtual
	explicit
typedef-name:
	identifier
type-specifier:
	simple-type-specifier
	elaborated-type-specifier
	typename-specifier
	cv-qualifier
type-specifier-seq:
	type-specifier attribute-specifier-seq
	type-specifier type-specifier-seq
defining-type-specifier:
	type-specifier
	class-specifier
	enum-specifier
defining-type-specifier-seq:
	defining-type-specifier attribute-specifier-seq
	defining-type-specifier defining-type-specifier-seq
simple-type-specifier:
	nested-name-specifier type-name
	nested-name-specifier template simple-template-id
	nested-name-specifier template-name
	char
	char16_t
	char32_t
	wchar_t
	bool
	short
	int
	long
	signed
	unsigned
	float
	double
	void
	auto
	decltype-specifier
type-name:
	class-name
	enum-name
	typedef-name
	simple-template-id
decltype-specifier:
	decltype ( expression )
	decltype ( auto )
elaborated-type-specifier:
	class-key attribute-specifier-seq nested-name-specifier identifier
	class-key simple-template-id
	class-key nested-name-specifier template simple-template-id
	enum nested-name-specifier identifier
enum-name:
	identifier
enum-specifier:
	enum-head { enumerator-list }
	enum-head { enumerator-list , }
enum-head:
	enum-key attribute-specifier-seq enum-head-name enum-base
enum-head-name:
	nested-name-specifier identifier
opaque-enum-declaration:
	enum-key attribute-specifier-seq nested-name-specifier identifier enum-base ;
enum-key:
	enum
	enum class
	enum struct
enum-base:
	: type-specifier-seq
enumerator-list:
	enumerator-definition
	enumerator-list , enumerator-definition
enumerator-definition:
	enumerator
	enumerator = constant-expression
enumerator:
	identifier attribute-specifier-seq
namespace-name:
	identifier
	namespace-alias
namespace-definition:
	named-namespace-definition
	unnamed-namespace-definition
	nested-namespace-definition
named-namespace-definition:
	inline namespace attribute-specifier-seq identifier { namespace-body }
unnamed-namespace-definition:
	inline namespace attribute-specifier-seq { namespace-body }
nested-namespace-definition:
	namespace enclosing-namespace-specifier :: identifier { namespace-body }
enclosing-namespace-specifier:
	identifier
	enclosing-namespace-specifier :: identifier
namespace-body:
	declaration-seq
namespace-alias:
	identifier
namespace-alias-definition:
	namespace identifier = qualified-namespace-specifier ;
qualified-namespace-specifier:
	nested-name-specifier namespace-name
using-declaration:
	using using-declarator-list ;
using-declarator-list:
	using-declarator ...
	using-declarator-list , using-declarator ...
using-declarator:
	typename nested-name-specifier unqualified-id
using-directive:
	attribute-specifier-seq using  namespace nested-name-specifier namespace-name ;
asm-definition:
	attribute-specifier-seq asm ( string-literal ) ;
linkage-specification:
	extern string-literal { declaration-seq }
	extern string-literal declaration
attribute-specifier-seq:
	attribute-specifier-seq attribute-specifier
attribute-specifier:
	[ [ attribute-using-prefix attribute-list ] ]
	alignment-specifier
alignment-specifier:
	alignas ( type-id ... )
	alignas ( constant-expression ... )
attribute-using-prefix:
	using attribute-namespace :
attribute-list:
	attribute
	attribute-list , attribute
	attribute ...
	attribute-list , attribute ...
attribute:
	attribute-token attribute-argument-clause
attribute-token:
	identifier
	attribute-scoped-token
attribute-scoped-token:
	attribute-namespace :: identifier
attribute-namespace:
	identifier
attribute-argument-clause:
	( balanced-token-seq )
balanced-token-seq:
	balanced-token
	balanced-token-seq balanced-token
balanced-token:
	( balanced-token-seq )
	[ balanced-token-seq ]
	{ balanced-token-seq }
	any token other than a parenthesis, a bracket, or a brace

A.7 Declarators [gram.decl]

init-declarator-list:
	init-declarator
	init-declarator-list , init-declarator
init-declarator:
	declarator initializer
declarator:
	ptr-declarator
	noptr-declarator parameters-and-qualifiers trailing-return-type
ptr-declarator:
	noptr-declarator
	ptr-operator ptr-declarator
noptr-declarator:
	declarator-id attribute-specifier-seq
	noptr-declarator parameters-and-qualifiers
	noptr-declarator [ constant-expression ] attribute-specifier-seq
	( ptr-declarator )
parameters-and-qualifiers:
	( parameter-declaration-clause ) cv-qualifier-seq
ref-qualifier noexcept-specifier attribute-specifier-seq
trailing-return-type:
	-> type-id
ptr-operator:
	* attribute-specifier-seq cv-qualifier-seq
	& attribute-specifier-seq
	&& attribute-specifier-seq
	nested-name-specifier * attribute-specifier-seq cv-qualifier-seq
cv-qualifier-seq:
	cv-qualifier cv-qualifier-seq
cv-qualifier:
	const
	volatile
ref-qualifier:
	&
	&&
declarator-id:
	... id-expression
type-id:
	type-specifier-seq abstract-declarator
defining-type-id:
	defining-type-specifier-seq abstract-declarator
abstract-declarator:
	ptr-abstract-declarator
	noptr-abstract-declarator parameters-and-qualifiers trailing-return-type
	abstract-pack-declarator
ptr-abstract-declarator:
	noptr-abstract-declarator
	ptr-operator ptr-abstract-declarator
noptr-abstract-declarator:
	noptr-abstract-declarator parameters-and-qualifiers
	noptr-abstract-declarator [ constant-expression ] attribute-specifier-seq
	( ptr-abstract-declarator )
abstract-pack-declarator:
	noptr-abstract-pack-declarator
	ptr-operator abstract-pack-declarator
noptr-abstract-pack-declarator:
	noptr-abstract-pack-declarator parameters-and-qualifiers
	noptr-abstract-pack-declarator [ constant-expression ] attribute-specifier-seq
	...
parameter-declaration-clause:
	parameter-declaration-list ...
	parameter-declaration-list , ...
parameter-declaration-list:
	parameter-declaration
	parameter-declaration-list , parameter-declaration
parameter-declaration:
	attribute-specifier-seq decl-specifier-seq declarator
	attribute-specifier-seq decl-specifier-seq declarator = initializer-clause
	attribute-specifier-seq decl-specifier-seq abstract-declarator
	attribute-specifier-seq decl-specifier-seq abstract-declarator = initializer-clause
function-definition:
	attribute-specifier-seq decl-specifier-seq declarator virt-specifier-seq function-body
function-body:
	ctor-initializer compound-statement
	function-try-block
	= default ;
	= delete ;
initializer:
	brace-or-equal-initializer
	( expression-list )
brace-or-equal-initializer:
	= initializer-clause
	braced-init-list
initializer-clause:
	assignment-expression
	braced-init-list
initializer-list:
	initializer-clause ...
	initializer-list , initializer-clause ...
braced-init-list:
	{ initializer-list , }
	{ }
expr-or-braced-init-list:
	expression
	braced-init-list

A.8 Classes [gram.class]

class-name:
	identifier
	simple-template-id
class-specifier:
	class-head { member-specification }
class-head:
	class-key attribute-specifier-seq class-head-name class-virt-specifier base-clause
	class-key attribute-specifier-seq base-clause
class-head-name:
	nested-name-specifier class-name
class-virt-specifier:
	final
class-key:
	class
	struct
	union
member-specification:
	member-declaration member-specification
	access-specifier : member-specification
member-declaration:
	attribute-specifier-seq decl-specifier-seq member-declarator-list ;
	function-definition
	using-declaration
	static_assert-declaration
	template-declaration
	deduction-guide
	alias-declaration
	empty-declaration
member-declarator-list:
	member-declarator
	member-declarator-list , member-declarator
member-declarator:
	declarator virt-specifier-seq pure-specifier
	declarator brace-or-equal-initializer
	identifier attribute-specifier-seq : constant-expression
virt-specifier-seq:
	virt-specifier
	virt-specifier-seq virt-specifier
virt-specifier:
	override
	final
pure-specifier:
	= 0

A.9 Derived classes [gram.derived]

base-clause:
	: base-specifier-list
base-specifier-list:
	base-specifier ...
	base-specifier-list , base-specifier ...
base-specifier:
	attribute-specifier-seq class-or-decltype
	attribute-specifier-seq virtual access-specifier class-or-decltype
	attribute-specifier-seq access-specifier virtual class-or-decltype
class-or-decltype:
	nested-name-specifier class-name
	nested-name-specifier template simple-template-id
	decltype-specifier
access-specifier:
	private
	protected
	public

A.10 Special member functions [gram.special]

conversion-function-id:
	operator conversion-type-id
conversion-type-id:
	type-specifier-seq conversion-declarator
conversion-declarator:
	ptr-operator conversion-declarator
ctor-initializer:
	: mem-initializer-list
mem-initializer-list:
	mem-initializer ...
	mem-initializer-list , mem-initializer ...
mem-initializer:
	mem-initializer-id ( expression-list )
	mem-initializer-id braced-init-list
mem-initializer-id:
	class-or-decltype
	identifier

A.11 Overloading [gram.over]

operator-function-id:
	operator operator
operator: one of
	new	delete	new[]	delete[]
	+	-	*	/	%	^	&	|	~
	!	=	<	>	+=	-=	*=	/=	%=
	^=	&=	|=	<<	>>	>>=	<<=	==	!=
	<=	>=	&&	||	++	--	,	->*	->
	()	[]
literal-operator-id:
	operator string-literal identifier
	operator user-defined-string-literal

A.12 Templates [gram.temp]

template-declaration:
	template < template-parameter-list > declaration
template-parameter-list:
	template-parameter
	template-parameter-list , template-parameter
template-parameter:
	type-parameter
	parameter-declaration
type-parameter:
	type-parameter-key ... identifier
	type-parameter-key identifier = type-id
	template < template-parameter-list > type-parameter-key ... identifier
	template < template-parameter-list > type-parameter-key identifier = id-expression
type-parameter-key:
	class
	typename
simple-template-id:
	template-name < template-argument-list >
template-id:
	simple-template-id
	operator-function-id < template-argument-list >
	literal-operator-id < template-argument-list >
template-name:
	identifier
template-argument-list:
	template-argument ...
	template-argument-list , template-argument ...
template-argument:
	constant-expression
	type-id
	id-expression
typename-specifier:
	typename nested-name-specifier identifier
	typename nested-name-specifier template simple-template-id
explicit-instantiation:
	extern template declaration
explicit-specialization:
	template < > declaration
deduction-guide:
	explicit template-name ( parameter-declaration-clause ) -> simple-template-id ;

A.13 Exception handling [gram.except]

try-block:
	try compound-statement handler-seq
function-try-block:
	try ctor-initializer compound-statement handler-seq
handler-seq:
	handler handler-seq
handler:
	catch ( exception-declaration ) compound-statement
exception-declaration:
	attribute-specifier-seq type-specifier-seq declarator
	attribute-specifier-seq type-specifier-seq abstract-declarator
	...
noexcept-specifier:
	noexcept ( constant-expression )
	noexcept
	throw ( )

A.14 Preprocessing directives [gram.cpp]

preprocessing-file:
	group
group:
	group-part
	group group-part
group-part:
	control-line
	if-section
	text-line
	# conditionally-supported-directive
control-line:
	# include		pp-tokens new-line
	# define		identifier replacement-list new-line
	# define		identifier lparen identifier-list ) replacement-list new-line
	# define		identifier lparen ... ) replacement-list new-line
	# define		identifier lparen identifier-list , ... ) replacement-list new-line
	# undef		identifier new-line
	# line		pp-tokens new-line
	# error		pp-tokens new-line
	# pragma		pp-tokens new-line
	# new-line
if-section:
	if-group elif-groups else-group endif-line
if-group:
	# if		constant-expression new-line group
	# ifdef		identifier new-line group
	# ifndef		identifier new-line group
elif-groups:
	elif-group
	elif-groups elif-group
elif-group:
	# elif		constant-expression new-line group
else-group:
	# else		new-line group
endif-line:
	# endif		new-line
text-line:
	pp-tokens new-line
conditionally-supported-directive:
	pp-tokens new-line
lparen:
	a ( character not immediately preceded by white-space
identifier-list:
	identifier
	identifier-list , identifier
replacement-list:
	pp-tokens
pp-tokens:
	preprocessing-token
	pp-tokens preprocessing-token
new-line:
	the new-line character
defined-macro-expression:
	defined identifier
	defined ( identifier )
h-preprocessing-token:
	any preprocessing-token other than >
h-pp-tokens:
	h-preprocessing-token
	h-pp-tokens h-preprocessing-token
has-include-expression:
	__has_­include ( < h-char-sequence > )
	__has_­include ( " q-char-sequence " )
	__has_­include (   string-literal  )
	__has_­include ( < h-pp-tokens     > )