Namespaces provide a method for preventing name conflicts in large projects.

Entities declared inside a namespace block are placed in a namespace scope, which prevents them from being mistaken for identically-named entities in other scopes.

Entities declared outside all namespace blocks belong to theglobal namespace. The global namespace belongs to theglobal scope, and can be referred to explicitly with a leading::. While it has no declaration, the global namespace is not anunnamed namespace.

Multiple namespace blocks with the same name are allowed. All declarations within these blocks are declared in the same namespace scope.

[edit]Syntax

[edit]Explanation

[edit]Namespaces

Namespace definitions are only allowed at namespace scope, including the global scope.

To reopen an existing namespace (formally, to be anextension-namespace-definition), the lookup for theidentifier used in the namespace definition must resolve to a namespace name (not a namespace alias), that was declared as a member of the enclosing namespace or of an inline namespace within an enclosing namespace.

Thenamespace-body defines anamespace scope, which affectsname lookup.

All names introduced by the declarations that appear withinnamespace-body (including nested namespace definitions) become members of the namespaceidentifier, whether this namespace definition is the original namespace definition (which introducedidentifier), or an extension namespace definition (which "reopened" the already defined namespace)

A namespace member that was declared within a namespace body may be defined or redeclared outside of it using explicit qualification

namespace Q{namespace V// V is a member of Q, and is fully defined within Q{// namespace Q::V { // C++17 alternative to the lines aboveclass C{void m();};// C is a member of V and is fully defined within V// C::m is only declaredvoid f();// f is a member of V, but is only declared here} void V::f()// definition of V's member f outside of V// f's enclosing namespaces are still the global namespace, Q, and Q::V{externvoid h();// This declares ::Q::V::h} void V::C::m()// definition of V::C::m outside of the namespace (and the class body)// enclosing namespaces are the global namespace, Q, and Q::V{}}

Out-of-namespace definitions and redeclarations are only allowed

• after the point of declaration,
• at namespace scope, and
• in namespaces that enclose the original namespace (including the global namespace).

Also, they must use qualified-id syntax.

namespace Q{namespace V// original-namespace-definition for V{void f();// declaration of Q::V::f} void V::f(){}// OKvoid V::g(){}// Error: g() is not yet a member of V namespace V// extension-namespace-definition for V{void g();// declaration of Q::V::g}} namespace R// not an enclosing namespace for Q{void Q::V::g(){}// Error: cannot define Q::V::g inside R} void Q::V::g(){}// OK: global namespace encloses Q

Names introduced byfriend declarations within a non-local class X become members of the innermost enclosing namespace of X, but they do not become visible to ordinaryname lookup (neitherunqualified norqualified) unless a matching declaration is provided at namespace scope, either before or after the class definition. Such name may be found throughADL which considers both namespaces and classes.

Only the innermost enclosing namespace is considered by such friend declaration when deciding whether the name would conflict with a previously declared name.

void h(int);namespace A{class X{friendvoid f(X);// A::f is a friend class Y{friendvoid g();// A::g is a friendfriendvoid h(int);// A::h is a friend, no conflict with ::h};};// A::f, A::g and A::h are not visible at namespace scope// even though they are members of the namespace A     X x;void g()// definition of A::g{        f(x);// A::X::f is found through ADL} void f(X){}// definition of A::fvoid h(int){}// definition of A::h// A::f, A::g and A::h are now visible at namespace scope// and they are also friends of A::X and A::X::Y}

// in C++14, std::literals and its member namespaces are inline{usingnamespace std::string_literals;// makes visible operator""s// from std::literals::string_literalsauto str="abc"s;} {usingnamespace std::literals;// makes visible both// std::literals::string_literals::operator""s// and std::literals::chrono_literals::operator""sauto str="abc"s;auto min= 60s;} {using std::operator""s;// makes both std::literals::string_literals::operator""s// and std::literals::chrono_literals::operator""s visibleauto str="abc"s;auto min= 60s;}

namespace Lib{inlinenamespace Lib_1{template<typename T>class A;} template<typename T>void g(T){/* ... */}}/* ... */struct MyClass{/* ... */};namespace Lib{template<>class A<MyClass>{/* ... */};} int main(){    Lib::A<MyClass> a;    g(a);// ok, Lib is an associated namespace of A}

[edit]Unnamed namespaces

Theunnamed-namespace-definition is a namespace definition of the form

This definition is treated as a definition of a namespace with unique name and ausing-directive in the current scope that nominates this unnamed namespace (Note: implicitly added using directive makes namespace available for thequalified name lookup andunqualified name lookup, but not for theargument-dependent lookup).The unique name is unique over the entire program, but within a translation unit each unnamed namespace definition maps to the same unique name: multiple unnamed namespace definitions in the same scope denote the same unnamed namespace.

namespace{int i;// defines ::(unique)::i} void f(){    i++;// increments ::(unique)::i} namespace A{namespace{int i;// A::(unique)::iint j;// A::(unique)::j} void g(){ i++;}// A::(unique)::i++} usingnamespace A;// introduces all names from A into global namespace void h(){    i++;// error: ::(unique)::i and ::A::(unique)::i are both in scope    A::i++;// ok, increments ::A::(unique)::i    j++;// ok, increments ::A::(unique)::j}

[edit]Using-declarations

Introduces a name that is defined elsewhere into the declarative region where this using-declaration appears.

Using-declarations can be used to introduce namespace members into other namespaces and block scopes, or to introduce base class members into derived class definitions, or to introduceenumerators into namespaces, block, and class scopes(since C++20).

For the use in derived class definitions, seeusing declaration.

Names introduced into a namespace scope by a using-declaration can be used just like any other names, including qualified lookup from other scopes:

void f();namespace A{void g();} namespace X{using::f;// global f is now visible as ::X::fusing A::g;// A::g is now visible as ::X::gusing A::g, A::g;// (C++17) OK: double declaration allowed at namespace scope} void h(){    X::f();// calls ::f    X::g();// calls A::g}

If, after the using-declaration was used to take a member from a namespace, the namespace is extended and additional declarations for the same name are introduced, those additional declarations do not become visible through the using-declaration (in contrast with using-directive). One exception is when a using-declaration names a class template: partial specializations introduced later are effectively visible, because theirlookup proceeds through the primary template.

namespace A{void f(int);}using A::f;// ::f is now a synonym for A::f(int) namespace A// namespace extension{void f(char);// does not change what ::f means} void foo(){    f('a');// calls f(int), even though f(char) exists.} void bar(){using A::f;// this f is a synonym for both A::f(int) and A::f(char)    f('a');// calls f(char)}

Using-declarations cannot nametemplate-id, or namespace, or a scoped enumerator(until C++20). Each declarator in a using-declaration introduces one and only one name, for example using-declaration for anenumeration does not introduce any of its enumerators.

All restrictions on regular declarations of the same names, hiding, and overloading rules apply to using-declarations:

namespace A{int x;} namespace B{int i;struct g{};struct x{}; void f(int);void f(double);void g(char);// OK: function name g hides struct g} void func(){int i;using B::i;// error: i declared twice void f(char);using B::f;// OK: f(char), f(int), f(double) are overloads    f(3.5);// calls B::f(double) using B::g;    g('a');// calls B::g(char)struct g g1;// declares g1 to have type struct B::g using B::x;using A::x;// OK: hides struct B::x    x=99;// assigns to A::xstruct x x1;// declares x1 to have type struct B::x}

If a function was introduced by a using-declaration, declaring a function with the same name and parameter list is ill-formed (unless the declaration is for the same function). If a function template was introduced by a using-declaration, declaring a function template with the same name, parameter type list, return type, and template parameter list is ill-formed.Two using-declarations can introduce functions with the same name and parameter list, but if a call to that function is attempted, the program is ill-formed.

namespace B{void f(int);void f(double);} namespace C{void f(int);void f(double);void f(char);} void h(){using B::f;// introduces B::f(int), B::f(double)using C::f;// introduces C::f(int), C::f(double), and C::f(char)    f('h');// calls C::f(char)    f(1);// error: B::f(int) or C::f(int)?void f(int);// error: f(int) conflicts with C::f(int) and B::f(int)}

If an entity is declared, but not defined in some inner namespace, and then declared through using-declaration in the outer namespace, and then a definition appears in the outer namespace with the same unqualified name, that definition is a member of the outer namespace and conflicts with the using-declaration:

namespace X{namespace M{void g();// declares, but doesn't define X::M::g()}using M::g; void g();// Error: attempt to declare X::g which conflicts with X::M::g()}

More generally, a declaration that appears in any namespace scope and introduces a name using an unqualified identifier always introduces a member into the namespace it's in and not to any other namespace. The exceptions are explicit instantiations and explicit specializations of a primary template that is defined in an inline namespace: because they do not introduce a new name, they may use unqualified-id in an enclosing namespace.

[edit]Using-directives

Ausing-directive is ablock-declaration with the following syntax:

Using-directives are allowed only in namespacescope and in block scope. From the point of view ofunqualified name lookup of any name after a using-directive and until the end of the scope in which it appears, every name fromnamespace-name is visible as if it were declared in the nearest enclosing namespace which contains both the using-directive andnamespace-name.

Using-directive does not add any names to the declarative region in which it appears (unlike the using-declaration), and thus does not prevent identical names from being declared.

Using-directives are transitive for the purposes ofunqualified lookup: if a scope contains a using-directive that nominates anamespace-name, which itself contains using-directive for somenamespace-name-2, the effect is as if the using directives from the second namespace appear within the first. The order in which these transitive namespaces occur does not influence name lookup.

namespace A{int i;} namespace B{int i;int j; namespace C{namespace D{usingnamespace A;// Names from A are "injected" into D.// Unqualified lookup within D considers these names to have the same// scope as the global scope (e.g. for the purposes of name hiding).// Qualified lookup referring to D (D::name for some name)// will find the same name as unqualified lookup within D. int j;int k;int a= i;// i is B::i, because A::i is hidden by B::iint b=::i;// error: there is still no i in the global namespace} usingnamespace D;// names from D and A are injected into C int k=89;// OK to declare name identical to one introduced by a usingint l= k;// ambiguous: C::k or D::kint m= i;// ok: B::i hides A::iint n= j;// ok: D::j hides B::j}} // These are all equivalent definitions:int t0= B::i;int t1= B::C::a;int t2= B::C::D::a;

If, after a using-directive was used to nominate some namespace, the namespace is extended and additional members and/or using-directives are added to it, those additional members and the additional namespaces are visible through the using-directive (in contrast with using-declaration)

namespace D{int d1;void f(char);}usingnamespace D;// introduces D::d1, D::f, D::d2, D::f,// E::e, and E::f into global namespace! int d1;// OK: no conflict with D::d1 when declaring namespace E{int e;void f(int);} namespace D// namespace extension{int d2;usingnamespace E;// transitive using-directivevoid f(int);} void f(){    d1++;// error: ambiguous ::d1 or D::d1?::d1++;// OK    D::d1++;// OK    d2++;// OK, d2 is D::d2     e++;// OK: e is E::e due to transitive using     f(1);// error: ambiguous: D::f(int) or E::f(int)?    f('a');// OK: the only f(char) is D::f(char)}

[edit]Notes

The using-directiveusingnamespace std; at any namespace scope introduces every name from the namespacestd into the global namespace (since the global namespace is the nearest namespace that contains bothstd and any user-declared namespace), which may lead to undesirable name collisions. This, and other using directives are generally considered bad practice at file scope of a header file (SF.7: Don’t writeusingnamespace at global scope in a header file).

[edit]Keywords

namespace,using,inline

[edit]Example

#include <vector> namespace vec{template<typename T>class vector{// ...};}// of vec int main(){std::vector<int> v1;// Standard vector.    vec::vector<int> v2;// User defined vector. // v1 = v2;          // Error: v1 and v2 are different object's type. {usingnamespace std;        vector<int> v3;// Same as std::vector        v1= v3;// OK} {using vec::vector;        vector<int> v4;// Same as vec::vector        v2= v4;// OK}}

[edit]Defect reports

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

[edit]See also

• In other languages

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