C++ Interface With Explicit Derived Methods - c++

Question

I have a sample interface that delegates behavior to the implementing class:
class IBase
{
public:
virtual void Do(IBase* base) = 0;
virtual std::string name() = 0;
};
I then have 1..N classes that implement IBase:
class A : public IBase
{
public:
virtual void Do(IBase* base);
virtual std::string name() { return "A"; }
};
class B : public IBase
{
public:
virtual void Do(IBase* base);
virtual std::string name() { return "B"; }
};
I then want the body of the Do() method to call free methods that are defined for everything that implements IBase:
void method(A* a, B* b)
{
std::cout << a->name() << " " << b->name() << std::endl;
}
void method(B* b, A* a)
{
method(b, a);
}
This doesn't compile because with this code because IBase cannot resolve to the derived type:
void Test::Run()
{
IBase* a = new A();
IBase* b = new B();
b->Do(a);
}
How do I make this work, or something similar? The free methods implement all possible combinations, and it seems like there is a trick to get the IBase* to be acceptable in one of the overloads.
Secondly, how do you implement a interface scheme where each implementer has a shared method that takes an interface? Perhaps this is better implemented with just free methods and removing the Do(IBase*) from the IBase interface.
Edit:
It works if (a) is declared to be type A. Whats the best way to make the code above work with the IBase?
void Test::Run()
{
A* a = new A();
IBase* b = new B();
b->Do(a);
}
Literal code I am compiling:
class IBase
{
public:
virtual void Do(IBase* base) = 0;
virtual std::string name() = 0;
};
class A : public IBase
{
public:
virtual void Do(IBase* base);
virtual std::string name();
};
class B : public IBase
{
public:
virtual void Do(IBase* base);
virtual std::string name();
};
class Test
{
public:
static void Run();
};
namespace
{
void method(A* a, B* b)
{
std::cout << a->name() << " " << b->name() << std::endl;
}
void method(B* b, A* a)
{
method(b, a);
}
}
void A::Do(IBase* base)
{
method(this, base);
}
std::string A::name()
{
return "A";
}
void B::Do(IBase* base)
{
method(this, base);
}
std::string B::name()
{
return "B";
}
void Test::Run()
{
IBase* a = new A();
IBase* b = new B();
b->Do(a);
}
Visual Studio 2013:
Error 1 error C2665: 'anonymous-namespace'::method' : none of the 2 overloads could convert all the argument types
Error 2 error C2665: 'anonymous-namespace'::method' : none of the 2 overloads could convert all the argument types

Answer 1

So if I understand you correctly, you want A::Do to look like this:
void A::Do(IBase* other) {
if other is A, then call:
method(this,other) for arguments A,A
else if other is B, then call
method(this,other) for arguments A,B
etc.
}
There are two answers to that. The best approach is usually to change the design. Make method a virtual function in IBase instead of a free function, and extract any functionality specific to A and B into yet another virtual function.
class IBase
{
public:
virtual void Do(IBase* base) = 0;
virtual std::string name() = 0;
virtual void method(IBase* other);
virtual void method2() = 0;
};
void IBase::method(IBase* other) {
std::cout << name() << " " << other->method2() << std::endl;
}
The other option is to use type casting:
void A::Do(IBase* other) {
if other is A, then call:
method(this,dynamic_cast<A*>(other)))
else if other is B, then call
method(this,dynamic_cast<B*>(other))
etc.
}
This approach usually does not scale well, is hard to maintain and error-prone.