6 Basics [basic]

6.1 Preamble [basic.pre]

[Note 1:

This Clause presents the basic concepts of the C++ language.

It explains the difference between an object and a name and how they relate to the value categories for expressions.

It introduces the concepts of a declaration and a definition and presents C++'s notion of type, scope, linkage, and storage duration.

The mechanisms for starting and terminating a program are discussed.

Finally, this Clause presents the fundamental types of the language and lists the ways of constructing compound types from these.

— end note]

[Note 2:

This Clause does not cover concepts that affect only a single part of the language.

Such concepts are discussed in the relevant Clauses.

— end note]

An entity is a value, object, reference, structured binding, function, enumerator, type, class member, bit-field, template, template specialization, namespace, or pack.

A name is an identifier ([lex.name]), operator-function-id ([over.oper]), literal-operator-id ([over.literal]), or conversion-function-id ([class.conv.fct]).

Every name is introduced by a declaration, which is a

(5.1)
declaration, block-declaration, or member-declaration ([dcl.pre], [class.mem]),
(5.2)
init-declarator ([dcl.decl]),
(5.3)
identifier in a structured binding declaration ([dcl.struct.bind]),
(5.4)
init-capture ([expr.prim.lambda.capture]),
(5.5)
condition with a declarator ([stmt.pre]),
(5.6)
member-declarator ([class.mem]),
(5.7)
using-declarator ([namespace.udecl]),
(5.8)
parameter-declaration ([dcl.fct]),
(5.9)
type-parameter ([temp.param]),
(5.10)
elaborated-type-specifier that introduces a name ([dcl.type.elab]),
(5.11)
class-specifier ([class.pre]),
(5.12)
enum-specifier or enumerator-definition ([dcl.enum]),
(5.13)
exception-declaration ([except.pre]), or
(5.14)
implicit declaration of an injected-class-name ([class.pre]).

[Note 3:

The interpretation of a for-range-declaration produces one or more of the above ([stmt.ranged]).

— end note]

An entity E is denoted by the name (if any) that is introduced by a declaration of E or by a typedef-name introduced by a declaration specifying E.

A variable is introduced by the declaration of a reference other than a non-static data member or of an object.

The variable's name, if any, denotes the reference or object.

A local entity is a variable with automatic storage duration, a structured binding whose corresponding variable is such an entity, or the *this object ([expr.prim.this]).

Some names denote types or templates.

In general, whenever a name is encountered it is necessary to determine whether that name denotes one of these entities before continuing to parse the program that contains it.

The process that determines this is called name lookup ([basic.lookup]).

Two names are the same if

(9.1)
they are identifiers composed of the same character sequence, or
(9.2)
they are operator-function-ids formed with the same operator, or
(9.3)
they are conversion-function-ids formed with equivalent ([temp.over.link]) types, or
(9.4)
they are literal-operator-ids ([over.literal]) formed with the same literal suffix identifier.

A name used in more than one translation unit can potentially refer to the same entity in these translation units depending on the linkage of the name specified in each translation unit.