============================MODULE17=======================================
|                                                                         |
|  The program examples' source codes have been arranged in the same      |
|  order that appeared in the Tutorial. This is unedited and unverified   |
|  compilation. Published as is basis for educational, reacretional and   |
|  brain teaser purposes. All trademarks, copyrights and IPs, wherever    |
|  exist, are the sole property of their respective owner and/or          |
|  holder. Any damage or loss by using the materials presented in this    |
|  tutorial is USER responsibility. Part or full distribution,            |
|  reproduction and modification is granted to any body.                  |
|     Copyright 2003-2005 © Tenouk, Inc. All rights reserved.		  |
|          Distributed through http://www.tenouk.com			        |
|        		                                                        |
|									                    |
===========================================================================
Originally programs compiled using Borland C++. Examples compiled using
VC++/VC++ .Net and gcc or g++ are given at the end of every Module.
For example if you want to compile C++ codes using VC++/VC++ .Net, change
the header file accordingly.  Just need some modification for the header
files...:

-------------------------------------------------
#include <iostream.h>
//for system()
#include <stdlib.h>

...
{
C++ codes...
}
-------------------------------------------------
should be changed to:
-------------------------------------------------
#include <iostream>
//use C++ wrapper to call C functions from C++ programs...
#include <cstdlib>
using namespace std;

...
{
C++ codes...
}
-------------------------------------------------
In VC++/VC++ .Net the iostream.h (header with .h) is not valid anymore.
It should be C++ header, <iostream> so that it comply to the standard.
In older Borland C++ compiler this still works, but not proper any more...
and for standard C/C++ the portability should be no problem or better
you read Module23 at http://www.tenouk.com/Module23.html to get
the big picture...For C codes, they still C codes :o)
=========================================================================
=========================================================================

//Program poly1.cpp.  For VC++/VC++ .Net change the
//header files accordingly...
//#include  <iostream>
//#include  <cstdlib>
//using namespace std;
 
#include  <iostream.h>
#include  <stdlib.h>

//---base class declaration
//---and implementation part-----
class   vehicle
{
   int    wheels;
   float  weight;
   public:
   void  message(void)  //first message()
   {cout<<"Vehicle message, from vehicle, the base class\n";}
};

//----derived class declaration and implementation part-----
class  car : public  vehicle
{
   int   passenger_load;
   public:
   void   message(void)    //second message() 
   {cout<<"Car message, from car, the vehicle derived class\n";}
};

class  truck : public  vehicle
{
   int  passenger_load;
   float   payload;
   public:
   int  passengers(void) {return  passenger_load;}
};

class  boat : public  vehicle
{
   int  passenger_load;
   public:
   int  passengers(void) {return  passenger_load;}
   void  message(void)     //third message() 
   {cout<<"Boat message, from boat, the vehicle derived class\n";}
};

