Namespaces

Пространства имён предоставляют метод предотвращения конфликтов имён в крупных проектах.

Объявления сущностей внутри блока пространства имён помещаются в область видимости пространства имён, что предотвращает их ошибочное принятие за одноимённые сущности в других областях видимости.

Объявления, находящиеся вне всех блоков пространств имён, принадлежат глобальному пространству имён . Глобальное пространство имён принадлежит глобальной области видимости и может быть явно указано с помощью ведущего :: . Хотя у него нет объявления, глобальное пространство имён не является неименованным пространством имён .

Допускается несколько блоков пространства имён с одинаковым именем. Все объявления внутри этих блоков объявляются в одной и той же области видимости пространства имён.

Синтаксис

Объяснение

Пространства имен

Определения пространств имен разрешены только в области видимости пространства имен, включая глобальную область видимости.

Чтобы повторно открыть существующее пространство имён (формально, чтобы быть определением-расширением-пространства-имён ), поиск идентификатора , используемого в определении пространства имён, должен разрешаться в имя пространства имён (не псевдоним пространства имён), которое было объявлено как член охватывающего пространства имён или встроенного пространства имён внутри охватывающего пространства имён.

Тело пространства имён namespace-body определяет область видимости пространства имён , которая влияет на поиск имён .

Все имена, введённые объявлениями, которые появляются внутри namespace-body (включая вложенные определения пространств имён), становятся членами пространства имён identifier , независимо от того, является ли это определение пространства имён оригинальным определением (которое ввело identifier ) или расширяющим определением пространства имён (которое "переоткрыло" уже определённое пространство имён)

Член пространства имен, объявленный внутри тела пространства имен, может быть определен или переобъявлен вне его с использованием явной квалификации

namespace Q
{
    namespace V   // V является членом Q и полностью определен внутри Q
    { // namespace Q::V { // C++17 альтернатива строкам выше
        class C { void m(); }; // C является членом V и полностью определен внутри V
                               // C::m только объявлен
        void f(); // f является членом V, но только объявлен здесь
    }
    void V::f() // определение члена f пространства имен V вне V
                // охватывающие пространства имен f все еще глобальное пространство имен, Q и Q::V
    {
        extern void h(); // Это объявляет ::Q::V::h
    }
    void V::C::m() // определение V::C::m вне пространства имен (и тела класса)
                   // охватывающие пространства имен - глобальное пространство имен, Q и Q::V
    {}
}

Определения и переобъявления вне пространства имен разрешены только

• после точки объявления,
• на уровне пространства имен, и
• в пространствах имен, охватывающих исходное пространство имен (включая глобальное пространство имен).

Кроме того, они должны использовать синтаксис qualified-id.

namespace Q
{
    namespace V    // исходное определение пространства имен для V
    {
        void f();  // объявление Q::V::f
    }
    void V::f() {} // OK
    void V::g() {} // Ошибка: g() еще не является членом V
    namespace V    // расширенное определение пространства имен для V
    {
        void g();  // объявление Q::V::g
    }
}
namespace R           // не является охватывающим пространством имен для Q
{
    void Q::V::g() {} // Ошибка: нельзя определить Q::V::g внутри R
}
void Q::V::g() {}     // OK: глобальное пространство имен охватывает Q

Имена, введённые с помощью friend объявлений внутри нелокального класса X, становятся членами ближайшего охватывающего пространства имён X, но они не становятся видимыми для обычного name lookup (ни unqualified , ни qualified ), если соответствующее объявление не предоставлено на уровне пространства имён, либо до, либо после определения класса. Такое имя может быть найдено с помощью ADL , которое учитывает как пространства имён, так и классы.

Только самая внутренняя охватывающая пространство имен учитывается таким объявлением дружественной функции при решении вопроса о том, будет ли имя конфликтовать с ранее объявленным именем.

void h(int);
namespace A
{
    class X
    {
        friend void f(X);       // A::f является дружественной функцией
        class Y
        {
            friend void g();    // A::g является дружественной функцией
            friend void h(int); // A::h является дружественной функцией, нет конфликта с ::h
        };
    };
    // A::f, A::g и A::h не видны в области видимости пространства имён
    // несмотря на то, что они являются членами пространства имён A
    X x;
    void g()  // определение A::g
    {
        f(x); // A::X::f находится через ADL
    }
    void f(X) {}   // определение A::f
    void h(int) {} // определение A::h
    // A::f, A::g и A::h теперь видны в области видимости пространства имён
    // и также являются дружественными функциями для A::X и A::X::Y
}

// in C++14, std::literals and its member namespaces are inline
{
    using namespace std::string_literals; // makes visible operator""s 
                                          // from std::literals::string_literals
    auto str = "abc"s;
}
{
    using namespace std::literals; // makes visible both
                                   // std::literals::string_literals::operator""s
                                   // and std::literals::chrono_literals::operator""s
    auto 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 visible
    auto str = "abc"s;
    auto min = 60s;
}

namespace Lib
{
    inline namespace 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
}

