Can I Perform inheritance outside of the class in C++11? - c++

Question

Say I want to overload a function outside of my classes with different pointer types. Can I do this in C++11?
struct Bird;
struct Bear;
struct Animal {
virtual Bird* AsBird() = 0;
virtual Bear* AsBear() = 0;
};
struct Bird : public Animal{
virtual Bird* AsBird(){ return this; }
virtual Bear* AsBear(){ return NULL; }
};
struct Bear : public Animal{
virtual Bird* AsBird(){ return NULL; }
virtual Bear* AsBear(){ return this; }
};
void Print(Animal* a){
cout << "I don't know what animal this is!" << endl;
}
void Print(Bear* b){
cout << "That's a bear!" << endl;
}
void Print(Bird* b){
cout << "That's a bird!" << endl;
}
int main(int argc, char* argv[]){
Animal* a = new Bear;
Bear* bear;
Bird* bird;
if (bear = a->AsBear()){
Print(bear);
} else if (bird = a->AsBird()){
Print(bird);
}
return 0;
}
This code works, but it's absolutely awful. I have tried playing around with templates and auto, but the compiler doesn't want anything to do with my evil experiments. Is there a legitimate way of doing this?

Answer 1

What you did is overloading the Print free function by changing the type of its parameter, there is no inheritance involved, and this is perfectly legal.
But you don't need it (or any dynamic_cast-like as you did) : What you should do is add a virtual void Print() const = 0 in your Animal base class instead, and override it in each derived class.
Example:
struct Animal {
virtual void Print() const = 0;
};
struct Bird : public Animal{
void Print() const { cout << "That's a bird!\n"; }
};
struct Bear : public Animal{
void Print() const { cout << "That's a bear!\n"; }
};
int main(){
Animal* a = new Bear;
a->Print();
Animal* b = new Bird;
b->Print();
}

Answer 2

As quantdev noted, the traditional way is adding a virtual function to your class hierarchy.
However, if you don't want to do it, you can use dynamic_cast, which was invented specifically for purposes like this.
struct Animal {
virtual ~Animal() {} // base class must have a virtual method to use dynamic_cast
};
...
if (bear = dynamic_cast<Bear*>(a)){
Print(bear);
} else if (bird = dynamic_cast<Bird*>(a)){
Print(bird);
}
This is a little better than what you have: if you add another inheriting class, you don't have to change your base class; you must only change your main function and add a new printing function.
If this is still "awful", maybe you should make Print a virtual function.

Answer 3

This looks like a use case for the visitor pattern.
struct Bird;
struct Bear;
struct Visitor
{
virtual void Visit(Bird& x) = 0;
virtual void Visit(Bear& x) = 0;
};
struct PrintVisitor : Visitor
{
void Visit(Bird& x) override { cout << "That's a bird!" << endl; };
void Visit(Bear& x) override { cout << "That's a bear!" << endl; };
};
struct Animal
{
virtual void Accept(Visitor& v) = 0;
};
struct Bird : public Animal
{
void Accept(Visitor& v) override { v.Visit(*this); }
};
struct Bear : public Animal
{
void Accept(Visitor& v) override { v.Visit(*this); }
};
int main(int argc, char* argv[])
{
Bear bear;
Bird bird;
PrintVisitor visitor;
Animal* a = &bear;
a->Accept(visitor);
a = &bird;
a->Accept(visitor);
}
Of course, it might just be easier to make Print a virtual member function.

Answer 4

The AsBear, AsBird functions, you've simply reimplemented dynamic_cast.
As far as the overloads of Print goes, the simplest solution here is to make Print be a virtual function in the Animal hierarchy.
My recommended solution would be to use the visitor pattern. Since that's what it seems like you're trying to do by decoupling the Print function and the class hierarchy.
#include <iostream>
struct Bird;
struct Bear;
struct Animal {
struct Visitor {
virtual void operator()(const Bird *) const = 0;
virtual void operator()(const Bear *) const = 0;
};
virtual void Accept(const Visitor &visitor) const = 0;
};
struct Bird : public Animal {
virtual void Accept(const Visitor &visitor) const override {
visitor(this);
}
};
struct Bear : public Animal {
virtual void Accept(const Visitor &visitor) const override {
visitor(this);
}
};
struct Print : public Animal::Visitor {
virtual void operator()(const Bird *) const override {
std::cout << "Bird" << std::endl;
}
virtual void operator()(const Bear *) const override {
std::cout << "Bear" << std::endl;
}
};
int main() {
Bird bird;
Animal *animal = &bird;
animal->Accept(Print());
}