Sobrecarga de la función de una superclase

Question

¿Hay algo en el estándar de C++ que me impida sobrecargar la función de una superclase?

A partir de este par de clases:

class A {   // super class 
    int x; 

public: 
    void foo (int y) {x = y;} // original definition 
}; 

class B : public A { // derived class 
    int x2; 

public: 
    void foo (int y, int z) {x2 = y + z;} // overloaded 
}; 

puedo llamar B::foo() fácilmente:

B b; 
    b.foo (1, 2); // [1] 

Pero si trato de llamar A::foo() ...

B b; 
    b.foo (12); // [2] 

.. Me sale un error del compilador:

test.cpp: In function 'void bar()': 
test.cpp:18: error: no matching function for call to 'B::foo(int)' 
test.cpp:12: note: candidates are: void B::foo(int, int) 

Sólo para asegurarse de que no estaba perdiendo algo, he cambiado el nombre de la función B 's para que no haya sobrecarga:

class B : public A { 
    int x2; 

public: 
    void stuff (int y, int z) {x2 = y + z;} // unique name 
}; 

Y ahora puedo llamar A::foo() usando el segundo ejemplo .

¿Es esta la norma? Estoy usando g ++.

Answer 1

Es necesario utilizar una declaración using dentro de la definición de clase B:

class B : public A { 
public: 
    using A::foo;   // allow A::foo to be found 
    void foo(int, int); 
    // etc. 
}; 

Sin el uso de la declaración, el compilador encuentra B::foo durante la búsqueda de nombre y efectivamente no busca en las clases base para otras entidades con el mismo nombre, por lo que A::foo no se encuentra.

Answer 2

No está anulando la implementación de A::foo(int), en su lugar está creando alias A::foo y cambiando su firma a (int, int) en lugar de (int). Como James McNellis mencionó, la declaración using A::foo; hace que la función de A esté disponible.