[basic.def] # 6 Basics [[basic]](./#basic) ## 6.2 Declarations and definitions [basic.def] [1](#1) [#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/basic.tex#L166) A declaration ([[basic.pre]](basic.pre "6.1 Preamble")) may (re)introduce one or more names and/or entities into a translation unit[.](#1.sentence-1) If so, the declaration specifies the interpretation and semantic properties of these names[.](#1.sentence-2) A declaration of an entity X is a redeclaration of X if another declaration of X is reachable from it ([[module.reach]](module.reach "10.7 Reachability")); otherwise, it is a [*first declaration*](#def:declaration,first "6.2 Declarations and definitions [basic.def]")[.](#1.sentence-3) A declaration may also have effects including: - [(1.1)](#1.1) a static assertion ([[dcl.pre]](dcl.pre "9.1 Preamble")), - [(1.2)](#1.2) controlling template instantiation ([[temp.explicit]](temp.explicit "13.9.3 Explicit instantiation")), - [(1.3)](#1.3) guiding template argument deduction for constructors ([[temp.deduct.guide]](temp.deduct.guide "13.7.2.3 Deduction guides")), - [(1.4)](#1.4) use of [attributes](dcl.attr "9.13 Attributes [dcl.attr]"), and - [(1.5)](#1.5) nothing (in the case of an [*empty-declaration*](dcl.pre#nt:empty-declaration "9.1 Preamble [dcl.pre]"))[.](#1.sentence-4) [2](#2) [#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/basic.tex#L188) Each entity declared by a [*declaration*](dcl.pre#nt:declaration "9.1 Preamble [dcl.pre]") is also [*defined*](#def:define "6.2 Declarations and definitions [basic.def]") by that declaration unless: - [(2.1)](#2.1) it declares a function without specifying the function's body ([[dcl.fct.def]](dcl.fct.def "9.6 Function definitions")), - [(2.2)](#2.2) it contains theextern specifier ([[dcl.stc]](dcl.stc "9.2.2 Storage class specifiers")) or a[*linkage-specification*](dcl.link#nt:linkage-specification "9.12 Linkage specifications [dcl.link]")[15](#footnote-15 "Appearing inside the brace-enclosed declaration-seq in a linkage-specification does not affect whether a declaration is a definition.") ([[dcl.link]](dcl.link "9.12 Linkage specifications")) and neither an [*initializer*](dcl.init.general#nt:initializer "9.5.1 General [dcl.init.general]") nor a[*function-body*](dcl.fct.def.general#nt:function-body "9.6.1 General [dcl.fct.def.general]"), - [(2.3)](#2.3) it declares a non-inline static data member in a class definition ([[class.mem]](class.mem "11.4 Class members"), [[class.static]](class.static "11.4.9 Static members")), - [(2.4)](#2.4) it declares a static data member outside a class definition and the variable was defined within the class with the constexpr specifier ([[class.static.data]](class.static.data "11.4.9.3 Static data members")) (this usage is deprecated; see [[depr.static.constexpr]](depr.static.constexpr "D.7 Redeclaration of static constexpr data members")), - [(2.5)](#2.5) it is an [*elaborated-type-specifier*](dcl.type.elab#nt:elaborated-type-specifier "9.2.9.5 Elaborated type specifiers [dcl.type.elab]") ([[class.name]](class.name "11.3 Class names")), - [(2.6)](#2.6) it is an[*opaque-enum-declaration*](dcl.enum#nt:opaque-enum-declaration "9.8.1 Enumeration declarations [dcl.enum]") ([[dcl.enum]](dcl.enum "9.8.1 Enumeration declarations")), - [(2.7)](#2.7) it is a[*template-parameter*](temp.param#nt:template-parameter "13.2 Template parameters [temp.param]") ([[temp.param]](temp.param "13.2 Template parameters")), - [(2.8)](#2.8) it is a[*parameter-declaration*](dcl.fct#nt:parameter-declaration "9.3.4.6 Functions [dcl.fct]") ([[dcl.fct]](dcl.fct "9.3.4.6 Functions")) in a functiondeclarator that is not the [*declarator*](dcl.decl.general#nt:declarator "9.3.1 General [dcl.decl.general]") of a[*function-definition*](dcl.fct.def.general#nt:function-definition "9.6.1 General [dcl.fct.def.general]"), - [(2.9)](#2.9) it is atypedef declaration ([[dcl.typedef]](dcl.typedef "9.2.4 The typedef specifier")), - [(2.10)](#2.10) it is an [*alias-declaration*](dcl.pre#nt:alias-declaration "9.1 Preamble [dcl.pre]") ([[dcl.typedef]](dcl.typedef "9.2.4 The typedef specifier")), - [(2.11)](#2.11) it is a [*namespace-alias-definition*](namespace.alias#nt:namespace-alias-definition "9.9.3 Namespace alias [namespace.alias]") ([[namespace.alias]](namespace.alias "9.9.3 Namespace alias")), - [(2.12)](#2.12) it is a [*using-declaration*](namespace.udecl#nt:using-declaration "9.10 The using declaration [namespace.udecl]") ([[namespace.udecl]](namespace.udecl "9.10 The using declaration")), - [(2.13)](#2.13) it is a [*deduction-guide*](temp.deduct.guide#nt:deduction-guide "13.7.2.3 Deduction guides [temp.deduct.guide]") ([[temp.deduct.guide]](temp.deduct.guide "13.7.2.3 Deduction guides")), - [(2.14)](#2.14) it is a [*static_assert-declaration*](dcl.pre#nt:static_assert-declaration "9.1 Preamble [dcl.pre]") ([[dcl.pre]](dcl.pre "9.1 Preamble")), - [(2.15)](#2.15) it is a [*consteval-block-declaration*](dcl.pre#nt:consteval-block-declaration "9.1 Preamble [dcl.pre]"), - [(2.16)](#2.16) it is an[*attribute-declaration*](dcl.pre#nt:attribute-declaration "9.1 Preamble [dcl.pre]") ([[dcl.pre]](dcl.pre "9.1 Preamble")), - [(2.17)](#2.17) it is an[*empty-declaration*](dcl.pre#nt:empty-declaration "9.1 Preamble [dcl.pre]") ([[dcl.pre]](dcl.pre "9.1 Preamble")), - [(2.18)](#2.18) it is a [*using-directive*](namespace.udir#nt:using-directive "9.9.4 Using namespace directive [namespace.udir]") ([[namespace.udir]](namespace.udir "9.9.4 Using namespace directive")), - [(2.19)](#2.19) it is a [*using-enum-declaration*](enum.udecl#nt:using-enum-declaration "9.8.2 The using enum declaration [enum.udecl]") ([[enum.udecl]](enum.udecl "9.8.2 The using enum declaration")), - [(2.20)](#2.20) it is a [*template-declaration*](temp.pre#nt:template-declaration "13.1 Preamble [temp.pre]") ([[temp.pre]](temp.pre "13.1 Preamble")) whose [*template-head*](temp.pre#nt:template-head "13.1 Preamble [temp.pre]") is not followed by either a [*concept-definition*](temp.concept#nt:concept-definition "13.7.9 Concept definitions [temp.concept]") or a [*declaration*](dcl.pre#nt:declaration "9.1 Preamble [dcl.pre]") that defines a function, a class, a variable, or a static data member, - [(2.21)](#2.21) it is an explicit instantiation declaration ([[temp.explicit]](temp.explicit "13.9.3 Explicit instantiation")), or - [(2.22)](#2.22) it is an [explicit specialization](temp.expl.spec "13.9.4 Explicit specialization [temp.expl.spec]") whose[*declaration*](dcl.pre#nt:declaration "9.1 Preamble [dcl.pre]") is not a definition[.](#2.sentence-1) A declaration is said to be a [*definition*](#def:definition "6.2 Declarations and definitions [basic.def]") of each entity that it defines[.](#2.sentence-2) [*Example [1](#example-1)*: All but one of the following are definitions:int a; // defines aextern const int c = 1; // defines cint f(int x) { return x+a; } // defines f and defines xstruct S { int a; int b; }; // defines S, S​::​a, and S​::​bstruct X { // defines Xint x; // defines non-static data member xstatic int y; // declares static data member y X(): x(0) { } // defines a constructor of X};int X::y = 1; // defines X​::​yenum { up, down }; // defines up and downnamespace N { int d; } // defines N and N​::​d X anX; // defines anX whereas these are just declarations:extern int a; // declares aextern const int c; // declares cint f(int); // declares fstruct S; // declares Stypedef int Int; // declares Intnamespace N1 = N; // declares N1extern X anotherX; // declares anotherXusing N::d; // declares d — *end example*] [3](#3) [#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/basic.tex#L304) [*Note [1](#note-1)*: In some circumstances, C++ implementations implicitly define the default constructor ([[class.default.ctor]](class.default.ctor "11.4.5.2 Default constructors")), copy constructor, move constructor ([[class.copy.ctor]](class.copy.ctor "11.4.5.3 Copy/move constructors")), copy assignment operator, move assignment operator ([[class.copy.assign]](class.copy.assign "11.4.6 Copy/move assignment operator")), or [destructor](class.dtor "11.4.7 Destructors [class.dtor]") member functions[.](#3.sentence-1) — *end note*] [*Example [2](#example-2)*: Given#include struct C { std::string s; // std​::​string is the standard library class ([[string.classes]](string.classes "27.4 String classes"))}; int main() { C a; C b = a; b = a;} the implementation will implicitly define functions to make the definition of C equivalent tostruct C { std::string s; C() : s() { } C(const C& x): s(x.s) { } C(C&& x): s(static_cast(x.s)) { }*//* : s(std​::​move(x.s)) { } C& operator=(const C& x) { s = x.s; return *this; } C& operator=(C&& x) { s = static_cast(x.s); return *this; }*//* { s = std​::​move(x.s); return *this; }~C() { }}; — *end example*] [4](#4) [#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/basic.tex#L345) [*Note [2](#note-2)*: A class name can also be implicitly declared by an[*elaborated-type-specifier*](dcl.type.elab#nt:elaborated-type-specifier "9.2.9.5 Elaborated type specifiers [dcl.type.elab]") ([[dcl.type.elab]](dcl.type.elab "9.2.9.5 Elaborated type specifiers"))[.](#4.sentence-1) — *end note*] [5](#5) [#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/basic.tex#L351) In the definition of an object, the type of that object shall not be an incomplete type ([[basic.types.general]](basic.types.general#term.incomplete.type "6.9.1 General")), an abstract class type ([[class.abstract]](class.abstract "11.7.4 Abstract classes")), or a (possibly multidimensional) array thereof[.](#5.sentence-1) [15)](#footnote-15)[15)](#footnoteref-15) Appearing inside the brace-enclosed[*declaration-seq*](dcl.pre#nt:declaration-seq "9.1 Preamble [dcl.pre]") in a [*linkage-specification*](dcl.link#nt:linkage-specification "9.12 Linkage specifications [dcl.link]") does not affect whether a declaration is a definition[.](#footnote-15.sentence-1)