Безымянные пространства имён

unnamed-namespace-definition — это определение пространства имен вида

Это определение трактуется как определение пространства имён с уникальным именем и using-директивой в текущей области видимости, которая указывает на это безымянное пространство имён (Примечание: неявно добавленная using-директива делает пространство имён доступным для qualified name lookup и unqualified name lookup , но не для argument-dependent lookup ). Уникальное имя является уникальным во всей программе, но в пределах единицы трансляции каждое определение безымянного пространства имён отображается на одно и то же уникальное имя: множественные определения безымянных пространств имён в одной области видимости обозначают одно и то же безымянное пространство имён.

namespace
{
    int i; // определяет ::(unique)::i
}
void f()
{
    i++;   // инкрементирует ::(unique)::i
}
namespace A
{
    namespace
    {
        int i;        // A::(unique)::i
        int j;        // A::(unique)::j
    }
    void g() { i++; } // A::(unique)::i++
}
using namespace A; // добавляет все имена из A в глобальное пространство имён
void h()
{
    i++;    // ошибка: ::(unique)::i и ::A::(unique)::i обе находятся в области видимости
    A::i++; // ok, инкрементирует ::A::(unique)::i
    j++;    // ok, инкрементирует ::A::(unique)::j
}

Объявления using

Вводит имя, определённое в другом месте, в декларативную область, где появляется эта using-декларация.

Using-объявления могут использоваться для введения членов пространства имён в другие пространства имён и области видимости блоков, или для введения членов базового класса в определения производных классов , или для введения enumerators в пространства имён, блоки и области видимости классов (since C++20) .

Для использования в определениях производных классов см. using declaration .

Имена, введённые в область видимости пространства имён с помощью using-объявления, могут использоваться так же, как и любые другие имена, включая квалифицированный поиск из других областей видимости:

void f();
namespace A
{
    void g();
}
namespace X
{
    using ::f;        // глобальная f теперь видна как ::X::f
    using A::g;       // A::g теперь видна как ::X::g
    using A::g, A::g; // (C++17) OK: двойное объявление разрешено в области пространства имён
}
void h()
{
    X::f(); // вызывает ::f
    X::g(); // вызывает A::g
}

Если после использования using-объявления для взятия члена из пространства имён это пространство имён расширяется и вводятся дополнительные объявления для того же имени, эти дополнительные объявления не становятся видимыми через using-объявление (в отличие от using-директивы). Исключением является случай, когда using-объявление именует шаблон класса: частичные специализации, введённые позже, эффективно видимы, поскольку их поиск осуществляется через первичный шаблон.

namespace A
{
    void f(int);
}
using A::f; // ::f теперь является синонимом для A::f(int)
namespace A       // расширение пространства имен
{
    void f(char); // не изменяет значение ::f
}
void foo()
{
    f('a'); // вызывает f(int), несмотря на существование f(char)
}
void bar()
{
    using A::f; // эта f является синонимом для A::f(int) и A::f(char)
    f('a');     // вызывает f(char)
}

Using-объявления не могут называть template-id , или пространство имён , или scoped enumerator (до C++20) . Каждый декларатор в using-объявлении вводит одно и только одно имя, например using-объявление для enumeration не вводит ни одного из его перечислителей.

Все ограничения на обычные объявления одинаковых имен, правила сокрытия и перегрузки применяются к using-объявлениям:

namespace A
{
    int x;
}
namespace B
{
    int i;
    struct g {};
    struct x {};
    void f(int);
    void f(double);
    void g(char); // OK: имя функции g скрывает структуру g
}
void func()
{
    int i;
    using B::i;   // ошибка: i объявлена дважды
    void f(char);
    using B::f;   // OK: f(char), f(int), f(double) являются перегрузками
    f(3.5);       // вызывает B::f(double)
    using B::g;
    g('a');       // вызывает B::g(char)
    struct g g1;  // объявляет g1 с типом struct B::g
    using B::x;
    using A::x;   // OK: скрывает struct B::x
    x = 99;       // присваивает A::x
    struct x x1;  // объявляет x1 с типом struct B::x
}

Если функция была введена с помощью using-объявления, объявление функции с тем же именем и списком параметров является некорректным (если только это не объявление той же самой функции). Если шаблон функции был введен с помощью using-объявления, объявление шаблона функции с тем же именем, списком типов параметров, возвращаемым типом и списком параметров шаблона является некорректным. Два using-объявления могут вводить функции с одинаковым именем и списком параметров, но при попытке вызова такой функции программа становится некорректной.

namespace B
{
    void f(int);
    void f(double);
}
namespace C
{
    void f(int);
    void f(double);
    void f(char);
}
void h()
{
    using B::f;  // вводит B::f(int), B::f(double)
    using C::f;  // вводит C::f(int), C::f(double) и C::f(char)
    f('h');      // вызывает C::f(char)
    f(1);        // ошибка: B::f(int) или C::f(int)?
    void f(int); // ошибка: f(int) конфликтует с C::f(int) и B::f(int)
}

