Unqualified name lookup

int n = 1;     // nの宣言
int x = n + 1; // OK: ルックアップが::nを見つける
int z = y - 1; // エラー: ルックアップ失敗
int y = 2;     // yの宣言

int n = 1; // 宣言
namespace N
{
    int m = 2;
    namespace Y
    {
        int x = n; // OK、ルックアップは ::n を見つける
        int y = m; // OK、ルックアップは ::N::m を見つける
        int z = k; // エラー：ルックアップ失敗
    }
    int k = 3;
}

namespace X
{
    extern int x; // 宣言、定義ではない
    int n = 1;    // 最初に見つかる
}
int n = 2;        // 2番目に見つかる
int X::x = n;     // X::nを見つけ、X::xを1に設定

namespace A
{
    namespace N
    {
        void f();
        int i = 3; // 3番目として見つかる（2番目が存在しない場合）
    }
    int i = 4;     // 4番目として見つかる（3番目が存在しない場合）
{
int i = 5;         // 5番目として見つかる（4番目が存在しない場合）
void A::N::f()
{
    int i = 2;     // 2番目として見つかる（1番目が存在しない場合）
    while (true)
    {
       int i = 1;  // 1番目として見つかる：検索完了
       std::cout << i;
    {
{
// int i;          // 見つからない
namespace A
{
    namespace N
    {
        // int i;  // 見つからない
    {
{

namespace M
{
    // const int i = 1; // 見つからない
    class B
    {
        // static const int i = 3;     // 3番目に見つかる（ただしアクセスチェックに通らない）
    };
}
// const int i = 5;                    // 5番目に見つかる
namespace N
{
    // const int i = 4;                // 4番目に見つかる
    class Y : public M::B
    {
        // static const int i = 2;     // 2番目に見つかる
        class X
        {
            // static const int i = 1; // 1番目に見つかる
            int a[i]; // iの使用
            // static const int i = 1; // 見つからない
        };
        // static const int i = 2;     // 見つからない
    };
    // const int i = 4;                // 見つからない
}
// const int i = 5;                    // 見つからない

class B
{
    // int i;         // 3番目に見つかる
};
namespace M
{
    // int i;         // 5番目に見つかる
    namespace N
    {
        // int i;     // 4番目に見つかる
        class X : public B
        {
            // int i; // 2番目に見つかる
            void f();
            // int i; // 同様に2番目に見つかる
        };
        // int i;     // 4番目に見つかる
    }
}
// int i;             // 6番目に見つかる
void M::N::X::f()
{
    // int i;         // 1番目に見つかる
    i = 16;
    // int i;         // 見つからない
}
namespace M
{
    namespace N
    {
        // int i;     // 見つからない
    }
}

struct X { void f(); };
struct B1: virtual X { void f(); };
struct B2: virtual X {};
struct D : B1, B2
{
    void foo()
    {
        X::f(); // OK、X::fを呼び出す（修飾名検索）
        f(); // OK、B1::fを呼び出す（非修飾名検索）
    }
};
// C++98規則: B1::fがX::fを隠蔽するため、DからB2経由でX::fに到達可能であっても、
// Dからの名前検索では見つからない
// C++11規則: Dにおけるfの検索セットは何も見つからず、基底クラスへ進行
//  B1におけるfの検索セットはB1::fを見つけ、完了
// マージにより空集合が置き換えられ、Cにおけるfの検索セットはB1内のB1::fを持つ
//  B2におけるfの検索セットは何も見つからず、基底クラスへ進行
//    Xにおけるfの検索はX::fを見つける
//  マージにより空集合が置き換えられ、B2におけるfの検索セットはX内のX::fを持つ
// Cへのマージで、B2の検索セット内のすべての部分オブジェクト（X）が、
// 既にマージされたすべての部分オブジェクト（B1）の基底クラスであることが判明し、
// B2のセットは破棄される
// CにはB1内で見つかったB1::fのみが残る
// （struct D : B2, B1が使用された場合、最後のマージでCのこれまでマージされた
//  X内のX::fが*置換*される。なぜならCに既に追加されたすべての部分オブジェクト（X）が
//  新しいセット（B1）内の少なくとも1つの部分オブジェクトの基底クラスとなるため。
//  最終結果は同じ：Cの検索セットはB1内で見つかったB1::fのみを保持する）

struct V { int v; };
struct B
{
    int a;
    static int s;
    enum { e };
};
struct B1 : B, virtual V {};
struct B2 : B, virtual V {};
struct D : B1, B2 {};
void f(D& pd)
{
    ++pd.v;       // OK: 仮想基底クラスのサブオブジェクトが1つだけなので、vは1つだけ
    ++pd.s;       // OK: B1とB2の両方で見つかるが、staticなB::sは1つだけ
    int i = pd.e; // OK: B1とB2の両方で見つかるが、列挙子B::eは1つだけ
    ++pd.a;       // エラー、曖昧: B1のB::aとB2のB::a
}

int i = 3;                     // f1では3番目、f2では2番目に見つかる
struct X
{
    static const int i = 2;    // f1では2番目に見つかる、f2では見つからない
    friend void f1(int x)
    {
        // int i;              // 1番目に見つかる
        i = x;                 // X::iを見つけて変更する
    }
    friend int f2();
    // static const int i = 2; // クラススコープ内のどこでもf1に対して2番目に見つかる
};
void f2(int x)
{
    // int i;                  // 1番目に見つかる
    i = x;                     // ::iを見つけて変更する
}

template<class T>
struct S;
// メンバ関数がフレンド指定されるクラス
struct A
{ 
    typedef int AT;
    void f1(AT);
    void f2(float);
    template<class T>
    void f3();
    void f4(S<AT>);
};
// f1、f2、f3に対してフレンド指定を許可するクラス
struct B
{
    typedef char AT;
    typedef float BT;
    friend void A::f1(AT);    // ATのルックアップはA::ATを発見（ATはA内で発見）
    friend void A::f2(BT);    // BTのルックアップはB::BTを発見（BTはA内で発見されず）
    friend void A::f3<AT>();  // ATのルックアップはB::ATを発見（A内でのルックアップは行われない、
                              //     ATは宣言子識別子A::f3<AT>内にあるため）
};
// f4に対してフレンド指定を許可するクラステンプレート
template<class AT>
struct C
{
    friend void A::f4(S<AT>); // ATのルックアップはA::ATを発見
                              // （ATは宣言子識別子A::f4内にないため）
};

class X
{
    int a, b, i, j;
public:
    const int& r;
    X(int i): r(a),      // X::r を X::a への参照として初期化
              b(i),      // X::b をパラメータ i の値で初期化
              i(i),      // X::i をパラメータ i の値で初期化
              j(this->i) // X::j を X::i の値で初期化
    {}
};
int a;
int f(int a, int b = a); // エラー: a の検索でパラメータ a が見つかり、::a ではない
                         // また、パラメータはデフォルト引数として許可されていない

struct X
{
    static int x;
    static const int n = 1; // 1番目に見つかる
};
int n = 2;                  // 2番目に見つかる
int X::x = n;               // X::nを見つけ、X::xを2ではなく1に設定する

const int RED = 7;
enum class color
{
    RED,
    GREEN = RED + 2, // REDはcolor::REDを見つけ、::REDではないため、GREEN = 2
    BLUE = ::RED + 4 // 修飾付きルックアップは::REDを見つけ、BLUE = 11
};

int n = 3;          // 3番目に見つかる
int f(int n = 2)    // 2番目に見つかる
try
{
    int n = -1;     // 見つからない
}
catch(...)
{
    // int n = 1;   // 1番目に見つかる
    assert(n == 2); // nの検索で関数パラメータfが見つかる
    throw;
}

struct A {};
void operator+(A, A);  // ユーザー定義の非メンバーoperator+
struct B
{
    void operator+(B); // ユーザー定義のメンバーoperator+
    void f();
};
A a;
void B::f() // Bのメンバー関数の定義
{
    operator+(a, a); // エラー：メンバー関数からの通常の名前探索では
                     // Bのスコープ内のoperator+の宣言を見つけ、
                     // そこで停止し、グローバルスコープに到達しない
    a + a; // OK：メンバー探索でB::operator+を発見、非メンバー探索で
           // ::operator+(A, A)を発見、オーバーロード解決で ::operator+(A, A)を選択
}

void f(char); // fの最初の宣言
template<class T> 
void g(T t)
{
    f(1);    // 非依存名: ルックアップは ::f(char)を見つけ、即時バインド
    f(T(1)); // 依存名: ルックアップは延期
    f(t);    // 依存名: ルックアップは延期
//  dd++;    // 非依存名: ルックアップは宣言を見つけられない
}
enum E { e };
void f(E);   // fの2番目の宣言
void f(int); // fの3番目の宣言
double dd;
void h()
{
    g(e);  // g<E>をインスタンス化、この時点で
           // 名前'f'の2番目と3番目の使用が
           // ルックアップにより ::f(char)を、ADLにより ::f(E)を見つけ
           // その後オーバーロード解決が ::f(E)を選択
           // これはf(char)を1回、f(E)を2回呼び出す
    g(32); // g<int>をインスタンス化、この時点で
           // 名前'f'の2番目と3番目の使用が
           // ルックアップにより ::f(char)のみを見つけ
           // その後オーバーロード解決が ::f(char)を選択
           // これはf(char)を3回呼び出す
}
typedef double A;
template<class T>
class B
{
    typedef int A;
};
template<class T>
struct X : B<T>
{
    A a; // Aのルックアップは ::A(double)を見つけ、B<T>::Aではない
};