Definitions and ODR

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

C++ language

 

Basic Concepts

language keywords

phases of translation

comments

the main() function

names and identifiers

types

fundamental types

objects

scope

object lifetime

storage duration and linkage

definitions and ODR

name lookup

memory model

 

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

• Any declaration with an extern storage class specifier or with a language linkage specifier (such as extern "C") without an initializer

extern const int a; // declares, but doesn't define a
extern const int b = 1; // defines b

• Function declaration without a function body

int f(int); // declares, but doesn't define f

• Parameter declaration in a function declaration that isn't a definition

int f(int x); // declares, but doesn't define f and x
int f(int x) { // defines f and x
     return x+a;
}

• Declaration of a static data member inside a class definition

struct S {    // defines S
    int n;        // defines S::n
    static int i; // declares, but doesn't define S::i
};
int S::i; // defines S::i

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

struct S; // declares, but doesn't define S
class Y f(class T p); // declares, but doesn't define Y and T (and also f and p)

• Declaration of a template parameter

template<typename T> // declares, but doesn't define T

• typedef declaration

typedef S S2; // declares, but doesn't define S2 (S may be incomplete)

alias-declaration using S2 = S; // declares, but doesn't define S2 (S may be incomplete) Opaque declaration of an enumeration. enum Color : int; // declares, but doesn't define Color

(since C++11)

• using-declaration

using N::d; // declares, but doesn't define d

• using-directive (does not define any entities)

static_assert declaration (does not define any entities) Attribute declaration (does not define any entities)

(since C++11)

• Empty declaration (does not define any entities)

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

Where necessary, the compiler may implicitly define the default constructor, copy constructor, move constructor, copy assignment operator, move assignment operator, and the destructor.

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

One Definition Rule

Only one definition of any variable, function, class type, enumeration type, 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 is odr-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, a definition is required in every translation unit where it is odr-used

One and only one definition of a class is required to appear in any translation unit where the class is used in a way that requires it to be complete.

There can be more than one definition in a program, as long as each definition appears in a different translation unit, of each of the following: class type, enumeration type, inline function with external linkage, class template, non-static function template, static data member of a class template, member function of a class template, partial template specialization, as long as all of the following is true:

• each definition consists of the same sequence of tokens (typically, appears in the same header file)
• name lookup from within each definition finds the same entities (after overload-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)
• the language linkage is the same (e.g. the include file isn't inside an extern "C" block)
• the three 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 behavior is undefined.

Note: in C, there is no program-wide ODR for types: two structs with members of compatible types in the same order can be (and commonly are) used across translation units even if the members have different names. In C++, the source-code names of all members must be the same as described above: if one .cpp file defines struct S { int x; }; and the other .cpp file defines struct S { int y; };, the behavior of the program that links them together is undefined. This is usually resolved with unnamed namespaces.

ODR-use

• a variable is odr-used if its name appears as a potentially-evaluated expression, except if all of the following is true:

• applying lvalue-to-rvalue conversion to the expression yields a constant expression that doesn't invoke non-trivial functions
• the expression is either a discarded-value expression or an lvalue-to-rvalue conversion

• this is odr-used if it appears as a potentially-evaluated expression (including the implicit this in a non-static member function call expression)
• virtual member function is odr-used if it is not a pure virtual member function

A function whose name appears as a potentially-evaluated expression is odr-used if it is the unique lookup result or the selected member of a set of overloaded functions