名前空間

namespace Q {
  namespace V { // V は Q のメンバであり、 Q 内で完全に定義されます。
// namespace Q::V { // C++17 では上の2行の代わりにこのように書けます。
    class C { void m(); }; // C は V のメンバであり、 V 内で完全に定義されます。
                           // C::m は宣言されるだけです。
    void f(); // f は V のメンバですが、ここでは宣言されるだけです。
  }
  void V::f() // V のメンバ f の V の外側での定義。
              // f の囲っている名前空間はグローバル名前空間、 Q、 および Q::V のままです。
  {
      extern void h(); // これは ::Q::V::h を宣言します。
  }
  void V::C::m() // 名前空間 (およびクラス本体) の外側の V::C::m の定義。
                 // 囲っている名前空間はグローバル名前空間、 Q、 および Q::V です。
  {
  }
}

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() {} // エラー、 R 内部で Q::V::g は定義できません。
}
void Q::V::g() {} // OK、グローバル名前空間は Q を囲っています。

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 のフレンドでもあります。
}

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 をインクリメントします。
}

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 を呼びます。
}

namespace A {
    void f(int);
}
using A::f; // ::f は A::f(int) に対する同義語になります。
 
namespace A { // 名前空間の拡張。
   void f(char); // ::f の意味は変わりません。
}
void foo() {
    f('a'); // f(char) が存在していますが、 f(int) を呼びます。
} 
void bar() {
   using A::f; // この f は A::f(int) と A::f(char) の両方に対する同義語です。
   f('a'); // f(char) を呼びます。
}

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 が2回宣言されています。
 
    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; // 構造体 B::g 型の変数 g1 を宣言します。
 
    using B::x;
    using A::x;  // OK、構造体 B::x を隠蔽します。
    x = 99;      // A::x に代入します。
    struct x x1; // 構造体 B::x 型の変数 x1 を宣言します。
}

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) と衝突します。
}

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; // A::i は B::i によって隠蔽されるため、 i は B::i です。
        }
        using namespace D; // D 内の名前が C に注入され、
                           // A 内の名前がグローバル名前空間に注入されます。
        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 を隠蔽します。
    }
}

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、推移的な using 指令により e は E::e です。
    f(1); // エラー、 D::f(int) と E::f(int) の間で曖昧です。
    f('a'); // OK、唯一の f(char) は D::f(char) です。
}