6 Basics [basic]

6.2 Declarations and definitions [basic.def]

A declaration may (re)introduce one or more names and/or entities into a translation unit.

If so, the declaration specifies the interpretation and semantic properties of these names.

A declaration of an entity or typedef-name X is a redeclaration of X if another declaration of X is reachable from it ([module.reach]).

A declaration may also have effects including:

(1.1)
a static assertion ([dcl.pre]),
(1.2)
controlling template instantiation ([temp.explicit]),
(1.3)
guiding template argument deduction for constructors ([temp.deduct.guide]),
(1.4)
use of attributes, and
(1.5)
nothing (in the case of an empty-declaration).

Each entity declared by a declaration is also defined by that declaration unless:

(2.1)
it declares a function without specifying the function's body ([dcl.fct.def]),
(2.2)
it contains the extern specifier ([dcl.stc]) or a linkage-specification15 ([dcl.link]) and neither an initializer nor a function-body,
(2.3)
it declares a non-inline static data member in a class definition ([class.mem], [class.static]),
(2.4)
it declares a static data member outside a class definition and the variable was defined within the class with the constexpr specifier (this usage is deprecated; see [depr.static.constexpr]),
(2.5)
it is an elaborated-type-specifier ([class.name]),
(2.6)
it is an opaque-enum-declaration ([dcl.enum]),
(2.7)
it is a template-parameter ([temp.param]),
(2.8)
it is a parameter-declaration ([dcl.fct]) in a function declarator that is not the declarator of a function-definition,
(2.9)
it is a typedef declaration ([dcl.typedef]),
(2.10)
it is an alias-declaration ([dcl.typedef]),
(2.11)
it is a using-declaration ([namespace.udecl]),
(2.12)
it is a deduction-guide ([temp.deduct.guide]),
(2.13)
it is a static_assert-declaration ([dcl.pre]),
(2.14)
it is an attribute-declaration ([dcl.pre]),
(2.15)
it is an empty-declaration ([dcl.pre]),
(2.16)
it is a using-directive ([namespace.udir]),
(2.17)
it is a using-enum-declaration ([enum.udecl]),
(2.18)
it is a template-declaration ([temp.pre]) whose template-head is not followed by either a concept-definition or a declaration that defines a function, a class, a variable, or a static data member.
(2.19)
it is an explicit instantiation declaration ([temp.explicit]), or
(2.20)
it is an explicit specialization whose declaration is not a definition.

A declaration is said to be a definition of each entity that it defines.

[Example 1:

All but one of the following are definitions: int a; // defines a extern const int c = 1; // defines c int f(int x) { return x+a; } // defines f and defines x struct S { int a; int b; }; // defines S, S::a, and S::b struct X { // defines X int x; // defines non-static data member x static int y; // declares static data member y X(): x(0) { } // defines a constructor of X }; int X::y = 1; // defines X::y enum { up, down }; // defines up and down namespace N { int d; } // defines N and N::d namespace N1 = N; // defines N1 X anX; // defines anX whereas these are just declarations: extern int a; // declares a extern const int c; // declares c int f(int); // declares f struct S; // declares S typedef int Int; // declares Int extern X anotherX; // declares anotherX using N::d; // declares d

— end example]

[Note 1:

In some circumstances, C++ implementations implicitly define the default constructor ([class.default.ctor]), copy constructor, move constructor ([class.copy.ctor]), copy assignment operator, move assignment operator ([class.copy.assign]), or destructor member functions.

— end note]

[Example 2:

Given #include <string> struct C { std::string s; // std::string is the standard library class ([string.classes]) }; int main() { C a; C b = a; b = a; } the implementation will implicitly define functions to make the definition of C equivalent to struct C { std::string s; C() : s() { } C(const C& x): s(x.s) { } C(C&& x): s(static_cast<std::string&&>(x.s)) { } // : s(std::move(x.s)) { } C& operator=(const C& x) { s = x.s; return *this; } C& operator=(C&& x) { s = static_cast<std::string&&>(x.s); return *this; } // { s = std::move(x.s); return *this; } ~C() { } };

— end example]

[Note 2:

A class name can also be implicitly declared by an elaborated-type-specifier ([dcl.type.elab]).

— end note]

In the definition of an object, the type of that object shall not be an incomplete type ([basic.types.general]), an abstract class type ([class.abstract]), or a (possibly multidimensional) array thereof.

15)15)

Appearing inside the brace-enclosed declaration-seq in a linkage-specification does not affect whether a declaration is a definition.