Il sovraccarico di funzione di una classe di super-

Question

C'è qualcosa in C ++ standard che mi impedisce di sovraccaricare la funzione di una classe di super-?

A partire da questo paio di classi:

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
};

posso chiamare B::foo() facilmente:

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

Ma se provo a chiamare A::foo() ...

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

... Ottengo un errore di compilazione:

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)

Giusto per assicurarsi che non mi manca qualcosa, ho cambiato il nome della funzione di B in modo che non vi sia sovraccarico:

class B : public A {
    int x2;

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

E ora posso chiamare A::foo() utilizzando il secondo esempio.

E 'questo standard? Sto usando g ++.

Answer 1

È necessario utilizzare una dichiarazione secondo all'interno della definizione di classe B:

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

Senza la dichiarazione utilizzando, i reperti del compilatore B::foo durante nome di ricerca e in modo efficace non cerca le classi di base per altre entità con lo stesso nome, in modo da A::foo non si trova.

Answer 2

Non stai sovrascrivendo l'implementazione di A::foo(int), invece si sta aliasing A::foo e cambiando la sua firma a (int, int) invece di (int). Come James McNellis menzionato la dichiarazione using A::foo; rende la funzione da A a disposizione.