Definitions aredeclarations that fully define the entity introduced by the declaration. Every declaration is a definition, except for the following:

• A function declaration without a function body:

int f(int);// declares, but does not define f

• Any declaration with anexternstorage class specifier or with alanguage linkage specifier (such asextern"C") without an initializer:

externconstint a;// declares, but does not define aexternconstint b=1;// defines b

• Declaration of anon-inline(since C++17)static data member inside a class definition:

struct S{int n;// defines S::nstaticint i;// declares, but does not define S::iinlinestaticint x;// defines S::x};// defines S int S::i;// defines S::i

struct S{staticconstexprint x=42;// implicitly inline, defines S::x}; constexprint S::x;// declares S::x, not a redefinition

• Declaration of a class name (byforward declaration or by the use of the elaborated type specifier in another declaration):

struct S;// declares, but does not define S class Y f(class T p);// declares, but does not define Y and T (and also f and p)

enum Color:int;// declares, but does not define Color

• Declaration of atemplate parameter:

template<typename T>// declares, but does not define T

• A parameter declaration in a function declaration that isn't a definition:

int f(int x);// declares, but does not define f and x int f(int x)// defines f and x{return x+ a;}

• Atypedef declaration:

typedef S S2;// declares, but does not define S2 (S may be incomplete)

using S2= S;// declares, but does not define S2 (S may be incomplete)

• Ausing-declaration:

using N::d;// declares, but does not define d

• Anempty declaration (does not define any entities)
• Ausing-directive (does not define any entities)

externtemplatef<int,char>;// declares, but does not define f<int, char>

• Anexplicit specialization whose declaration is not a definition:

template<>struct A<int>;// declares, but does not define A<int>

Anasm declaration does not define any entities, but it is classified as a definition.

Where necessary, the compiler may implicitly define thedefault constructor,copy constructor,move constructor,copy assignment operator,move assignment operator, and thedestructor.

If the definition of any object results in an object ofincomplete type orabstract class type, the program is ill-formed.

[edit]One Definition Rule

Only one definition of any variable, function, class type, enumeration type, concept(since C++20) or template is allowed in any one translation unit (some of these may have multiple declarations, but only one definition is allowed).

One and only one definition of every non-inline function or variable that isodr-used (see below) is required to appear in the entire program (including any standard and user-defined libraries). The compiler is not required to diagnose this violation, but the behavior of the program that violates it is undefined.

For an inline function or inline variable(since C++17), a definition is required in every translation unit where it isodr-used .

For a class, a definition is required wherever the class is used in a way that requires it to becomplete.

There can be more than one definition in a program of each of the following: class type, enumeration type, inline function, inline variable(since C++17),templated entity (template or member of template, but not fulltemplate specialization), as long as all following conditions are satisfied:

• Each definition appears in a different translation unit.

• Each definition consists of the same sequence oftokens (typically, appears in the same header).
• Name lookup from within each definition finds the same entities (afteroverload resolution), except that:

• Constants with internal or no linkage may refer to different objects as long as they are not odr-used and have the same values in every definition.

• Overloaded operators, including conversion, allocation, and deallocation functions refer to the same function from each definition (unless referring to one defined within the definition).
• Corresponding entities have the same language linkage in each definition (e.g. the include file is not inside anextern"C" block).
• If aconst object isconstant-initialized in any of the definitions, it is constant-initialized in each definition.
• The rules above apply to every default argument used in each definition.
• If the definition is for a class with an implicitly-declared constructor, every translation unit where it is odr-used must call the same constructor for the base and members.

• If the definition is for a template, then all these requirements apply to both names at the point of definition and dependent names at the point of instantiation.

If all these requirements are satisfied, the program behaves as if there is only one definition in the entire program. Otherwise, the program is ill-formed, no diagnostic required.

Note: in C, there is no program-wide ODR for types, and even extern declarations of the same variable in different translation units may have different typesas long as they are compatible. In C++, the source-code tokens used in declarations of the same type must be the same as described above: if one .cpp file definesstruct S{int x;}; and the other .cpp file definesstruct S{int y;};, the behavior of the program that links them together is undefined. This is usually resolved withunnamed namespaces.

[edit]Naming an entity

A variable isnamed by an expression if the expression is an identifier expression that denotes it.

A function isnamed by an expression or conversion in following cases:

• A function whose name appears as an expression or conversion (including named function, overloaded operator,user-defined conversion, user-defined placement forms ofoperator new, non-default initialization) is named by that expression if it is selected by overload resolution, except when it is an unqualified pure virtual member function or a pointer-to-member to a pure virtual function.
• Anallocation ordeallocation function for a class is named by anew expression appearing in an expression.
• A deallocation function for a class is named by adelete expression appearing in an expression.
• A constructor selected to copy or move an object is considered to be named by the expression or conversion even ifcopy elision takes place.Using a prvalue in some contexts does not copy or move an object, seemandatory elision.(since C++17)

A potentially evaluated expression or conversion odr-uses a function if it names it.

[edit]Potential results

The set ofpotential results of an expressionE is a (possibly empty) set of identifier expressions that appear withinE, combined as follows:

• IfE is anidentifier expression, the expressionE is its only potential result.
• IfE is a subscript expression (E1[E2]) where one of the operands is an array, the potential results of that operand is included in the set.
• IfE is a class member access expression of the formE1.E2 orE1.template E2 naming a non-static data member, the potential results ofE1 is included in the set.
• IfE is a class member access expression naming a static data member, the identifier expression designating the data member is included in the set.
• IfE is a pointer-to-member access expression of the formE1.*E2 orE1.*template E2 whose second operand is a constant expression, the potential results ofE1 are included in the set.
• IfE is an expression in parentheses ((E1)), the potential results ofE1 are included in the set.
• IfE is a glvalue conditional expression (E1? E2: E3, whereE2 andE3 are glvalues), the union of the potential results ofE2 andE3 are both included in the set.
• IfE is a comma expression (E1, E2), the potential results ofE2 are in the set of potential results.
• Otherwise, the set is empty.

[edit]ODR-use (informal definition)

An object is odr-used if its value is read (unless it is a compile time constant) or written, its address is taken, or a reference is bound to it,

A reference is odr-used if it is used and its referent is not known at compile time,

A function is odr-used if a function call to it is made or its address is taken.

If an entity is odr-used, its definition must exist somewhere in the program; a violation of that is usually a link-time error.

struct S{staticconstint x=0;// static data member// a definition outside of class is required if it is odr-used}; constint& f(constint& r); int n= b?(1, S::x)// S::x is not odr-used here: f(S::x);// S::x is odr-used here: a definition is required

[edit]ODR-use (formal definition)

A variablex that is named by apotentially-evaluated expressionexpr that appears at a pointP is odr-used byexpr, unless any of the following conditions is satisfied:

• x is a reference that isusable in constant expressions atP.
• x is not a reference and(until C++26)expr is an element of the set of potential results of an expressionE, and any of the following conditions is satisfied:
  • E is adiscarded-value expression, and no lvalue-to-rvalue conversion is applied to it.
  • x is a non-volatile(since C++26) object that is usable in constant expressions atP and has no mutable subobjects, and any of the following conditions is satisfied:

• E has non-volatile-qualified non-class type, and the lvalue-to-rvalue conversion is applied to it.

struct S{staticconstint x=1;};// applying lvalue-to-rvalue conversion// to S::x yields a constant expression int f(){    S::x;// discarded-value expression does not odr-use S::x return S::x;// expression where lvalue-to-rvalue conversion// applies does not odr-use S::x}

*this is odr-used ifthis appears as a potentially-evaluated expression (including the implicitthis in a non-static member function call expression).

A function is odr-used in following cases:

• A function is odr-used if it is named by (see below) a potentially-evaluated expression or conversion.
• Avirtual member function is odr-used if it is not a pure virtual member function (addresses of virtual member functions are required to construct the vtable).
• A non-placement allocation or deallocation function for a class is odr-used by the definition of a constructor of that class.
• A non-placement deallocation function for a class is odr-used by the definition of the destructor of that class, or by being selected by the lookup at the point of definition of a virtual destructor.
• An assignment operator in a classT that is a member or base of another classU is odr-used by an implicitly-defined copy-assignment or move-assignment functions ofU.
• A constructor (including default constructors) for a class is odr-used by theinitialization that selects it.
• A destructor for a class is odr-used if it ispotentially invoked.

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]References

• In other languages

• Español
• 日本語
• Русский
• 中文