C++ dziedziczyć z wielu klas bazowych o tej samej nazwie wirtualnego funkcji

Question

próbowałem ten kod:

class A 
{ 
    virtual void foo() = 0; 
}; 

class B 
{ 
    virtual void foo() = 0; 
}; 

class C : public A, public B 
{ 
    //virtual void A::foo(){} 
    //virtual void B::foo(){} 

    virtual void A::foo(); 
    virtual void B::foo(); 
}; 

void C::A::foo(){} 
void C::B::foo(){} 

int main() 
{ 
    C c; 
    return 0; 
} 

Jest OK podczas korzystania z skomentował udział, ale gdy próbuję napisać definicje poza deklaracją klasy, kompilator zgłasza błędy. Używam kompilatora MSVC11, czy ktoś wie, jak to napisać? Potrzebuję przenieść kod do pliku cpp.

Dziękuję ~~

Answer 1

Masz tylko jedną funkcję wirtualną foo:

class A { 
    virtual void foo() = 0; 
}; 

class B { 
    virtual void foo() = 0; 
}; 

class C : public A, public B { 
    virtual void foo(); 

}; 

void C::foo(){} 
void C::A::foo(){} 
void C::B::foo(){}; 

int main() { 
    C c; 
    return 0; 
} 

Answer 2

funkcja zastępuje funkcję wirtualną klasę bazową na podstawie nazwy i parametrów typów (patrz niżej) . W związku z tym klasa C ma jedną wirtualną funkcję, jedną odziedziczoną po każdym A i B. Ale to funkcja void C::foo() zastępuje zarówno:

[class.virtual]/2

Jeżeli wirtualne funkcja element vf deklaruje klasą Base w klasie Derived, pochodzący, bezpośrednio lub pośrednio, z Base , funkcja członkowska vf o tej samej nazwie, listę parametrów typu, kwalifikację cv i kwalifikację ref (lub jej brak) jako Base::vf jest zadeklarowana, następnie Derived::vf jest również wirtualna (niezależnie od tego, czy jest to deklaracja, czy nie). ed) i to przesłaniaBase::vf.

Jak już podano w komentarzach, [dcl.meaning]/1 zabrania zastosowanie kwalifikowanej ID w zgłoszeniu o (użytkownik) Funkcja:

Gdy declarator-id jest kwalifikowana, deklaracja odnosi się do wcześniej zadeklarowanej członek klasy lub przestrzeni nazw, do których odnosi się kwalifikator [...]”

Dlatego każdy virtual void X::foo(); jest illeg al jako deklaracja wewnątrz C.

Kod

class C : public A, public B 
{ 
    virtual void foo(); 
}; 

jest jedynym sposobem AFAIK przesłonić foo, i zastąpi on zarówno A::foo i B::foo. Nie ma sposobu, aby mieć dwa różne nadpisania dla A::foo i B::foo z różnych zachowań innych niż wprowadzając kolejną warstwę dziedziczenia:

#include <iostream> 

struct A 
{ 
    virtual void foo() = 0; 
}; 

struct B 
{ 
    virtual void foo() = 0; 
}; 

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

struct CB : B 
{ 
    virtual void foo() { std::cout << "B" << std::endl; } 
}; 

struct C : CA, CB {}; 

int main() { 
    C c; 
    //c.foo(); // ambiguous 

    A& a = c; 
    a.foo(); 

    B& b = c; 
    b.foo(); 
}