#include <iostream>
#include <string>
using namespace std;
//
//
// Base class
class Pet 
{
public:
    Pet(string name);       // constructor
    void goes();			// NOT virtual function
    virtual void likes();   // virtual function, polymorphic         
    string I();
private:
    string my_name;
};

Pet::Pet(string name) 
:my_name(name) 
{
}

void Pet::goes()
{
    cout << I() << " goes !???\n"; 
}

void Pet::likes()
{   
    cout << I() << " likes ????\n";
}

string Pet::I()
{   
    return my_name;
}


//
//  Derived Class 
// 
class Dog: public Pet 
{
public:
    Dog(string name);   // constructor
    void goes();        // Not virtual function
    void likes();       // vir fun; same as "virtual void likes();"
private:
    int id_tag;
};

Dog::Dog(string name) 
:Pet(name) 
{
}

void Dog::goes()  
{   
    cout << I() << " goes Woof!! Woof!!\n"; 
}

void Dog::likes()
{   
    cout << I() << " likes bone.\n";
}

//
// Derived Class
// 
class Cat: public Pet 
{
public:
    Cat(string name);        // constructor
    virtual void goes();     // make it a virtual function
    void likes();			 // virtual function as it is
    virtual void hunts();    // a virtual function
private:
    int id_tag;
};

Cat::Cat(string name) 
:Pet(name) 
{
}

void Cat::goes()
{   
    cout << I() << " goes Meow!! Meow!!\n";
}

void Cat::likes()
{   
    cout << I() << " likes fish.\n";
}

void Cat::hunts()
{
	 cout << I() << " hunts birds.\n";
}

//
// Derived Class
//
class BigCat: public Cat 
{
public:
    BigCat(string name);        // constructor
    void goes();                // virtual function as it is 
    void likes();               // virtual function as it is
	void hunts();               // not a virtual
};


BigCat::BigCat(string name) 
:Cat(name) 
{
}

void BigCat::goes()
{   
    cout << I() << " roars Grrr!! Grrr!!\n";
}

void BigCat::likes()
{   
    cout << I() << " likes big meat.\n";
}

void BigCat::hunts()
{   
    cout << I() << " hunts zebras.\n";
}


//
// Derived Class
//
class Wolf: public Dog 
{
public:
    Wolf(string name);          // constructor
    virtual void goes();        // make is a virtual function
    void likes();               // virtual function as it is
	void hunts();               // not a virtual
};


Wolf::Wolf(string name) 
:Dog(name) 
{
}

void Wolf::goes()
{   
    cout << I() << " howls Whooo...\n";
}

void Wolf::likes()
{   
    cout << I() << " likes small meat.\n";
}

void Wolf::hunts()
{   
    cout << I() << " hunts rabbits.\n";
}


int main()
{
	char ans;
   
	Pet tommy("Tommy");
    cout << "\n" << tommy.I() << " is a Pet\n";
	tommy.goes();   //Tommy goes ???
    tommy.likes();  //Tommy likes ???
   
	Dog lucky("Lucky");
  	cout << "\n" << lucky.I() << " is a Dog\n";
	lucky.goes();   //Lucky goes Woof!! Woof!!
    lucky.likes();  //Lucky likes bone.
  
	Cat mimi("Mimi");
    cout << "\n" << mimi.I() << " is a Cat\n";
	mimi.goes();    //Mimi goes Meow!! Meow!!
    mimi.likes();	//Mimi likes fish.
	mimi.hunts();	//Mimi hunts birds.

	Wolf buck("Buck");
	cout << "\n" << buck.I() << " is a BigCat\n";
	buck.goes();   //Buck roars Grrr!! Grrr!! 
    buck.likes();	//Buck likes small meat.
	buck.hunts();  //Buck hunts rabbits. 

	BigCat simba("Simba");
	cout << "\n" << simba.I() << " is a BigCat\n";
	simba.goes();   //Simba roars Grrr!! Grrr!! 
    simba.likes();	//Simba likes big meat.
	simba.hunts();  //Simba hunts zebras. 

	cout << "\ntommy=simba -- then:";
	tommy = simba;
    cout << "\n" << tommy.I() << " is a Pet\n";
	tommy.goes();   //Tommy goes ???
    tommy.likes();  //Tommy likes ???
	tommy = Pet("Tommy");
    cout << "\n\nCan't do simba=tommy\n\n";

	cin.get(ans);


    Pet *p;
    cout << "\n\n**** p is a pointer of Pet\n";
	p = &tommy;
	cout << "\np=&tommy: p points to " << p->I() << "\n";
    p->goes();		//Lucky goes !???  -- p as a pet
    p->likes();     //Lucky likes ???? -- p as a pet
 	cin.get(ans);

    p = &lucky;
	cout << "\np=&luck: p points to " << p->I() << "\n";
    p->goes();		//Lucky goes !???   -- p as a pet, geos is not virtual
    p->likes();     //Lucky likes bone. -- p as a dog
 	cin.get(ans);
 
	p = &mimi;
    cout << "\np=&mimi: p points to " << p->I() << "\n";
    p->goes();		//Mimi goes !???   -- p as a pet, geos is not virtual
    p->likes();     //Mimi likes fish.  -- p as a cat
	//p->hunts();   //This is not allowed, p as a pet has no hunts function
	cout << "can't call p->hunts() as p is a pet.\n";
	cin.get(ans);

	p = &simba;
    cout << "\np=&simba: p points to " << p->I() << "\n";
	p->goes();		//Simba goes !???   -- p as a pet, geos is not virtual
    p->likes();     //Simba likes big meat. -- p as a BigCat.
	//p->hunts();   //This is not allowed, p as a pet has no hunts function
	cout << "can't call p->hunts() as p is a pet.\n";

	cin.get(ans);
    Cat *c;
    cout << "\n\n**** c is a pointer of Cat\n";
	// c = &tommy; c = &lucky;
    cout << "Can't do c=&tommy, c=&lucky\n\n";

	c = &mimi;
	cout << "\nc=&mimi: c points to " << c->I() << "\n";
    c->goes();       //c is Mimi it roars Grrr!! Grrr!!      
    c->likes();      //c is Mimi it likes big meat.
	c->hunts();      //c is Mimi it hunts zebras

    c = &simba;
	cout << "\nc=&simba: c points to " << c->I() << "\n";
    c->goes();       //c is Simba it roars Grrr!! Grrr!!      
    c->likes();      //c is Simba it likes big meat.
	c->hunts();      //c is Simba it hunts zebras
                          
    
	cin.get(ans);
    Dog *d;
    cout << "\n\n**** d is a pointer of Dog\n";
	// d = &tommy; d = &mimi;
    cout << "Can't do d=&tommy, d=&mimi\n\n";

	d = &lucky;
	cout << "\nc=&lucky: d points to " << d->I() << "\n";
    d->goes();       //c is Lucky as a Dog      
    d->likes();      //c is Lucky as a Dog

	d = &buck;
    cout << "\nd=&buck: d points to " << d->I() << "\n";
	d->goes();		//Buck goes !??? as a dog.
    d->likes();     //Buck likes samll as a Wolf.
	//d->hunts();   //This is not allowed, d as a dog has no hunts function
	cout << "can't call d->hunts() as d is a dog.\n";


	return 0;
}