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

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

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

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

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

Синтаксис

Объяснение

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

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

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

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

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

Элемент пространства имён, который был объявлен в теле пространства имён, может быть определён или повторно объявлен вне его с помощью явной квалификации

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
  {
  }
}

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

• после точки объявления,
• только в области видимости пространства имён и
• только в пространствах имён, которые включают исходное пространство имён (включая глобальное пространство имён). Кроме того, они должны использовать синтаксис полного идентификатора (начиная с C++14)

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, но они не становятся видимыми для обычного поиска имени (ни для неполного, ни для полного), если соответствующее объявление не предоставлено в области видимости пространства имён до или после определения класса. Такое имя можно найти с помощью ADL, который учитывает как пространства имён, так и классы.

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

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
}

{ // в C++14, std::literals и его пространства имён являются встроенными
   using namespace std::string_literals; // делает видимым operator""s 
                                         // из std::literals::string_literals
   auto str = "abc"s;
}
{
   using namespace std::literals; // делает видимыми как
                                  // std::literals::string_literals::operator""s,
                                  // так и std::literals::chrono_literals::operator""s
   auto str = "abc"s;
   auto min = 60s;
}
{
   using std::operator""s; // делает видимыми
                           // и std::literals::string_literals::operator""s
                           // и std::literals::chrono_literals::operator""s
   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);  // ок, Lib является ассоциированным пространством имён A
}

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

Определение-безымянного-пространства-имён, это определение пространства имён в форме

Это определение рассматривается как определение пространства имён с уникальным именем и using-директивой в текущей области видимости, которая именует это безымянное пространство имён (Примечание: неявно добавленная директива using делает пространство имён доступным для полного поиска имени и неполного поиска имени}, но не для поиска, зависящего от аргументов ).

namespace {
    int i;  // объявляет ::(уникальное)::i
}
void f() {
    i++;  // инкрементирует ::(уникальное)::i
}

namespace A {
    namespace {
        int i; // A::(уникальное)::i
        int j; // A::(уникальное)::j
    }
    void g() { i++; } // A::уникальное::i++
}

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

Using-объявления

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

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

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

Имена, введённые в область пространства имён с помощью 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-объявления не могут именовать идентификатор шаблона, или пространство имён, или перечислитель с ограниченной областью видимости (до C++20). Каждый декларатор в using-объявлении вводит одно и только одно имя, например, using-объявление для перечисления не вводит ни одного из его перечислителей.

Все ограничения на обычные объявления с одинаковыми именами, правила скрытия и перегрузки применимы к 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 с типом структуры B::g

    using B::x;
    using A::x;  // OK: скрывает структуру B::x
    x = 99;      // присваивание переменной A::x
    struct x x1; // объявляет x1 с типом структуры 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-директива представляет собой блочное объявление со следующим синтаксисом:

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

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

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

namespace A {
    int i;
}
namespace B {
    int i;
    int j;
    namespace C {
        namespace D {
            using namespace A; // все имена из A вводятся в глобальное пространство имён
            int j;
            int k;
            int a = i; // i это B::i, та как A::i скрыто под B::i
        }
        using namespace D; // имена из D вводятся в C
                           // имена из A вводятся в глобальное пространство имён
        int k = 89; // OK, объявление имени идентичного имени, введённому с помощью using
        int l = k;  // неоднозначность: C::k или D::k
        int m = i;  // ok: B::i скрывает A::i
        int n = j;  // ok: D::j скрывает B::j
    }
}

Если после использования 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 в глобальной области видимости в файле заголовка).

Пример

#include <vector>

namespace vec {

    template< typename T >
    class vector {
        // ...
    };

} // vec

int main()
{
    std::vector<int> v1; // Стандартный вектор.
    vec::vector<int> v2; // Определённый пользователем вектор.

    v1 = v2; // Ошибка: v1 и v2 являются объектами разного типа.

    {
        using namespace std;
        vector<int> v3; // То же, что и std::vector
        v1 = v3; // OK
    }

    {
        using vec::vector;
        vector<int> v4; // То же, что и vec::vector
        v2 = v4; // OK
    }
        
    return 0;
}

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

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

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