Resolución de sobrecarga de C++ [duplicar]

La resolución de sobrecarga es una de las partes más feas de C++

Básicamente el compilador encuentra una coincidencia de nombre "doSomething(int)" en el ámbito de B, ve que los parámetros no coinciden y se detiene con un error.

Se puede superar usando el A:: doSomething en la clase B

class A  
{  
  public:  
    int DoSomething() {return 0;}
};  

class B : public A  
{  
  public:  
    using A::DoSomething;
    int DoSomething(int x) {return 1;} 
};   


int main(int argc, char** argv)
{
  B* b = new B();  
  // b->A::DoSomething();    // still works, but...
  b->DoSomething();    // works now too
  delete b;  
  return 0;
}

No, este comportamiento está presente para asegurar que no te atrapen heredando de clases base distantes por error.

Para sortearlo, necesita decirle al compilador a qué método desea llamar colocando a using A::doSomething en la clase B.

Vea este artículo para una descripción rápida y fácil de este comportamiento.

La presencia de un método en una clase derivada oculta todos los métodos con el mismo nombre (independientemente de los parámetros) en las clases base. Esto se hace para evitar problemas como este:

class A {} ;
class B :public A
{
    void DoSomething(long) {...}
}

B b;
b.DoSomething(1);     // calls B::DoSomething((long)1));

Que más tarde alguien cambia de clase A:

class A
{
    void DoSomething(int ) {...}
}

Ahora de repente:

B b;
b.DoSomething(1);     // calls A::DoSomething(1);

En otras palabras, si no funciona así, un cambio no relacionado en una clase que no controlas (A), podría afectar silenciosamente cómo funciona tu código.

Esto tiene algo que ver con la forma en que funciona la resolución de nombres. Básicamente, primero encontramos el ámbito del que proviene el nombre, y luego recogemos todas las sobrecargas para ese nombre en ese ámbito. Sin embargo, el alcance en su caso es clase B, y en clase B, B:: doSomething oculta A:: doSomething:

3.3.7 Ocultación de nombres [basic.alcance.ocultar]

...[snip]...

3 En una definición de función miembro, la declaración de un nombre local se oculta el declaración de un miembro de la clase con el mismo nombre; véase básico.alcance.clase. Declaración de un miembro de una clase derivada (clase.derivado ) oculta la declaración de un miembro de una clase base de el mismo nombre; ver clase.miembro.lookup .

Debido a la ocultación de nombres, A::doSomething ni siquiera se considera para la resolución de sobrecarga

Cuando define una función en una clase derivada, oculta todas las funciones con ese nombre en la clase base. Si la función de clase base es virtual y tiene una firma compatible, entonces la función de clase derivada también anula la función de clase base. Sin embargo, eso no afecta la visibilidad.

Puede hacer visible la función de clase base con una declaración using:

class B : public A  
{  
  public:  
    int DoSomething(int x) {return 1;};  
    using A::DoSomething;
};  

Eso no es sobrecargar! ¡Eso es ESCONDERSE!

Al buscar en el árbol de herencia la función a utilizar, C++ utiliza el nombre sin argumentos, una vez que ha encontrado cualquier definición se detiene, a continuación, examina los argumentos. En el ejemplo dado, se detiene en la clase B. Para poder hacer lo que buscas, la clase B debe definirse así:

class B : public A  
{  
  public:
    using A::DoSomething;
    int DoSomething(int x) {return 1;};  
}; 

La función está oculta por la función con el mismo nombre en la subclase (pero con una firma diferente). Puede mostrarlo usando la instrucción using, como al usar A:: doSomething ();