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.

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

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

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 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.