1 - Grammar summary (informative) [gram]

-1- This summary of C++ syntax 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.

1.1 - Keywords [gram.key]

-1- New context-dependent keywords are introduced into a program by typedef (dcl.typedef), namespace (namespace.def), class (clause class), enumeration (dcl.enum), and template (clause temp) declarations.

typedef-name:
	identifier
namespace-name:
	original-namespace-name
	namespace-alias

original-namespace-name:
	identifier

namespace-alias:
	identifier
class-name:
	identifier
	template-id
enum-name:
	identifier
template-name:
	identifier
Note that a typedef-name naming a class is also a class-name (class.name).

1.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
	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 nondigit
	pp-number e sign
	pp-number E sign
	pp-number .
identifier:
	nondigit
	identifier nondigit
	identifier digit
nondigit: one of
	universal-character-name
	_ 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
integer-literal:
	decimal-literal integer-suffixopt
	octal-literal integer-suffixopt
	hexadecimal-literal integer-suffixopt
decimal-literal:
	nonzero-digit
	decimal-literal digit
octal-literal:
	0
	octal-literal octal-digit
hexadecimal-literal:
	0x hexadecimal-digit
	0X hexadecimal-digit
	hexadecimal-literal hexadecimal-digit
nonzero-digit: one of
	1  2  3  4  5  6  7  8  9
octal-digit: one of
	0  1  2  3  4  5  6  7
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-suffixopt
	long-suffix unsigned-suffixopt
unsigned-suffix: one of
	u  U
long-suffix: one of
	l  L
character-literal:
	'c-char-sequence'
	L'c-char-sequence'
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:
	fractional-constant exponent-partopt floating-suffixopt
	digit-sequence exponent-part floating-suffixopt
fractional-constant:
	digit-sequenceopt . digit-sequence
	digit-sequence .
exponent-part:
	e signopt digit-sequence
	E signopt digit-sequence
sign: one of
	+  -
digit-sequence:
	digit
	digit-sequence digit
floating-suffix: one of
	f  l  F  L
string-literal:
	"s-char-sequenceopt"
	L"s-char-sequenceopt"
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
boolean-literal:
	false
	true

1.3 - Basic concepts [gram.basic]

translation-unit:
        declaration-seqopt

1.4 - Expressions [gram.expr]

primary-expression:
	literal
	this
	( expression )
	id-expression

id-expression:
	unqualified-id
	qualified-id

unqualified-id:
	identifier
	operator-function-id
	conversion-function-id
	~ class-name
	template-id
qualified-id:
	::opt nested-name-specifier templateopt unqualified-id
	:: identifier
	:: operator-function-id
	:: template-id

nested-name-specifier:
	class-or-namespace-name :: nested-name-specifieropt 
	class-or-namespace-name :: template nested-name-specifier

class-or-namespace-name:
	class-name
	namespace-name
postfix-expression:
	primary-expression
	postfix-expression [ expression ]
	postfix-expression ( expression-listopt )
	simple-type-specifier ( expression-listopt )
	typename ::opt  nested-name-specifier identifier ( expression-listopt )
	typename ::opt  nested-name-specifier templateopt  template-id ( expression-listopt )
	postfix-expression . templateopt id-expression
	postfix-expression -> templateopt 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:
	assignment-expression
	expression-list , assignment-expression
pseudo-destructor-name:
	::opt  nested-name-specifieropt type-name :: ~ type-name
	::opt  nested-name-specifier template template-id :: ~ type-name
	::opt  nested-name-specifieropt ~ type-name
unary-expression:
	postfix-expression
	++  cast-expression
	--  cast-expression
	unary-operator cast-expression
	sizeof unary-expression
	sizeof ( type-id )
	new-expression
	delete-expression
unary-operator: one of
	*  &  +  -  !  ~
new-expression:
	::opt new new-placementopt new-type-id new-initializeropt
	::opt new new-placementopt ( type-id ) new-initializeropt
new-placement:
	( expression-list )
new-type-id:
	type-specifier-seq new-declaratoropt
new-declarator:
	ptr-operator new-declaratoropt
	direct-new-declarator
direct-new-declarator:
	[ expression ]
	direct-new-declarator [ constant-expression ]
new-initializer:
	( expression-listopt )
delete-expression:
	::opt delete cast-expression
	::opt delete [ ] cast-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
assignment-expression:
	conditional-expression
	logical-or-expression assignment-operator assignment-expression
	throw-expression
assignment-operator: one of
	=  *=  /=  %=   +=  -=  >>=  <<=  &=  ^=  |=
expression:
	assignment-expression
	expression , assignment-expression
constant-expression:
	conditional-expression

1.5 - Statements [gram.stmt.stmt]

statement:
	labeled-statement
	expression-statement
	compound-statement
	selection-statement
	iteration-statement
	jump-statement
	declaration-statement
	try-block
labeled-statement:
	identifier : statement
	case constant-expression : statement
	default : statement
