Unqualified name lookup

int n = 1;     // n의 선언
int x = n + 1; // OK: lookup이 ::n을 찾음
int z = y - 1; // Error: lookup 실패
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;        // 두 번째로 발견됨
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를 숨기므로, X::f가 D에서 B2를 통해 접근 가능하더라도
// 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::f in X를 *대체*할 것임. 왜냐하면 이미 C에 추가된 모든 하위 객체(즉 X)가
//  새 집합(B1)의 적어도 하나의 하위 객체의 기본 클래스가 되기 때문이며,
//  최종 결과는 동일함: 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: 가상 기본 클래스 서브오브젝트가 하나뿐이므로 v는 하나만 존재
    ++pd.s;       // OK: B1과 B2 모두에서 발견되더라도 static B::s는 하나만 존재
    int i = pd.e; // OK: B1과 B2 모두에서 발견되더라도 열거자 B::e는 하나만 존재
    ++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;
// 멤버 함수들이 friend로 선언될 클래스
struct A
{ 
    typedef int AT;
    void f1(AT);
    void f2(float);
    template<class T>
    void f3();
    void f4(S<AT>);
};
// f1, f2, f3에 대한 friend 권한을 부여하는 클래스
struct B
{
    typedef char AT;
    typedef float BT;
    friend void A::f1(AT);    // AT 조회 시 A::AT를 찾음 (A에서 AT 발견)
    friend void A::f2(BT);    // BT 조회 시 B::BT를 찾음 (A에서 BT 발견되지 않음)
    friend void A::f3<AT>();  // AT 조회 시 B::AT를 찾음 (선언자 식별자 A::f3<AT>에 AT가 있으므로
                              //     A에서 조회하지 않음)
};
// f4에 대한 friend 권한을 부여하는 클래스 템플릿
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; // 첫 번째로 발견됨
};
int n = 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의 두 번째 선언
void f(int); // f의 세 번째 선언
double dd;
void h()
{
    g(e);  // g<E>를 인스턴스화하며, 이 시점에서
           // 이름 'f'의 두 번째와 세 번째 사용이
           // 조회되어 ::f(char)(조회로)와 ::f(E)(ADL로)를 찾은 후
           // 오버로드 해결이 ::f(E)를 선택함
           // 이는 f(char)를 한 번, f(E)를 두 번 호출함
    g(32); // g<int>를 인스턴스화하며, 이 시점에서
           // 이름 'f'의 두 번째와 세 번째 사용이
           // 조회되어 ::f(char)만 찾은 후
           // 오버로드 해결이 ::f(char)를 선택함
           // 이는 f(char)를 세 번 호출함
}
typedef double A;
template<class T>
class B
{
    typedef int A;
};
template<class T>
struct X : B<T>
{
    A a; // A에 대한 조회가 B<T>::A가 아닌 ::A(double)를 찾음
};