Identifiers - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Identifiers

From cppreference.com
< cpp‎ | language

An identifier is an arbitrary long sequence of digits, underscores, lowercase and uppercase Latin letters, and Unicode characters. A valid identifier must begin with a non-digit character (Latin letter, underscore, or Unicode non-digit character). Identifiers are case-sensitive (lowercase and uppercase letters are distinct), and every character is significant.

Note: C++ grammar formally requires Unicode characters to be escaped with `\u` or `\U`, but due to translation phase 1, that is exactly how raw unicode characters from the source code are presented to the compiler. Also note that support of this feature may be limited, e.g. gcc

### [edit] In declarations

Identifiers can be used to name objects, types, namespaces, and other entities, with the following exceptions:

- the identifiers that are keywords cannot be used for other purposes;
- the identifiers with a double underscore anywhere are reserved;
- the identifiers that begin with an underscore followed by an uppercase letter are reserved;
- the identifiers that begin with an underscore are reserved for use at global namespace.

"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 behavior is undefined.

In addition, it's undefined behavior to #define or #undef names identical to keywords. If at least one standard library header is included, it's undefined behavior to #define or #undef identifiers identical to names declared in any standard library header.

| This section is incomplete Reason: +other contents of 17.6.4.3 [reserved.names]

### [edit] In expressions

An identifier that names an variable or a function can be used as an expression. The expression consisting of just the identifier returns the entity named by the identifier. The value category of the expression is lvalue if the identifier names a function, a variable, or a data member, and it is prvalue otherwise (e.g. an enumerator is a prvalue expression)

Within the body of a non-static member function, each identifier that names a non-static member is implicitly transformed to a class member access expression this->member.

Besides simple names of objects and functions, the following language constructs can be used in expressions in the same role (together with identifiers they are known as id-expressions)

- the name of an operator function, such as operator+ or operator new;
- the name of a user-defined conversion function, such as operator bool;
- the name of a user-defined literal operator function, such as operator "" _km;
- the character ~ followed by class name, such as ~MyClass;
- the character ~ followed by decltype specifier, such as ~decltype(str);
- a template identifier, such as MyTemplate<int>;
- qualified identifiers, such as std::string or ::tolower.

### [edit] Names

A name is the use of one of the following to refer to an entity or to a label:

- an identifier;
- operator in function notation (operator+, operator new);
- user-defined conversion function (operator bool);
- user-defined literal operator (operator "" _km);
- template id (`name<arg, arg>`).

Every name that denotes an entity is introduced into the program by a declaration. Every name that denotes a label is introduced into the program either by a goto statement or by a labeled statement. A name used in more than one translation unit may refer to the same or different entities, depending on linkage.

When the compiler encounters an unknown name in a program, it associates it with the declaration that introduced the name by means of name lookup, except for the dependent 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 require explicit disambiguation)

### [edit] Qualified identifiers

A qualified identifier is an identifier, operator function name, literal operator name, or a template identifier that is prepended by a scope resolution operator ::, and optionally, a sequence of enumeration, (since C++11)class or namespace names or decltype expressions (since C++11) separated by scope resolution operators:

For example, the expression std::string::npos is an id-expression that names the static member npos in the class string in namespace std. The expression ::tolower names the function tolower in the global namespace. The expression ::std::cout names the global variable cout in namespace std, which is a top-level namespace. The qualified identifier boost::signals2::connection names the type connection declared in namespace signals2, which is declared in namespace boost.

The keyword `template` may appear in qualified identifiers as necessary to disambiguate dependent template names.

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

### [edit] See also

C documentation for identifier

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/language/identifiers&oldid=80921"
Category:

- Todo with reason