Unless otherwise specified, two declarations cannot (re)introduce the same entity. The program is ill-formed if such declarations exist.

[edit]Corresponding declarations

Two declarationscorrespond if they (re)introduce the same name, both declare constructors, or both declare destructors, unless

• either is ausing declaration,
• one declares a type (not atypedef name) and the other declares a variable, non-static data member other than of ananonymous union, enumerator, function, or function template, or
• each declares a function or function template and they do not declare corresponding overloads.

[edit]Corresponding function overloads

Twofunction declarations declarecorresponding overloads if both declare functions satisfying all following conditions:

• They have the sameparameter-type-list, omitting the types ofexplicit object parameters(since C++23).

• If both of them are non-static member functions, they need to additionally satisfy one of the following requirements:

• Their object parameters have the same type.

[edit]Corresponding function template overloads

Twofunction template declarations declarecorresponding overloads if both declare function templates satisfying all following conditions:

• Their template parameter lists have the same length.
• Their corresponding template parameters areequivalent.
• They have equivalentparameter-type-lists, omitting the types ofexplicit object parameters(since C++23).
• They have equivalent return types.

• If both are non-static members function templates, they need to additionally satisfy one of the following requirements:

• Their object parameters have equivalent types.

struct A{friendvoid c();// #1}; struct B{friendvoid c(){}// corresponds to, and defines, #1}; typedefint Int; enum E:int{ a}; void f(int);// #2void f(Int){}// defines #2void f(E){}// OK, another overload struct X{staticvoid f();void f()const;// error: redeclaration void g();void g()const;// OKvoid g()&;// error: redeclaration void h(this X&,int);void h(int)&&;// OK, another overload void j(thisconst X&);void j()const&;// error: redeclaration void k();void k(this X&);// error: redeclaration};

[edit]Multiple declarations of the same entity

Unless otherwise specified, two declarations of entitiesdeclare the same entity if all following conditions are satisfied, considering declarations of unnamed types to introduce theirtypedef names andenumeration names for linkage purposes (if any exists):

• They correspond.
• They have the sametarget scope, which is not afunction parameter scope or atemplate parameter scope.

• One of the following conditions is satisfied:

• They appear in the same translation unit.

• They both declare names withexternal linkage.

A declaration of an entity or typedef nameX is aredeclaration ofX if another declaration ofX is reachable from it; otherwise, it is afirst declaration  ofX.

[edit]Restrictions

If any two declarations of an entityE violate the corresponding restriction below, the program is ill-formed:

• If one declaresE to be a variable, the other must also declareE as a variable of the same type.
• If one declaresE to be afunction, the other must also declareE as a function of the same type.
• If one declaresE to be anenumerator, the other must also declareE as an enumerator.
• If one declaresE to be anamespace, the other must also declareE as a namespace.
• If one declaresE to be aclass type, the other must also declareE as a class type.
• If one declaresE to be anenumeration type, the other must also declareE as an enumeration type.
• If one declaresE to be aclass template, the other must also declareE as a class template with an equivalent template parameter list (seefunction template overloading).
• If one declaresE to be afunction template, the other must also declareE as a function template with an equivalent template parameter list and type.

Types are compared after all adjustments of types (during whichtypedefs are replaced by their definitions). Declarations for an array object can specify array types that differ by the presence or absence of a major array bound. No diagnostic is required if neither declaration is reachable from the other.

void g();// #1void g(int);// OK, different entity from #1 (they do not correspond)int g();// Error: same entity as #1 with different type void h();// #2namespace h{}// Error: same entity as #2, but not a function

If a declarationH that declares a name withinternal linkage precedes a declarationD in another translation unitU and would declare the same entity asD if it appeared inU, the program is ill-formed.

[edit]Potentially-conflicting declarations

Two declarationspotentially conflict if they correspond but declare different entities.

If, in any scope, a name is bound to two declarationsA andB that potentially conflict,B is not name-independent(since C++26), andA precedesB, the program is ill-formed:

void f(){int x, y;void x();// Error: different entity for xint y;// Error: redefinition} enum{ f};// Error: different entity for ::f namespace A{}namespace B= A;namespace B= A;// OK, no effectnamespace B= B;// OK, no effectnamespace A= B;// OK, no effectnamespace B{}// Error: different entity for B void g(){int _;    _=0;// OKint _;// OK since C++26, name-independent declaration    _=0;// Error: two non-function declarations in the lookup set} void h(){int _;// #1    _++;// OKstaticint _;// Error: conflicts with #1 because// static variables are not name-independent}

[edit]Defect reports

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

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文