How to cast from parent to interface of chlid class - c++

Question

Say I have a parent class Parent and child classes Child1 and Child2 having the latter implementing MyInterface:
class Parent {
public:
Parent();
virtual ~Parent();
virtual void MyMethod();
}
class MyInterface {
public:
virtual ~MyInterface() {}
virtual void MyInterfaceMethod() = 0;
}
class Child1 : public Parent {
public:
Child1();
virtual ~Child1();
}
class Child2 : public Parent, MyInterface {
public:
Child2();
virtual ~Child2();
virtual void MyInterfaceMethod() override;
}
And say I'm given a Parent* pointer, and I want to check if the object is implementing MyInterface and if yes, cast it to MyInterface*.
I've tried to achieve it this way:
void MyFunction(Parent* p) {
MyInterface* i = dynamic_cast<MyInterface*>(p);
if (i != 0)
DoSomething();
else
cout << "Cannot do anything.";
}
But i always equals to 0 which says it is never casted to the type MyInterface* even if I know for sure that the object has the good type.
How should I achieve this?

Answer 1

Child2 private inherits from MyInterface, unless MyFunction() has the privilege to access the private base subobject, dynamic_cast will always fail.
Since MyInterface seems to be an interface, I think you want public inheritance.
class Child2 : public Parent, public MyInterface { }
// ~~~~~~
LIVE (Other errors fixed)

Answer 2

Your classes must be polymorphic types for dynamic_cast to work.
The simplest way of achieving this is to add
virtual ~Parent() = default;
in the public area of the Parent class. Then the dynamic_cast will sniff around the inheritance tree for your interface like a truffling pig.

Answer 3

Alternatively, instead of using dynamic_cast, we could use the Visitor Pattern:
#include <iostream>
class MyInterface {
public:
virtual void DoSomething() = 0;
};
class Parent {
public:
virtual ~Parent() = default;
virtual void accept(class Visitor& visitor) = 0;
};
class Child1 : public Parent {
public:
virtual void accept(Visitor& visitor);
};
class Child2 : public Parent, public MyInterface {
public:
virtual void accept(Visitor& visitor);
virtual void DoSomething();
};
class Visitor
{
public:
void visit(Child1& child);
void visit(Child2& child);
};
void Child1::accept(Visitor& visitor) { visitor.visit(*this); }
void Child2::accept(Visitor& visitor) { visitor.visit(*this); }
void Child2::DoSomething() { std::cout << "Do something.\n"; }
void Visitor::visit(Child1& child) { std::cout << "Cannot do anything.\n"; }
void Visitor::visit(Child2& child) { child.DoSomething(); }
void MyFunction(Parent& p) {
Visitor v;
p.accept(v);
}
int main()
{
Child1 c1;
Child2 c2;
MyFunction(c1);
MyFunction(c2);
}
Output:
Cannot do anything.
Do something.