¿Orden de búsqueda del alcance del símbolo de C++ diferente para la clase de plantilla y sin plantilla?

Question

#include <iostream> 

void foo() 
{ 
    std::cout << "global foo()" << std::endl; 
} 

struct A { 
    void foo() 
    { 
     std::cout << "A::foo()" << std::endl; 
    } 
}; 

struct B : public A { 
    void call() 
    { 
     foo(); 
    } 
}; 

int main(int argc, char **argv) 
{ 
    B b; 
    b.call(); 
    return 0; 
} 

Esto da expected result:

A::foo() 

Sin embargo después de cambiar dos líneas (clase B de la plantilla):

#include <iostream> 

void foo() 
{ 
    std::cout << "global foo()" << std::endl; 
} 

struct A { 
    void foo() 
    { 
     std::cout << "A::foo()" << std::endl; 
    } 
}; 

template <typename T> // change here 
struct B : public T { 
    void call() 
    { 
     foo(); 
    } 
}; 

int main(int argc, char **argv) 
{ 
    B<A> b; // and here 
    b.call(); 
    return 0; 
} 

consigo unexpected result:

global foo() 

Y el uso de this-> es no es una opción ya que estoy tratando de crear comió un mecanismo de "retroceso".

Answer 1

Lo que obtienes es un resultado esperado. Esto se denomina "búsqueda de nombre de dos fases" en el estándar de C++.

nombres dentro de las plantillas se dividen en dos tipos:

dependientes - Nombres que dependen de los parámetros de plantilla, pero no se declaran dentro de la plantilla.

No dependiente - nombres que no dependen de los parámetros de la plantilla, más el nombre de la plantilla misma y los nombres declarados dentro de ella.

Cuando el compilador intenta resolver algún nombre en el código, primero decide si el nombre es dependiente o no, y el proceso de resolución se deriva de esta distinción. Mientras que los nombres no dependientes se resuelven "normalmente": cuando se define la plantilla, la resolución para los nombres dependientes se produce en el momento de la instanciación de la plantilla.

foo(); en B::call en su ejemplo es un nombre no dependiente, por lo que se resuelve en global foo() en el punto de definición de la plantilla.

Answer 2

Tiene que decirle específicamente que use el método de clase T.

template <typename T> 
struct B : public T { 
    void call() 
    { 
     T::foo(); 
    } 
}; 

---

Pero en cuanto a un mecanismo de reserva, se puede comprobar esta pregunta: Is it possible to write a template to check for a function's existence?

utilizando un fracaso La sustitución no es un error (SFINAE), se puede comprobar para un método foo en T, y luego ejecute el método apropiado.

Answer 3

La respuesta aceptada explica por qué ve ese comportamiento, pero no cómo lograr el comportamiento de "repliegue" que desea. Esto se puede hacer usando SFINAE, introduciendo un par de sobrecargas de plantillas miembro, una de las cuales solo existirá si la clase base tiene una función miembro llamada foo.

template <typename T> 
struct B : T { 
    template <void (T::*)()> struct has_mem_fn {}; 

    template <typename U> void call(has_mem_fn<&U::foo>*) {this->foo();} 
    template <typename U> void call(...) {foo();} 

    void call() {call<T>(0);} 
}; 

struct X {}; 

int main() 
{ 
    B<A> ba; 
    ba.call(); // A::foo() 

    B<X> bx; 
    bx.call(); // global foo() 
} 

ACTUALIZACIÓN: Acabo de notar sus comentarios en otra respuesta, en el que dice que está consciente de este método, pero no puedo usarlo debido a tener que soportar compiladores disfuncionales. En ese caso, me temo que lo que quieres es probablemente imposible.