修飾名の名前探索

#include <iostream>
int main() {
  struct std{};
  std::cout << "fail\n"; // エラー、非修飾名 std の名前探索は構造体を発見します。
  ::std::cout << "ok\n"; // OK、::std は名前空間 std を発見します。
}

struct A {
  static int n;
};
int main() {
  int A;
  A::n = 42;    // OK、 :: の左の非修飾名 A の名前探索は変数を無視します。
  A b;          // エラー、非修飾名 A の名前探索は変数 A を発見します。
}

class X { };
constexpr int number = 100;
struct C {
  class X { };
  static const int number = 50;
  static X arr[number];
};
X C::arr[number], brr[number];    // エラー、 X に対する名前探索は C::X ではなく ::X を発見します。
C::X C::arr[number], brr[number]; // OK、 arr のサイズは 50、 brr のサイズは 100 です。

struct C { typedef int I; };
typedef int I1, I2;
extern int *p, *q;
struct A { ~A(); };
typedef A AB;
int main() {
  p->C::I::~I(); // ~ の後の名前 I は :: の前の I と同じスコープで、つまり
                 // C のスコープで名前探索されるため、 C::I を発見します。
  q->I1::~I2();  // 名前 I2 は I1 と同じスコープで、つまり現在のスコープで
                 // 名前探索されるため、 ::I2 を発見します。
  AB x;
  x.AB::~AB();   // ~ の後の名前 AB は :: の前の AB と同じスコープで、つまり
                 // 現在のスコープで名前探索されるため、 ::AB を発見します。
}

struct A { A(); };
struct B : A { B(); };
A::A() { } // A::A はコンストラクタを表します (宣言で使用されています)。
B::B() { } // B::B はコンストラクタを表します (宣言で使用されています)。
B::A ba;   // B::A は型 A を表します (B のスコープで名前探索されます)
A::A a;    // エラー、 A::A は型を表しません。
 
struct A::A a2; // OK、複雑型指定子内の名前探索は関数を無視するため、
                // A::A は A のスコープ内から見ているかのように
                // クラス A (つまり注入されたクラス名) を表します。

struct B { virtual void foo(); };
struct D : B { void foo() override; };
int main()
{
    D x;
    B& b = x;
    b.foo(); // D::foo を呼びます (仮想ディスパッチ)。
    b.B::foo(); // B::foo を呼びます (静的ディスパッチ)。
}

namespace N {
   template<typename T> struct foo {};
   struct X {};
}
N::foo<X> x; // エラー、 X は N::X ではなく ::X として名前探索されます。

int x;
namespace Y {
  void f(float);
  void h(int);
}
namespace Z {
  void h(double);
}
namespace A {
  using namespace Y;
  void f(int);
  void g(int);
  int i;
}
namespace B {
  using namespace Z;
  void f(char);
  int i;
}
namespace AB {
  using namespace A;
  using namespace B;
  void g();
}
void h()
{
  AB::g();  // AB が検索され、名前探索により AB::g が発見され、 AB::g() が選択されます
            // (A と B は検索されません)。
  AB::f(1); // まず AB が検索されます。 f はありません。
            // その後 A と B が検索されます。 名前探索により A::f と B::f が
            // 発見され (Y は検索されないため Y::f は考慮されません)、
            // オーバーロード解決が A::f(int) を選択します。
  AB::x++;    // まず AB が検索されます。 x はありません。
              // その後 A と B が検索されます。 x はありません。
              // その後 Y と Z が検索されます。 それでも x はありません。 これはエラーです。
  AB::i++;  // AB が検索されます。 i はありません。
            // その後 A と B が検索されます。 名前探索により A::i と B::i が発見されます。 これはエラーです。
  AB::h(16.8);  // まず AB が検索されます。 h はありません。
                // その後 Y と Z が検索されます。
                // 名前探索は Y::h と Z::h を発見します。 オーバーロード解決が Z::h(double) を選択します。
}

namespace A { int a; }
namespace B { using namespace A; }
namespace D { using A::a; }
namespace BD {
  using namespace B;
  using namespace D;
}
void g()
{
  BD::a++; // OK、 B 経由と D 経由で同じ A::a を発見します。
}