CODEWITHSUNDEEP
c++polymorphismoverloading
OMGtechy
OMGtechy

Reputation: 8220

Overloading functions with derived classes

What I'm trying to do is something like this:

void SomeFunction(Base *){//do something}
void SomeFunction(Derived *){//do something else}

Is this possible in C++? My attempts so far just call the base version of the function. Here is an example for some clarity.

Example:

#include <iostream>
#include <vector>

class Base
{
    public:
        Base () {std::cout << "Base Constructor for " << this << std::endl;}
        void virtual PrintSomething ()
        {
            std::cout << "I am Base!" << std::endl;
        };
};

class Derived : public Base
{
    public:
        Derived () : Base () {std::cout << "Derived Construtor for " << this << std::endl;}
        void virtual PrintSomething ()
        {
            std::cout << "I am Derived!" << std::endl;
        };
};

void DoAmazingStuff ( Base * ) {std::cout << "Amazing!" << std::endl;}
void DoAmazingStuff ( Derived * ) {std::cout << "DERP!" << std::endl;}

int main ()
{
    std::vector<Base *> some_vector;

    Base *x = new Base ();
    Derived *y = new Derived ();

    some_vector.push_back ( x );
    some_vector.push_back ( y );

// This is the part that isn't functioning as expected.
/******************************************/
    DoAmazingStuff ( some_vector[0] );
    DoAmazingStuff ( some_vector[1] );
/******************************************/

    std::cin.get ();
    std::cin.get ();
    delete some_vector[0];
    delete some_vector[1];
}

The following line never gets called:

void DoAmazingStuff ( Derived * ) {std::cout << "DERP!" << std::endl;}

Upvotes: 0

Views: 146

Answers (1)

Mike Seymour
Mike Seymour

Reputation: 254431

Certainly it's possible; but the Derived version will only be called if the static type of the pointer is Derived*. For example:

Base * b = new Base;        // static and dynamic types are Base
Derived * d = new Derived;  // static and dynamic types are Derived
Base * bd = new Derived;    // static type Base, dynamic type Derived

SomeFunction(b);   // Base overload
SomeFunction(d);   // Derived overload
SomeFunction(bd);  // Base overload (from static type)

Dynamic dispatch (selecting a function based on its dynamic type) will only happen when calling virtual member functions, not overloaded non-member functions:

struct Base {
    virtual void SomeFunction() {/*do something*/}
};
struct Derived : Base {
    virtual void SomeFunction() {/*do something else*/}
};

b->SomeFunction();  // Base version
d->SomeFunction();  // Derived override
bd->SomeFunction(); // Derived override (from dynamic type)

and you could achieve something like dynamic dispatch on a non-member function with the help of a member function:

void SomeFunction(Base * b) {b->SomeFunction();}

As noted in the comments, this technique can be extended to implement multiple dispatch, selecting a function based on the dynamic types of multiple function arguments. But that's rather beyond the scope of the question.

Upvotes: 7

Related Questions