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]

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

Two names are the same if

(4.1)
they are identifiers composed of the same character sequence, or
(4.2)
they are conversion-function-ids formed with equivalent ([temp.over.link]) types, or
(4.3)
they are operator-function-ids formed with the same operator, or
(4.4)
they are literal-operator-ids formed with the same literal suffix identifier.

Every name is introduced by a declaration, which is a

(5.1)
name-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)
identifier in a result-name-introducer in a postcondition assertion ([dcl.contract.res]),
(5.5)
init-capture ([expr.prim.lambda.capture]),
(5.6)
condition with a declarator ([stmt.pre]),
(5.7)
member-declarator ([class.mem]),
(5.8)
using-declarator ([namespace.udecl]),
(5.9)
parameter-declaration ([dcl.fct], [temp.param]),
(5.10)
type-parameter ([temp.param]),
(5.11)
type-tt-parameter ([temp.param]),
(5.12)
variable-tt-parameter ([temp.param]),
(5.13)
concept-tt-parameter ([temp.param]),
(5.14)
elaborated-type-specifier that introduces a name ([dcl.type.elab]),
(5.15)
class-specifier ([class.pre]),
(5.16)
enum-specifier or enumerator-definition ([dcl.enum]),
(5.17)
exception-declaration ([except.pre]), or
(5.18)
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]

[Note 4:

Some names denote types or templates.

In general, whenever a name is encountered it is necessary to look it up ([basic.lookup]) to determine whether that name denotes one of these entities before continuing to parse the program that contains it.

— end note]

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

An entity is a variable, structured binding, result binding, function, enumerator, type, type alias, non-static data member, bit-field, template, namespace, namespace alias, template parameter, function parameter, or init-capture.

The underlying entity of an entity is that entity unless otherwise specified.

A name denotes the underlying entity of the entity declared by each declaration that introduces the name.

[Note 5:

Type aliases and namespace aliases have underlying entities that are distinct from themselves.

— end note]

A local entity is a variable with automatic storage duration ([basic.stc.auto]), a structured binding ([dcl.struct.bind]) whose corresponding variable is such an entity, a result binding ([dcl.contract.res]), or the *this object ([expr.prim.this]).

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.