expression-statement:
	expressionopt ;
compound-statement:
	 { statement-seqopt }
statement-seq:
	statement
	statement-seq statement
selection-statement:
	if ( condition ) statement
	if ( condition ) statement else statement
	switch ( condition ) statement
condition:
	expression
	type-specifier-seq declarator = assignment-expression
iteration-statement:
	while ( condition ) statement
	do statement  while ( expression ) ;
	for ( for-init-statement conditionopt ; expressionopt ) statement
for-init-statement:
	expression-statement
	simple-declaration
jump-statement:
	break ;
	continue ;
	return expressionopt ;
	goto identifier ;
declaration-statement:
	block-declaration

1.6 - Declarations [gram.dcl.dcl]

declaration-seq:
	declaration
	declaration-seq declaration
declaration:
	block-declaration
	function-definition
	template-declaration
	explicit-instantiation
	explicit-specialization
	linkage-specification
	namespace-definition
block-declaration:
	simple-declaration
	asm-definition
	namespace-alias-definition
	using-declaration
	using-directive
simple-declaration:
	decl-specifier-seqopt init-declarator-listopt ;
decl-specifier:
	storage-class-specifier
	type-specifier
	function-specifier
	friend
	typedef
decl-specifier-seq:
	decl-specifier-seqopt decl-specifier
storage-class-specifier:
	auto
	register
	static
	extern
	mutable
function-specifier:
	inline
	virtual
	explicit
typedef-name:
	identifier
type-specifier:
	simple-type-specifier
	class-specifier
	enum-specifier
	elaborated-type-specifier
	cv-qualifier
simple-type-specifier:
	::opt nested-name-specifieropt type-name
	::opt nested-name-specifier template template-id
	char
	wchar_t
	bool
	short
	int
	long
	signed
	unsigned
	float
	double
	void
type-name:
	class-name
	enum-name
	typedef-name
elaborated-type-specifier:
	class-key ::opt nested-name-specifieropt identifier
	enum ::opt nested-name-specifieropt identifier
	typename ::opt  nested-name-specifier identifier
	typename ::opt  nested-name-specifier templateopt template-id
enum-name:
	identifier
enum-specifier:
	enum identifieropt { enumerator-listopt }
enumerator-list:
	enumerator-definition
	enumerator-list , enumerator-definition
enumerator-definition:
	enumerator
	enumerator = constant-expression
enumerator:
	identifier
namespace-name:
        original-namespace-name
        namespace-alias
original-namespace-name:
        identifier

namespace-definition:
        named-namespace-definition
        unnamed-namespace-definition

named-namespace-definition:
        original-namespace-definition
        extension-namespace-definition

original-namespace-definition:
        namespace identifier { namespace-body }

extension-namespace-definition:
        namespace original-namespace-name  { namespace-body }

unnamed-namespace-definition:
        namespace { namespace-body }

namespace-body:
        declaration-seqopt
namespace-alias:
        identifier

namespace-alias-definition:
        namespace identifier = qualified-namespace-specifier ;

qualified-namespace-specifier:
	::opt nested-name-specifieropt namespace-name
using-declaration:
        using typenameopt ::opt nested-name-specifier unqualified-id ;
        using ::  unqualified-id ;
using-directive:
        using  namespace ::opt nested-name-specifieropt namespace-name ;
asm-definition:
	asm ( string-literal ) ;
linkage-specification:
	extern string-literal { declaration-seqopt }
	extern string-literal declaration

1.7 - Declarators [gram.dcl.decl]

init-declarator-list:
	init-declarator
	init-declarator-list , init-declarator
init-declarator:
	declarator initializeropt
declarator:
	direct-declarator
	ptr-operator declarator
direct-declarator:
	declarator-id
	direct-declarator ( parameter-declaration-clause ) cv-qualifier-seqopt exception-specificationopt
	direct-declarator [ constant-expressionopt ]
	( declarator )
ptr-operator:
	* cv-qualifier-seqopt
	&
	::opt nested-name-specifier * cv-qualifier-seqopt
cv-qualifier-seq:
	cv-qualifier cv-qualifier-seqopt
cv-qualifier:
	const
	volatile
declarator-id:
	id-expression
	::opt nested-name-specifieropt type-name
type-id:
	type-specifier-seq abstract-declaratoropt
type-specifier-seq:
	type-specifier type-specifier-seqopt
abstract-declarator:
	ptr-operator abstract-declaratoropt
	direct-abstract-declarator
direct-abstract-declarator:
	direct-abstract-declaratoropt
		( parameter-declaration-clause ) cv-qualifier-seqopt exception-specificationopt
	direct-abstract-declaratoropt [ constant-expressionopt ]
	( abstract-declarator )
parameter-declaration-clause:
	parameter-declaration-listopt ...opt
	parameter-declaration-list , ...
parameter-declaration-list:
	parameter-declaration
	parameter-declaration-list , parameter-declaration
