Por qué argumento de búsqueda Dependiente no funciona con plantilla de función dynamic_pointer_cast

Question

Consideremos el siguiente programa en C++:

#include <memory> 

struct A {}; 

struct B : A {}; 

int main() 
{ 
    auto x = std::make_shared<A>(); 
    if (auto p = dynamic_pointer_cast<B>(x)); 
} 

Al compilar con MSVC 2010, me obtener el siguiente error:

error C2065: 'dynamic_pointer_cast' : undeclared identifier 

el error persiste si auto se reemplaza por std::shared_ptr<A>. Cuando califico completamente la llamada con std::dynamic_pointer_cast, el programa se compila con éxito.

Además, gcc 4.5.1 no le gusta, sea:

error: 'dynamic_pointer_cast' was not declared in this scope 

pensé que std::dynamic_pointer_cast habría sido escogido por Koenig lookup, ya que el tipo de x vidas en el espacio de nombres std. Que me estoy perdiendo aqui ?

Answer 1

Creo sección §14.8.1/6 (03 C++, y creo que tiene en C++ 11 también) se aplica a este caso que dice lo,

[Note: For simple function names, argument dependent lookup (3.4.2) applies even when the function name is not visible within the scope of the call. This is because the call still has the syntactic form of a function call (3.4.1). But when a function template with explicit template arguments is used, the call does not have the correct syntactic form unless there is a function template with that name visible at the point of the call. If no such name is visible, the call is not syntactically well-formed and argument-dependent lookup does not apply. If some such name is visible, argument dependent lookup applies and additional function templates may be found in other namespaces.

[Example:

namespace A { 
    struct B { }; 
    template<int X> void f(B); 
} 
namespace C { 
    template<class T> void f(T t); 
} 
void g(A::B b) { 
    f<3>(b); //ill-formed: not a function call 
    A::f<3>(b); //well-formed 
    C::f<3>(b); //ill-formed; argument dependent lookup 
       // applies only to unqualified names 

    using C::f; 
    f<3>(b); //well-formed because C::f is visible; then 
       // A::f is found by argument dependent lookup 
} 

—end example] —end note]

Su caso no lo hacen desencadenar ADL porque expira explícitamente el argumento de plantilla y no hay ninguna plantilla con el mismo nombre disponible en el sitio donde llama al dynamic_pointer_cast.

Un truco para permitir ADL es añadir una plantilla de maniquí con mismo nombre a su código, como se muestra a continuación:

#include <memory> 

struct A {}; 

struct B : A {}; 

template<int> //template parameter could be anything! 
void dynamic_pointer_cast(); //ADD this. NO NEED TO DEFINE IT 

int main() 
{ 
    auto x = std::make_shared<A>(); 
    if (auto p = dynamic_pointer_cast<B>(x)); //now it should work through ADL 
} 

Answer 2

búsqueda Koenig sólo se aplica a la búsqueda de funciones. Aquí, primero tiene que encontrar una plantilla, luego crear una instancia, antes de tener una función. Para simplemente analizar el código, el compilador debe saber que dynamic_pointer_cast es una plantilla (de lo contrario, '<' es menor que, y no es el comienzo de una lista de argumentos de la plantilla); hasta que el compilador sepa que dynamic_pointer_cast es una plantilla de función, ni siquiera sabe que se trata de una llamada a función. La expresión que ve es básicamente a <b> c, donde < y > son los operadores relacionales.