Почему поиск Koening не работает здесь?

Question

Аргумент зависит поиск говорит:

Для аргументов типа класса (в том числе объединения), набор состоит из ... а) Сам класс б) ...

Тогда почему может 't printX найти X?

#include<iostream> 
using namespace std; 

class A { 
public: 
    static const int X = 1; 
}; 

class B { 
public: 
    static void printX(A a) 
    { 
     cout << "X is " << X << endl; 
    } 
}; 

int main(int argc, char** argv) 
{ 
    A a; 
    B::printX(a); 
    return 0; 
} 

Answer 1

Я хочу расширить ответ от @Nawaz, который проливает некоторый свет на значение «набор состоит из ... a) Сам класс«.

Пример программа:

#include <iostream> 

void bar(int) { std::cout << "Came to ::bar(int)\n"; } 

namespace foo 
{ 
    struct A2; 
    struct A1 
    { 
     friend void bar(A1 const&) { std::cout << "Came to foo::bar(A1 const&)\n"; } 
     friend void bar(A2 const&) { std::cout << "Came to foo::bar(A2 const&)\n"; } 
    }; 

    struct A2 
    { 
    }; 
} 

struct B 
{ 
    friend void bar(B) { std::cout << "Came to ::bar(B)\n"; } 
}; 

int main() 
{ 
    foo::A1 a1; 
    foo::A2 a2; 
    B b; 
    int i = 0; 

    bar(i); // This resolves to the only bar() in the global namespace. 

    bar(a1); // This resolves to the appropriate overloaded friend function 
      // defined in foo::A1 because the scopes for looking up the 
      // function includes class foo::A1 

    bar(a2); // Error. The search for bar include foo::A2 but not foo::A1.   

    bar(b); // This resolves to the friend function defined in B because 
      // the scopes for looking up the function includes class B 
} 

Answer 2

Это не то, что ADL должен делать. ADL работает для неквалифицированный вызов функции, а функция первая в поле имен (0), в котором указаны типы (имена) аргумента (ов).

Пример,

namespace N 
{ 
     struct A {}; 

     void f(A const &) {} 
} 

N::A a; 

N::f(a); //qualified function call. ADL is not needed. 
f(a); //unqualified function call. ADL works here 

В приведенном выше примере f(a) вызывает f() из пространства имен N. Поскольку f(a) является неквалифицированным вызовом функции, ADL позволяет компилятору сначала искать функцию f в пространстве имен N как тип аргумента a определен в N.

Надеюсь, что это поможет.