Anidentifier is an arbitrarily long sequence of digits, underscores, lowercase and uppercase Latin letters, and most Unicode characters.

The first character of a valid identifier must be one of the following:

• uppercase Latin letters A-Z
• lowercase Latin letters a-z
• underscore
• any Unicode character with the Unicode propertyXID_Start

Any other character of a valid identifier must be one of the following:

• digits 0-9
• uppercase Latin letters A-Z
• lowercase Latin letters a-z
• underscore
• any Unicode character with the Unicode propertyXID_Continue

The lists of characters with properties XID_Start and XID_Continue can be found inDerivedCoreProperties.txt.

Identifiers are case-sensitive (lowercase and uppercase letters are distinct), and every character is significant. Every identifier must conform toNormalization Form C.

Note: Support of Unicode identifiers is limited in most implementations, e.g.gcc (until 10).

[edit]In declarations

An identifier can be usedto name objects, references, functions, enumerators, types, class members, namespaces, templates, template specializations, parameter packs(since C++11), goto labels, and other entities, with the following exceptions:

• The identifiers that arekeywords cannot be used for other purposes.

• The identifiers that arealternative representations for certain operators and punctuators cannot be used for other purposes.

• Identifiersthat appear as a token or preprocessing token (i.e., not inuser-defined-string-literal likeoperator""id)(since C++11) of one of the following forms are reserved:
  • in the global namespace, identifiers that begin with an underscore
  • identifiers that contain a double underscore or begin with an underscore followed by an uppercase letter, except the following identifiers:

• predefined macros (includinglanguage feature test macros)(since C++20)

• the following macros defined in the standard library:

• the C-style I/O library macros_IOFBF,_IOLBF and_IONBF

“Reserved” here means that the standard library headers#define or declare such identifiers for their internal needs, the compiler may predefine non-standard identifiers of that kind, and that name mangling algorithm may assume that some of these identifiers are not in use. If the programmer uses such identifiers, the program is ill-formed, no diagnostic required.

In addition, it is undefined behavior to#define or#undef certain names in a translation unit, seereserved macro names for more details.

[edit]Zombie identifiers

As of C++14, some identifiers are removed from the C++ standard library. They are listed in thelist of zombie names.

However, these identifiers are still reserved for previous standardization in a certain context. Removed member function names may not be used as a name for function-like macros, and other removed member names may not be used as a name for object-like macros in portable code.

[edit]In expressions

An identifier that names a variable, a function,specialization of aconcept,(since C++20) or an enumerator can be used as anexpression. The result of an expression consisting of just the identifier is the entity named by the identifier. Thevalue category of the expression islvalue if the identifier names a function, a variable, atemplate parameter object(since C++20), or a data member, andrvalue(until C++11)prvalue(since C++11) otherwise (e.g. anenumerator isan rvalue(until C++11)a prvalue(since C++11) expression, a specialization of a concept is a bool prvalue(since C++20)).

[edit]Type

The type of an identifier expression is the same as the type of the entity it names.

void f(){float x,&r= x; [=]{        decltype(x) y1;// y1 has type float        decltype((x)) y2= y1;// y2 has type float const& because this lambda// is not mutable and x is an lvalue        decltype(r) r1= y1;// r1 has type float&        decltype((r)) r2= y2;// r2 has type float const&};}

[edit]Unqualified identifiers

Besides suitably declared identifiers, the following can be used in expressions in the same role:

• anoverloaded operator name in function notation, such asoperator+ oroperator new;
• auser-defined conversion function name, such asoperatorbool;

• atemplate name followed by its argument list, such asMyTemplate<int>;
• the character~ followed by a class name, such as~MyClass;

Together with identifiers they are known asunqualified identifier expressions.

[edit]Qualified identifiers

Aqualified identifier expression is an unqualified identifier expression prepended by a scope resolution operator::, and optionally, a sequence of any of the following separated by scope resolution operators:

• a namespace name;
• a class name;

For example, the expressionstd::string::npos is an expression that names the static membernpos in the classstring in namespacestd. The expression::tolower names the functiontolower in the global namespace. The expression::std::cout names the global variablecout in namespacestd, which is a top-level namespace. The expressionboost::signals2::connection names the typeconnection declared in namespacesignals2, which is declared in namespaceboost.

The keywordtemplate may appear in qualified identifiers as necessary to disambiguatedependent template names.

Seequalified lookup for the details of the name lookup for qualified identifiers.

[edit]Implicit member access transformation

If an identifier expressionE denotes a non-static non-type member of some classC and all following conditions are satisfied,E is transformed into the class member access expressionthis->E:

• E is not the right operand of amember access operator.
• IfE is a qualified identifier expression,E is not the un-parenthesized operand of anaddress-of operator.
• Any of the following conditions is satisfied:

• E ispotentially evaluated.
• C is the innermost enclosing class atE.
• C is a base class of the innermost enclosing class atE.

This transformation does not apply in the template definition context (seedependent names).

struct X{int x;}; struct B{int b;}; struct D: B{    X d; void func(){        d;// OK, will be transformed into this->d        b;// OK, will be transformed into this->b        x;// Error: this->x is ill-formed         d.x;// OK, will be transformed into this->d.x// instead of d.this->x or this->d.this->x}};

[edit]Names

Aname is the use of one of the following to refer to an entity:

• an identifier
• an overloaded operator name in function notation (operator+,operator new)
• a user-defined conversion function name (operatorbool)

• a template name followed by its argument list (MyTemplate<int>)

Every name is introduced into the program by adeclaration. A name used in more than one translation unit may refer to the same or different entities, depending onlinkage.

When the compiler encounters an unknown name in a program, it associates it with the declaration that introduced the name by means ofname lookup, except for thedependent names in template declarations and definitions (for those names, the compiler determines whether they name a type, a template, or some other entity, which may requireexplicit disambiguation).

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]See also

• In other languages

• Español
• 日本語
• Русский
• 中文