La sobrecarga de la función de una superclase

Question

¿Hay algo en el C ++ estándar que me impide la sobrecarga de 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
};

Me puede 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 de B de manera 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 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, los hallazgos del compilador 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 no se encuentra A::foo.

Answer 2

Usted no está anulando la aplicación de A::foo(int), en vez que estés aliasing A::foo y cambiando su firma a (int, int) en lugar de (int). Como James McNellis menciona la declaración using A::foo; hace que la función de A disponibles.