Surcharge en C++

Question

class base { 
    public: 
     int foo(); 
     int foo(int a); 
     int foo(char* b);  
     int doSomething(int);  
} 

class derived : public base 
    { 
    public: 
    int doSomething(int b); 
    } 

int derived::doSomething(int b) 
    { 
    base::doSomething(b); 
     //Make Something else 
    } 

int main() 
{ 
    derived d= new derived(); 
    d->foo(); 
} 

maintenant dans la méthode foo (l'un d'entre eux) je veux appeler le doSomething plus spécifique. si par exemple une classe dérivée je veux le doSomething de la classe dérivée, et si par exemple une classe de base je veux le doSomething de la classe de base, malgré que j'appelle de la méthode de foo implémentée dans la classe de base.

int base::foo() 
{ 
//do something 
makeSomething(5); 
} 

Answer 1

Dans votre classe de base, faire la méthode doSomething virtuelle:

public: 

virtual int doSomething(int); 

Vous pouvez alors:

Base* deriv = new Derived(); 

Base* base = new Base(); 

deriv->doSomething(); 
base->doSomething(); 

Et amusez-vous!

Answer 2

C'est ce que les fonctions virtuelles sont pour:

struct A { 
    virtual ~A() {} 
    virtual void f() {} 
}; 

struct B : A { 
    void f() {} 
}; 

// ... 
A* a = new A; 
A* b = new B; 
a->f(); // calls A::f 
b->f(); // calls B::f 

Le C++ FAQ Lite covers some details, mais ne peut pas remplacer un bon introductory book.

Answer 3

Je propose cet exemple pour illustrer la différence entre l'utilisation de Look virtuelle ou non-utilisation

struct A { 
    virtual ~A() {} 
    virtual void f() {} 
    void g() {} 
}; 

struct B : A { 
    void f() {} 
    void g() {} 
}; 

A* a = new A; 
A* b = new B; 
a->f(); // calls A::f 
b->f(); // calls B::f 
b->g(); // calls A::g