C++ Dynamic binding in method argument - c++

Question

I recently wanted to get c++ to dynamically resolve a member/function by its input parameter which comes in some derived versions. Here is what I mean:
#include <iostream>
class Base {
};
class DerivedA : public Base {
};
class DerivedB : public Base {
};
class DerivedC : public Base {
};
class Test {
public:
void world( DerivedA *instance )
{
std::cout << "DerivedA" << std::endl;
}
void world( DerivedB *instance )
{
std::cout << "DerivedB" << std::endl;
}
void world( Base *instance )
{
std::cout << "Base" << std::endl;
}
};
int main()
{
Base *a = new Base;
Base *b = new DerivedA;
Base *c = new DerivedB;
Base *d = new DerivedC;
Test hello;
hello.world( a );
hello.world( b );
hello.world( c );
hello.world( d );
return 0;
}
The behaviour I WANTED is this:
Base
DerivedA
DerivedB
Base
But for sure the output I am REALLY getting is this:
Base
Base
Base
Base
I understand, that dynamic binding is the other way, resolving the correct member function within the derived classes of base and not like that way - but can it work in any way for that?
Maybe I am only missing the essential point..
However, many thanks in advance!
Sebastian

Answer 1

The type of a, b, c and d are all Base*. The compiler does not track "what the variable contains". If that is what you want to do then you need to use a virtual function in the class that you derive from, for example:
class Base {
public:
virtual const char* MyName() { return "Base"; }
};
class DerivedA : public Base {
public:
virtual const char* MyName() { return "DerivedA"; }
};
... similiar for all derived classes ...
void world( Base *instance )
{
std::cout << instance->MyName() << std::endl;
}
(Edit: To get exactly the behaviour you list in the first case, you'd need to NOT implement the MyName() function in the DerivedC class)
So, using a wrapper class may be the solution for a test-setup. Here's something I just hacked up, without much consideration and sophistication:
#include <iostream>
class Base {
};
class DerivedA : public Base {
};
class DerivedB : public Base {
};
class DerivedC : public Base {
};
class Test {
public:
void world( DerivedA *instance )
{
std::cout << "DerivedA" << std::endl;
}
void world( DerivedB *instance )
{
std::cout << "DerivedB" << std::endl;
}
void world( Base *instance )
{
std::cout << "Base" << std::endl;
}
};
template<typename T>
class Wrapper
{
public:
Wrapper(T* i) : instance(i)
{
}
~Wrapper()
{
delete instance;
}
void doTest(Test& t)
{
t.world(instance);
}
T* instance;
};
int main()
{
Test hello;
Wrapper<Base> a(new Base);
Wrapper<DerivedA> b(new DerivedA);
Wrapper<DerivedB> c(new DerivedB);
Wrapper<DerivedC> d(new DerivedC);
a.doTest(hello);
b.doTest(hello);
c.doTest(hello);
d.doTest(hello);
return 0;
}

Answer 2

In your example you don't have a runtime polymorphism scheme (i.e., dynamic binding). What you have is an overloaded member function and in overload resolution the compiler correctly selects void world( Base *instance ).
In order to get what you want you should apply an inheritance scheme like the one below:
class Base {
public:
virtual ~Base() {}
virtual void world() const { std::cout << "Base" << std::endl; }
};
class DerivedA : public Base {
public:
virtual ~DerivedA() {}
void world() const { std::cout << "DerivedA" << std::endl; }
};
class DerivedB : public Base {
public:
virtual ~DerivedB() {}
void world() const { std::cout << "DerivedB" << std::endl; }
};
class DerivedC : public Base {
public:
virtual ~DerivedC() {}
using Base::world;
};
Live Demo
Edit:
In order to keep your code as intented in one place you could add to the above scheme the following altered version of the Test class:
class Test {
public:
void world( DerivedA *instance ) { instance->world(); }
void world( DerivedB *instance ) { instance->world(); }
void world( Base *instance ) { instance->world(); }
};
Live Demo
Unfortunately, overload resolution takes place at compile time whereas dynamic-dispatching takes place at run-time. Thus, if you intended for the compiler to deduce the underlying type from a Base pointer and then pick-up the right member function from Test class, this is not feasible.