//----the main program---
int  main()
{
  vehicle  unicycle;
  car      sedan_car;
  truck    trailer;
  boat     sailboat;

  unicycle.message();
  sedan_car.message();
  trailer.message();
  sailboat.message();
  
     //base and derived object assignment
     unicycle = sedan_car;      
     unicycle.message();
  
  system("pause”);
  return 0;
}

----------------------------------------------------------------------------------------

//Program poly2.cpp
#include  <iostream.h>
#include  <stdlib.h>

//---base class declaration
//---and implementation part-----
class   vehicle
{
   int    wheels;
   float  weight;
   public:
   virtual void  message(void)
   //first message(), with virtual keyword
   {cout<<"Vehicle message, from vehicle, the base class\n";}
};

//----derived class declaration and implementation part-----
class  car : public  vehicle
{
   int   passenger_load;
   public:
   void   message(void)    //second message()
   {cout<<"Car message, from car, the vehicle derived class\n";}
};

class  truck : public  vehicle
{
   int  passenger_load;
   float   payload;
   public:
   int  passengers(void) {return  passenger_load;}
};

class  boat : public  vehicle
{
   int  passenger_load;
   public:
   int  passengers(void) {return  passenger_load;}
   void  message(void)     //third message()
   {cout<<"Boat message, from boat, the vehicle derived class\n";}
};

//------the main program----
int   main()
{
    vehicle   unicycle;
    car       sedan_car;
    truck     trailer;
    boat      sailboat;

   cout<<"Adding virtual keyword at the base class method\n";
   cout<<"-----------------------------------------------\n";
   unicycle.message();
   sedan_car.message();
   trailer.message();
   sailboat.message();
   
    //unicycle = sedan_car;
    //sedan_car.message();
   
   system("pause");
   return  0;
}

--------------------------------------------------------------------------------------------

//Program poly3.cpp
#include  <iostream.h>
#include  <stdlib.h>

//---base class declaration
//---and implementation part-----
class   vehicle
{
   int    wheels;
   float  weight;
   public:
   void  message(void)
   //first message()
   {cout<<"Vehicle message, from vehicle, the base class\n";}
};

//----derived class declaration and implementation part-----
class  car : public  vehicle
{
   int   passenger_load;
   public:
   void   message(void)    //second message()
   {cout<<"Car message, from car, the vehicle derived class\n";}
};

class  truck : public  vehicle
{
   int  passenger_load;
   float   payload;
   public:
   int  passengers(void) {return  passenger_load;}
};

class  boat : public  vehicle
{
   int  passenger_load;
   public:
   int  passengers(void) {return  passenger_load;}
   void  message(void)     //third message()
   {cout<<"Boat message, from boat, the vehicle derived class\n";}
};

//------the main program-----
int   main()    
{
    vehicle *unicycle;
    car     *sedan_car;
    truck   *trailer;
    boat    *sailboat;

    cout<<"Omitting the virtual keyword. Using\n";
    cout<<"pointer variables, and new keyword\n";
    cout<<"-----------------------------------\n";

    unicycle = new vehicle;
    unicycle->message();
    sedan_car = new car;
    sedan_car->message();
    trailer = new truck;
    trailer->message();
    sailboat = new boat;
    sailboat->message();
    
    unicycle = sedan_car;
    unicycle->message();
    
    
    system("pause");
    return  0;
}

------------------------------------------------------------------------------------------

//Program poly4.cpp
#include  <iostream.h>
#include  <stdlib.h>

//---base class declaration
//---and implementation part-----
class   vehicle
{
   int    wheels;
   float  weight;
   public:
   virtual void  message(void)
   //first message(), with virtual keyword
   {cout<<"Vehicle message, from vehicle, the base class\n";}
};

//----derived class declaration and implementation part-----
class  car : public  vehicle
{
   int   passenger_load;
   public:
   void   message(void)    //second message()
   {cout<<"Car message, from car, the vehicle derived class\n";}
};

class  truck : public  vehicle
{
   int  passenger_load;
   float   payload;
   public:
   int  passengers(void) {return  passenger_load;}
};

class  boat : public  vehicle
{
   int  passenger_load;
   public:
   int  passengers(void) {return  passenger_load;}
   void  message(void)     //third message()
   {cout<<"Boat message, from boat, the vehicle derived class\n";}
};

//------the main program-------
int   main()    //main program
{
    vehicle *unicycle;
    car     *sedan_car;
    truck   *trailer;
    boat    *sailboat;

    cout<<"Re add the virtual keyword. Using\n";
    cout<<"pointer variables, and new keyword\n";
    cout<<"-----------------------------------\n";

    unicycle = new vehicle;
    unicycle->message();
       sedan_car = new car;
       sedan_car->message();
    trailer = new truck;
    trailer->message();
       sailboat = new boat;
       sailboat->message();
    
    unicycle = sedan_car;
    unicycle->message();
    
    system("pause");
    return  0;
}

-------------------------------------------------------------------------------------------

//Program poly5.cpp
#include  <iostream.h>
#include  <stdlib.h>

//---base class declaration
//---and implementation part-----
class   vehicle
{
   int    wheels;
   float  weight;
   public:
   void  message(void)
   //first message()
   {cout<<"Vehicle message, from vehicle, the base class\n";}
};

//----derived class declaration and implementation part-----
class  car : public  vehicle
{
   int   passenger_load;
   public:
   void   message(void)    //second message()
   {cout<<"Car message, from car, the vehicle derived class\n";}
};

class  truck : public  vehicle
{
   int  passenger_load;
   float   payload;
   public:
   int  passengers(void) {return  passenger_load;}
};

class  boat : public  vehicle
{
   int  passenger_load;
   public:
   int  passengers(void) {return  passenger_load;}
   void  message(void)     //third message()
   {cout<<"Boat message, from boat, the vehicle derived class\n";}
};

//------the main program------
int   main()
{

    cout<<"Omitting the virtual keyword. Using\n";
    cout<<"pointer variables, new and\n";
    cout<<"delete keyword\n";
    cout<<"-----------------------------------\n";

    vehicle   *unicycle;
    unicycle = new vehicle;
    unicycle->message();
     delete unicycle;

    unicycle = new car;
    unicycle->message();
      delete unicycle;

   unicycle = new truck;
   unicycle->message();
      delete unicycle;

   unicycle = new boat;
   unicycle->message();
     delete unicycle;

    //unicycle = sedan_car;
    //unicycle->message();
   
   system("pause");
   return  0;
}

--------------------------------------------------------------------------------------

//Program poly6.cpp
#include  <iostream.h>
#include  <stdlib.h>

//---base class declaration
//---and implementation part-----
class   vehicle
{
   int    wheels;
   float  weight;
   public:
   virtual void  message(void)
   //first message() method, with virtual keyword
   {cout<<"Vehicle message, from vehicle, the base class\n";}
};

//----derived class declaration and implementation part-----
class  car : public  vehicle
{
   int   passenger_load;
   public:
   void   message(void)    //second message()
   {cout<<"Car message, from car, the vehicle derived class\n";}
};

class  truck : public  vehicle
{
   int  passenger_load;
   float   payload;
   public:
   int  passengers(void) {return  passenger_load;}
};

class  boat : public  vehicle
{
   int  passenger_load;
   public:
   int  passengers(void) {return  passenger_load;}
   void  message(void)     //third message()
   {cout<<"Boat message, from boat, the vehicle derived class\n";}
};

//------the main program----
int   main()
{

    cout<<"Re add the virtual keyword. Using\n";
    cout<<"pointer variables, new and\n";
    cout<<"delete keyword\n";
    cout<<"-----------------------------------\n";

    vehicle  *unicycle;

   unicycle = new vehicle;
   unicycle->message();
      delete unicycle;
   unicycle = new car;
   unicycle->message();
 	   delete unicycle;
   unicycle = new truck;
   unicycle->message();
	   delete unicycle;

   unicycle = new boat;
   unicycle->message();
	   delete unicycle;

  cout<<"\nThe real virtual function huh!\n";
  
  system("pause");
  return  0;
}

----------------------------------------------------------------------------------------------

//polymorphic functions, virtual keyword
//program example...
#include <iostream.h>
#include <stdlib.h>

//------class declaration and implementation--------
//base class
class Shape
{
	//protected member variables should be available
	//for derived classes...
	protected:
	char* Color;
	
	public:
	//constructor, set the object's data
	Shape(){Color = "No Color!";}
	~Shape(){};
	//virtual base member function...
	//return the object's data
	virtual char* GetColor(){return Color;}
};

//derived class...
class Rectangle:public Shape
{
	//notice the same variable name, it is OK...
	char* Color;

	public:
	Rectangle(){Color = "bLue SkY!";}
	~Rectangle(){}
	//derived class member function
	//should also be virtual...
	char* GetColor(){return Color;}
};

class Square:public Shape
{
	char* Color;

	public:
	Square(){ Color = "yEllOw!";}
	~Square(){}
	char* GetColor(){return Color;}
};

class Triangle:public Shape
{
	char* Color;

	public:
	Triangle(){Color = "GrEEn!";}
	~Triangle(){}
	char* GetColor(){return Color;}
};

class Circle:public Shape
{
	char* Color;

	public:
	Circle(){Color = "aMbEr!";}
	~Circle(){}
	//let set different function name but
	//same functionality...
	char* GetMyColor(){return Color;}
};

//----main program---
int main()
{
	//instantiate objects of class type...
	Shape ObjOne;
	Rectangle ObjTwo;
	Square ObjThree;
	Triangle ObjFour;
	Circle ObjFive;

	cout<<"Non polymorphic, early binding:"<<endl;
	cout<<"----------------------------------"<<endl;
	cout<<"Shape color:     "<<ObjOne.GetColor()<<endl;
	cout<<"Rectangle color: "<<ObjTwo.GetColor()<<endl;
	cout<<"Square color:    "<<ObjThree.GetColor()<<endl;
	cout<<"Triangle color:  "<<ObjFour.GetColor()<<endl;
	//notice the different function name as previous function...
	cout<<"Circle color:    "<<ObjFive.GetMyColor()<<endl;

	cout<<"\nPolymorphic, late binding:"<<endl;
	cout<<"--------------------------"<<endl;     

	//pointer variable of type Shape class...
	Shape *VirtualPtr;

	//object allocation of type Shape size...
	VirtualPtr = new Shape;
	cout<<"Shape color:     "<<VirtualPtr->GetColor()<<endl;
	cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
	//deallocate, clean up...
	delete VirtualPtr;

	VirtualPtr = new Rectangle;
	cout<<"Rectangle color: "<<VirtualPtr->GetColor()<<endl;
	cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
	delete VirtualPtr;

	VirtualPtr = new Square;
	cout<<"Square color:    "<<VirtualPtr->GetColor()<<endl;
	cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
	delete VirtualPtr;

	VirtualPtr = new Triangle;
	cout<<"Triangle color:  "<<VirtualPtr->GetColor()<<endl;
	cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
	delete VirtualPtr;

	//no GetColor() in this derived class, so use the GetColor
	//from the base class...
	VirtualPtr = new Circle;
	cout<<"Circle color:    "<<VirtualPtr->GetColor()<<endl;
	cout<<"  VirtualPtr pointer reference   = "<<&VirtualPtr<<"\n\n";
	delete VirtualPtr;

	//retest..
	VirtualPtr = new Triangle;
	cout<<"Triangle color:  "<<VirtualPtr->GetColor()<<endl;
	cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
	delete VirtualPtr;

	system("pause");
	return 0;
}

----------------------------------------------VC++/VC++ .Net-----------------------------------------------------

//Program poly6.cpp
#include  <iostream>
using namespace std;

//---base class declaration
//---and implementation part-----
class   vehicle
{
   int    wheels;
   float  weight;
   public:
   virtual void  message(void)
   //first message() method, with virtual keyword
   {cout<<"Vehicle message, from vehicle, the base class\n";}
};

//----derived class declaration and implementation part-----
class  car : public  vehicle
{
   int   passenger_load;
   public:
   void   message(void)    //second message()
   {cout<<"Car message, from car, the vehicle derived class\n";}
};
	
class  truck : public  vehicle
{
   int  passenger_load;
   float   payload;
   public:
   int  passengers(void) {return  passenger_load;}
};
	
class  boat : public  vehicle
{
   int  passenger_load;
   public:
   int  passengers(void) {return  passenger_load;}
   void  message(void)     //third message()
   {cout<<"Boat message, from boat, the vehicle derived class\n";}
};
	
//------the main program------
int   main()
{
    cout<<"Re add the virtual keyword. Using\n";
    cout<<"  pointer variables, new and\n";
    cout<<"       delete keyword\n";
    cout<<"==================================\n";

	vehicle  *unicycle;

   unicycle = new vehicle;
   unicycle->message();
      delete unicycle;
   unicycle = new car;
   unicycle->message();
 	   delete unicycle;
   unicycle = new truck;
   unicycle->message();
	   delete unicycle;

   unicycle = new boat;
   unicycle->message();
	   delete unicycle;

  cout<<"\nThe real virtual function huh!\n";
  cout<<"==================================\n";

  return 0;
}

---------------------------------------------G++ on Linux/Fedora-------------------------------------------------------

///////-polymorph.cpp-/////////
///////-polymorphic functions, virtual function-////////
///////-FEDORA 3, g++ x.x.x-///////
#include <iostream>
using namespace std;

//------class declaration and implementation--------
//base class
class Shape
{
        //protected member variables should be available
        //for derived classes...
        protected:
        char* Color;

        public:
        //constructor, set the object's data
        Shape(){Color = "No Color!";}
        ~Shape(){};
        //virtual base member function...
        //return the object's data
        virtual char* GetColor(){return Color;}
};

//derived class...
class Rectangle:public Shape
{
        //notice the same variable name, it is OK...
        char* Color;

        public:
        Rectangle(){Color = "bLue SkY!";}
        ~Rectangle(){}
        //derived class member function
        //should also be virtual...
        char* GetColor(){return Color;}
};

class Square:public Shape
{
        char* Color;

        public:
        Square(){Color = "yEllOw!";}
        ~Square(){}
        char* GetColor(){return Color;}
};

class Triangle:public Shape
{
        char* Color;

        public:
        Triangle(){Color = "GrEEn!";}
        ~Triangle(){}
        char* GetColor(){return Color;}
};

class Circle:public Shape
{
        char* Color;

        public:
        Circle(){Color = "aMbEr!";}
        ~Circle(){}
        //let set different function name but
        //same functionality...
        char* GetMyColor(){return Color;}
};

//------main program-----
int main()
{
        //instantiate objects of class type...
        Shape ObjOne;
        Rectangle ObjTwo;
        Square ObjThree;
        Triangle ObjFour;
        Circle ObjFive;

        cout<<"Non polymorphic, early binding:"<<endl;
        cout<<"----------------------------------"<<endl;
        cout<<"Shape color:     "<<ObjOne.GetColor()<<".  ";
        cout<<" The address-->"<<&ObjOne<<endl;
        cout<<"Rectangle color: "<<ObjTwo.GetColor()<<". ";
        cout<<" The address-->"<<&ObjTwo<<endl;
        cout<<"Square color:    "<<ObjThree.GetColor()<<". ";
        cout<<" The address-->"<<&ObjThree<<endl;
        cout<<"Triangle color:  "<<ObjFour.GetColor()<<". ";
        cout<<" The address-->"<<&ObjFour<<endl;
        //notice the different function name as previous function...
        cout<<"Circle color:    "<<ObjFive.GetMyColor()<<". ";
        cout<<"The address-->"<<&ObjFive<<endl;

        cout<<"\nPolymorphic, late binding:"<<endl;
        cout<<"--------------------------"<<endl;

        //pointer variable of type Shape class...
        Shape *VirtualPtr;

        //object allocation of type Shape size...
        VirtualPtr = new Shape;
        cout<<"Shape color:     "<<VirtualPtr->GetColor()<<endl;
        cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
        //deallocate, clean up...
        delete VirtualPtr;

        VirtualPtr = new Rectangle;
        cout<<"Rectangle color: "<<VirtualPtr->GetColor()<<endl;
        cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
        delete VirtualPtr;

        VirtualPtr = new Square;
        cout<<"Square color:    "<<VirtualPtr->GetColor()<<endl;
        cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
        delete VirtualPtr;

        VirtualPtr = new Triangle;
        cout<<"Triangle color:  "<<VirtualPtr->GetColor()<<endl;
        cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
        delete VirtualPtr;

        //no GetColor() in this derived class, so use the GetColor
        //from the base class...
        VirtualPtr = new Circle;
        cout<<"Circle color:    "<<VirtualPtr->GetColor()<<endl;
        cout<<"  VirtualPtr pointer reference   = "<<&VirtualPtr<<"\n\n";
        delete VirtualPtr;

        //retest...
        VirtualPtr = new Triangle;
        cout<<"Triangle color:  "<<VirtualPtr->GetColor()<<endl;
        cout<<"  VirtualPtr pointer reference   = "<<VirtualPtr<<endl;
        delete VirtualPtr;

        return 0;
}

===========================================================================================================