Checking for derived class type - c++

Question

This is an example of a problem I have while designing an interface.
I have a class Animal and I have derived Cat, Dog and Lion from it. Now I have a function 'feedFood' which takes in the base class Animal as parameter. Based on the type of animal I should feed different food to the Animal.
So how do I check the type of the animal in the 'feedFood' function.
There are 3 methods I could think of
Adding a 'AnimalType' enum in the base class which is set to the right type in the derived class.
Add a virtual function in base class to return a string with animal type. In derived class return the proper string for the animal name.
Use typeid or dynamic_cast to check the type of the derived class in the 'feedFood' function.
Which is the best method or is there any other better approach for this?

Answer 1

You are currently saying this:
void feedFood(Animal &);
Cat myCat;
Dog myDog;
feedFood(myCat);
feedFood(myDog);
// Problem: How does feedFood() know what's going on?
To use polymorphism, make the feeding function a virtual member of Animal:
struct Animal
{
virtual void feedFood() = 0; // pure virtual or default behaviour, up to you
virtual ~Animal() { } // always provide virtual destructor!
/* ... */
};
struct Cat : public Animal
{
void feedFood() { /* Cat implementation */ }
/* ... */
};
// Usage:
// via reference
void feed(Animal & a) { a.feedFood(); }
// via pointer
Animal * b = new Bat;
b->feedFood();

Answer 2

Try this:
class Animal{};
class Dog: public Animal{};
class Cat: public Animal{};
class Lion: public Animal{};
void FeedFood(Dog& d)
{
cout << "Feeding the dog.\n";
return;
}
void FeedFood(Cat& c)
{
cout << "Feeding the cat.\n";
return;
}
void FeedFood(Lion& l)
{
cout << "Feeding the lion.\n";
}
void FeedFood(Animal& a)
{
cout << "Feeding an unknown animal.\n";
return;
}
With the above functions, the compiler will take care of feeding animals.
Sometimes, functionality may be better placed outside the class.

Answer 3

Okay, somewhat complicated, but resolves at compile time:
template <class _Derived>
class Animal
{};
class Dog: public Animal<Dog>
{
public:
void Feed()
{
cout<<"Feeding Dog...";
}
};
class Cat: public Animal<Cat>
{
public:
void Feed() { /* Feed Cat*/ }
};
And implement ONE template function:
template<class _AnimalType>
void FeedAnimal(_AnimalType& animal)
{
animal.Feed();
}
Create instance of any class, and call FeedAnimal:
Dog dog;
Cat cat;
FeedAnimal(dog);
FeedAnimal(cat);
If Feed is not implemented by derived-class, you may not get error, until you call Feed template function. Therefore, if Lion is implemented like:
class Lion : public Animal<Lion>
{};
You won't get any error that Feed is missing from class. As soon as you make call to FeedAnimal with Lion, you would get error that Lion is missing Feed method.
This is one of the hack to ensure that derived class implements Feed:
template <class _Derived>
class Animal
{
void (_Derived::*pDummy)();
public:
Animal()
{
pDummy = &_Derived::Feed;
}
};
Dirty, but works!

Answer 4

Not the animal gets food feeded, but it ates it. So add a virtual 'eat' method together with some FoodProvider on which the Animal can eat on.
Update:
So instead of an
void feed (const Food & food);
use
virtual void eatFrom (FoodProvider * provider);
That way you can also implement different food resources in your provider.