Если сущность объявлена, но не определена во внутреннем пространстве имён, а затем объявлена через using-объявление во внешнем пространстве имён, и затем появляется определение во внешнем пространстве имён с тем же неквалифицированным именем, это определение является членом внешнего пространства имён и конфликтует с using-объявлением:

namespace X
{
    namespace M
    {
        void g(); // объявляет, но не определяет X::M::g()
    }
    using M::g;
    void g();     // Ошибка: попытка объявить X::g, которая конфликтует с X::M::g()
}

В более общем случае, объявление, которое появляется в любой области видимости пространства имён и вводит имя с использованием неквалифицированного идентификатора, всегда вводит член в то пространство имён, в котором оно находится, а не в какое-либо другое. Исключениями являются явные инстанциации и явные специализации основного шаблона, определённого во встроенном пространстве имён: поскольку они не вводят новое имя, они могут использовать неквалифицированный идентификатор в охватывающем пространстве имён.

Директивы using

Директива using-directive является block-declaration со следующим синтаксисом:

Директивы using разрешены только в области видимости пространства имен scope и в блочной области видимости. С точки зрения unqualified name lookup любого имени после директивы using и до конца области видимости, в которой она появляется, каждое имя из namespace-name видимо так, как если бы оно было объявлено в ближайшем охватывающем пространстве имен, которое содержит как директиву using, так и namespace-name .

Директива using не добавляет никакие имена в декларативную область, в которой она появляется (в отличие от объявления using), и поэтому не предотвращает объявление идентичных имен.

Директивы using транзитивны для целей неполного поиска : если область содержит директиву using, которая указывает на namespace-name , который сам содержит директиву using для некоторого namespace-name-2 , эффект такой, как если бы директивы using из второго пространства имён присутствовали в первом. Порядок, в котором встречаются эти транзитивные пространства имён, не влияет на поиск имён.

namespace A
{
    int i;
}
namespace B
{
    int i;
    int j;
    namespace C
    {
        namespace D
        {
            using namespace A;
            // Имена из A "внедряются" в D.
            // Неполный поиск в пределах D рассматривает эти имена как имеющие ту же
            // область видимости, что и глобальная область (например, для целей сокрытия имен).
            // Полный поиск с указанием D (D::name для некоторого имени)
            // найдет то же имя, что и неполный поиск в пределах D.
            int j;
            int k;
            int a = i;   // i - это B::i, потому что A::i скрыто B::i
            int b = ::i; // ошибка: в глобальном пространстве имен все еще нет i
        }
        using namespace D; // имена из D и A внедряются в C
        int k = 89; // Можно объявить имя, идентичное введенному с помощью using
        int l = k;  // неоднозначность: C::k или D::k
        int m = i;  // ok: B::i скрывает A::i
        int n = j;  // ok: D::j скрывает B::j
    }
}
// Все это эквивалентные определения:
int t0 = B::i;
int t1 = B::C::a;
int t2 = B::C::D::a;

Если после использования using-директивы для указания некоторого пространства имен это пространство имен расширяется и в него добавляются дополнительные члены и/или using-директивы, эти дополнительные члены и дополнительные пространства имен становятся видимыми через using-директиву (в отличие от using-объявления)

namespace D
{
    int d1;
    void f(char);
}
using namespace D; // вводит D::d1, D::f, D::d2, D::f,
                   // E::e и E::f в глобальное пространство имён!
int d1;            // OK: нет конфликта с D::d1 при объявлении
namespace E
{
    int e;
    void f(int);
}
namespace D            // расширение пространства имён
{
    int d2;
    using namespace E; // транзитивная using-директива
    void f(int);
}
void f()
{
    d1++;    // ошибка: неоднозначность ::d1 или D::d1?
    ::d1++;  // OK
    D::d1++; // OK
    d2++;    // OK, d2 это D::d2
    e++;     // OK: e это E::e благодаря транзитивному using
    f(1);    // ошибка: неоднозначность: D::f(int) или E::f(int)?
    f('a');  // OK: единственная f(char) это D::f(char)
}

Примечания

Директива using using namespace std ; на любом уровне пространства имён добавляет все имена из пространства имён std в глобальное пространство имён (поскольку глобальное пространство имён является ближайшим пространством, содержащим как std , так и любое пользовательское пространство имён), что может привести к нежелательным конфликтам имён. Эта и другие using-директивы обычно считаются плохой практикой на уровне файла в заголовочных файлах ( SF.7: Не используйте using namespace на глобальном уровне в заголовочных файлах ).

Ключевые слова

namespace , using , inline

Пример

#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.
    {
        using namespace std;
        vector<int> v3;  // Same as std::vector
        v1 = v3; // OK
    }
    {
        using vec::vector;
        vector<int> v4;  // Same as vec::vector
        v2 = v4; // OK
    }
}

Отчеты о дефектах

Следующие отчеты об изменениях в поведении, являющиеся дефектными, были применены ретроактивно к ранее опубликованным стандартам C++.

Смотрите также