parameter-declaration:
	decl-specifier-seq declarator
	decl-specifier-seq declarator = assignment-expression
	decl-specifier-seq abstract-declaratoropt
	decl-specifier-seq abstract-declaratoropt = assignment-expression
function-definition:
	decl-specifier-seqopt declarator ctor-initializeropt function-body
	decl-specifier-seqopt declarator function-try-block

function-body:
	compound-statement
initializer:
	= initializer-clause
	( expression-list )
initializer-clause:
	assignment-expression
	{ initializer-list ,opt }
	{ }
initializer-list:
	initializer-clause
	initializer-list , initializer-clause

1.8 - Classes [gram.class]

class-name:
	identifier
	template-id
class-specifier:
	class-head { member-specificationopt }
class-head:
	class-key identifieropt base-clauseopt
	class-key nested-name-specifier identifier base-clauseopt
	class-key nested-name-specifieropt template-id base-clauseopt
class-key:
	class
	struct
	union
member-specification:
	member-declaration member-specificationopt
	access-specifier : member-specificationopt
member-declaration:
	decl-specifier-seqopt member-declarator-listopt ;
	function-definition ;opt
	::opt nested-name-specifier templateopt unqualified-id ;
	using-declaration
	template-declaration
member-declarator-list:
	member-declarator
	member-declarator-list , member-declarator
member-declarator:
	declarator pure-specifieropt
	declarator constant-initializeropt
	identifieropt : constant-expression
pure-specifier:
	 = 0
constant-initializer:
	 = constant-expression

1.9 - Derived classes [gram.class.derived]

base-clause:
	: base-specifier-list
base-specifier-list:
	base-specifier
	base-specifier-list , base-specifier
base-specifier:
	::opt nested-name-specifieropt class-name
	virtual access-specifieropt ::opt nested-name-specifieropt class-name
	access-specifier virtualopt ::opt nested-name-specifieropt class-name
access-specifier:
	private
	protected
	public

1.10 - Special member functions [gram.special]

conversion-function-id:
	operator conversion-type-id
conversion-type-id:
	type-specifier-seq conversion-declaratoropt
conversion-declarator:
	ptr-operator conversion-declaratoropt
ctor-initializer:
	: mem-initializer-list
mem-initializer-list:
	mem-initializer
	mem-initializer , mem-initializer-list
mem-initializer:
	mem-initializer-id ( expression-listopt )
mem-initializer-id:
	::opt nested-name-specifieropt class-name
	identifier

1.11 - Overloading [gram.over]

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

1.12 - Templates [gram.temp]

template-declaration:
	exportopt template < template-parameter-list > declaration
template-parameter-list:
	template-parameter
	template-parameter-list , template-parameter
template-parameter:
	type-parameter
	parameter-declaration
type-parameter:
	class identifieropt
	class identifieropt = type-id
	typename identifieropt
	typename identifieropt = type-id
	template < template-parameter-list > class  identifieropt
	template < template-parameter-list > class  identifieropt = id-expression
template-id:
	template-name < template-argument-listopt >
template-name:
	identifier
template-argument-list:
	template-argument
	template-argument-list , template-argument
template-argument:
	assignment-expression
	type-id
	id-expression
explicit-instantiation:
	template declaration
explicit-specialization:
	template < > declaration

1.13 - Exception handling [gram.except]

try-block:
	 try compound-statement handler-seq
function-try-block:
	 try  ctor-initializeropt function-body handler-seq
handler-seq:
	handler handler-seqopt
handler:
	catch ( exception-declaration ) compound-statement
exception-declaration:
	type-specifier-seq declarator
	type-specifier-seq abstract-declarator
	type-specifier-seq
	...
throw-expression:
	throw assignment-expressionopt
exception-specification:
	throw ( type-id-listopt )
type-id-list:
	type-id
	type-id-list ,  type-id

1.14 - Preprocessing directives [gram.cpp]

preprocessing-file:
	groupopt
group:
	group-part
	group group-part
group-part:
	pp-tokensopt new-line
	if-section
	control-line
if-section:
	if-group elif-groupsopt else-groupopt endif-line
if-group:
	# if     constant-expression new-line groupopt
	# ifdef  identifier new-line groupopt
	# ifndef identifier new-line groupopt
elif-groups:
	elif-group
	elif-groups elif-group
elif-group:
	# elif   constant-expression new-line groupopt
else-group:
	# else   new-line groupopt
endif-line:
	# endif  new-line
control-line:
	# include pp-tokens new-line
	# define  identifier replacement-list new-line
	# define  identifier lparen identifier-listopt ) replacement-list new-line
	# undef   identifier new-line
	# line    pp-tokens new-line
	# error   pp-tokensopt new-line
	# pragma  pp-tokensopt new-line
	#         new-line
lparen:
	the left-parenthesis character without preceding white-space
replacement-list:
	pp-tokensopt
pp-tokens:
	preprocessing-token
	pp-tokens preprocessing-token
new-line:
	the new-line character