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

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

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

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

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

string Pet::food()   
{
	return "????";
}


//
//  Derived Class 
// 
class Dog: public Pet 
{
public:
    Dog(string name);   // constructor
private:
	string voice();		// overriding 
	string food();		// redefining 
};

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


string Dog::voice()
{
	return "Woof!! Woof!";
}


string Dog::food()
{   
    return "bone";
}

//
// Derived Class
// 
class Cat: public Pet 
{
public:
    Cat(string name);       // constructor
	void likes();			// redefining     
private:
	string voice();			// overriding 
	virtual string food();	// changing to virtual and redefining it
};

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

void Cat::likes()
{   
    cout << I() << " likes " << food() << "!\n";
}

string Cat::voice()
{   
    return "Meow!! Meow!";
}

string Cat::food()
{   
    return "fish";
}

//
// Derived Class
// 
class BigCat: public Cat 
{
public:
    BigCat(string name);        // constructor
private:
	string voice(); // overriding 
	string food();  // overriding 
};

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



string BigCat::voice()
{   
    return "Grrr!! Grrr!";
}

string BigCat::food()
{   
    return "zebras";
}

int main()
{
   
//	Pet tommy("Tommy"); // Pet is an abstract class, can't be instantiated 
   
	Dog lucky("Lucky");
  	cout << "\n" << lucky.I() << " is a Dog.\n";
	lucky.goes();   
    lucky.likes(); 
  
	Cat mimi("Mimi");
    cout << "\n" << mimi.I() << " is a Cat.\n";
	mimi.goes();    
    mimi.likes();	

	BigCat simba("Simba");
    cout << "\n" << simba.I() << " is a BigCat.\n";
	simba.goes();   
    simba.likes();	

	cout << endl;

	cout << "************************************";

	Cat t("temp");

	t = mimi; 
	cout << "\nAssign a Cat -- " << t.I() << " -- to t.\n";
	t.goes();   
    t.likes(); 

	t = simba; 
	cout << "\nAssign a BigCat -- " << t.I() << " -- to t.\n";
	t.goes();   
    t.likes(); 


	/**********************/

	Cat *p;

    p = &mimi;
	cout << "\np points to a Cat -- " << p->I() << ".\n";
	p->goes();   
    p->likes(); 

    p = &simba;
    cout << "\np points to a BigCat -- " << p->I() << ".\n";
	p->goes();   
    p->likes(); 


    cout << endl;
	return 0;
}

/********** Output of this program ******************

Lucky is a Dog.
Lucky goes Woof!! Woof!!
Lucky likes ????!

Mimi is a Cat.
Mimi goes Meow!! Meow!!
Mimi likes fish!

Simba is a BigCat.
Simba goes Grrr!! Grrr!!
Simba likes zebras!

************************************
Assign a Cat -- Mimi -- to t.
Mimi goes Meow!! Meow!!
Mimi likes fish!

Assign a BigCat -- Simba -- to t.
Simba goes Meow!! Meow!!
Simba likes fish!

p points to a Cat -- Mimi.
Mimi goes Meow!! Meow!!
Mimi likes fish!

p points to a BigCat -- Simba.
Simba goes Grrr!! Grrr!!
Simba likes zebras!

Press any key to continue

*******************************************************/