• Polymorphism allows an object refernce variable or an object pointer to reference objects of different types, and to call the correct member functions, depending upon the type of object being reference.
• Polymorphic behavior is not possible when an object is passed by value.

• Redefining, derived class redefine a base class member function, which is statically bound
• Override, redefine a virtual function, which is dynamically bound
  • Declare the override functions virtual
  • Declare the destructor virtual
  • Any class that has a virtual member function should also have a virtual destructor

#include <iostream>
#include "Vehicle.h"
#include "Car.h"
#include "Bicycle.h"

void display(Vehicle &v)
{
	std::cout<<v.getProducer()<<std::endl;
	std::cout<<v.toString()<<std::endl;//toString in Vehicle class is called
}

int main(int argc, char *argv[])
{
	Vehicle v("Buick");
	Car c("Honda", "Accord");
	Bicycle b("Yongjiu", 26);

	std::cout<<"-----------------------"<<std::endl;
	display(v);
	display(c);
	display(b);
	std::cout<<"-----------------------"<<std::endl;

	return 0;
}
			

At compile time, toString() function of Vehicle class is bound. Even toString() has been redefined in Car and Bicyle, the toString() of Vehicle class will be called

//Vehicle.h
#ifndef VEHICLE_H
#define VEHICLE_H
#include <iostream>
#include <string>

class Vehicle
{
	private:
		std::string producer;
	public:
		//constructor
		Vehicle(std::string s);

		std::string getProducer() const {return producer;}
		void setProducer(std::string producer);

		virtual std::string toString();

		~Vehicle();
};
#endif
			

//Vehicle.cpp
#include <iostream>
#include <string>
#include "Vehicle.h"

//constructor
Vehicle::Vehicle(std::string s):producer(s)
{
	std::cout<<"Vehicle Constructor ..."<<std::endl;
}

void Vehicle::setProducer(std::string producer)
{
	this->producer = producer;
}

std::string Vehicle::toString()
{
	std::string temp;
	temp = "Vehicle Producer: "+producer;
	return temp;
}

Vehicle::~Vehicle()
{
	std::cout<<"Vehicle Destructor ..."<<std::endl;
}
			

//Car.h
#ifndef CAR_H
#define CAR_H
#include <iostream>
#include <string>
#include "Vehicle.h"

class Car : public Vehicle
{
	private:
		std::string model;
	public:
		//constructor
		Car(std::string p, std::string m);

		std::string getModel() const {return model;}
		void setModel(std::string model);

		std::string toString();

		~Car();
};
#endif
			

//Car.cpp
#include <iostream>
#include <string>
#include "Vehicle.h"
#include "Car.h"

//constructor
Car::Car(std::string p, std::string m):Vehicle(p), model(m)
{
	std::cout<<"Car Constructor ..."<<std::endl;
}

void Car::setModel(std::string model)
{
	this->model = model;
}

std::string Car::toString()
{
	std::string temp;
	temp = "Car Producer: "+getProducer()+" Model: "+model;
	return temp;
}

Car::~Car()
{
	std::cout<<"Car Destructor ..."<<std::endl;
}
			

//Bicycle.h
#ifndef BICYCLE_H
#define BICYCLE_H
#include <iostream>
#include <string>
#include "Vehicle.h"

class Bicycle : public Vehicle
{
	private:
		int size;
	public:
		//constructor
		Bicycle(std::string p, int s);

		int getSize() const {return size;}
		void setSize(int s);

		std::string toString();

		~Bicycle();
};
#endif
			

//Bicycle.cpp
#include <iostream>
#include <string>
#include "Vehicle.h"
#include "Bicycle.h"

//constructor
Bicycle::Bicycle(std::string p, int s) : Vehicle(p), size(s)
{
	std::cout<<"Bicycle Constructor ..."<<std::endl;
}

void Bicycle::setSize(int s)
{
	size = s;
}

std::string Bicycle::toString()
{
	std::string temp;
	temp = "Bicycle Producer: "+getProducer()+" Size: "+std::to_string(size);
	return temp;
}

Bicycle::~Bicycle()
{
	std::cout<<"Bicycle Destructor ..."<<std::endl;
}
			

//main.cpp
#include <iostream>
#include "Vehicle.h"
#include "Car.h"
#include "Bicycle.h"

void display(Vehicle &v)
{
	std::cout<<v.getProducer()<<std::endl;
	std::cout<<v.toString()<<std::endl;
}

int main(int argc, char *argv[])
{
	Vehicle v("Buick");
	Car c("Honda", "Accord");
	Bicycle b("Yongjiu", 26);

	std::cout<<"-----------------------"<<std::endl;
	display(v);
	display(c);
	display(b);
	std::cout<<"-----------------------"<<std::endl;

	return 0;
}
			

• The compiler does not bind calls to toString() function of Vehicle class. Instead, it allows the program to bind calls at runtime. The version of toString() that belongs to the same class as the object responsible for the call
• Virtual functions are declared by placing virtual before the return type in the base class's prototype
• When a member function of the base class is declared virtual, any redefined versions of the functions in the derived class automatically become virtual. It is not necessary to declare the same functions as virtual in derived class. The redefined versions of the functions int the class derived from the derived class are also virtual.

//Use the code of static binding
#include <iostream>
#include "Vehicle.h"
#include "Car.h"
#include "Bicycle.h"

void display(Vehicle &v)
{
	std::cout<<v.toString()<<std::endl;
}

int main(int argc, char *argv[])
{
	Vehicle *c = new Car("Honda", "Accord");
	display(*c);

	delete c;

	return 0;
}
			

//Vehicle destructor will be called instead of Car destructor
Vehicle Constructor ...
Car Constructor ...
Vehicle Producer: Honda
Vehicle Detructor ...

#ifndef VEHICLE_H
#define VEHICLE_H
#include <iostream>
#include <string>

class Vehicle
{
	private:
		std::string producer;
	public:
		//constructor
		Vehicle(std::string s);

		std::string getProducer() const {return producer;}
		void setProducer(std::string producer);

		std::string toString();

		virtual ~Vehicle();
};
#endif
		

//Car destructor will be called
Vehicle Constructor ...
Car Constructor ...
Vehicle Producer: Honda
Car Destructor ...
Vehicle Detructor ...

For a class that could become a base class, always declare the destructor virtual

//Vehicle.h
#ifndef VEHICLE_H
#define VEHICLE_H
#include 
#include 

class Vehicle
{
	private:
		std::string producer;
	public:
		//constructor
		Vehicle(std::string s);

		std::string getProducer() const {return producer;}
		void setProducer(std::string producer);

		virtual std::string toString();

		virtual ~Vehicle();
};
#endif
			

//main.cpp
#include <iostream>
#include "Vehicle.h"
#include "Car.h"
#include "Bicycle.h"

void display(Vehicle *v)
{
	std::cout<<v->toString()<<std::endl;
}

int main(int argc, char *argv[])
{
	Vehicle *v[3] = {new Vehicle("Buick"), new Car("Honda", "Accord"), new Bicycle("Yongjiu", 26)};

	std::cout<<"-----------------------"<<std::endl;
	for(int i = 0; i < 3; i++)
		display(v[i]);
	std::cout<<"-----------------------"<<std::endl;

	for(int i = 0; i < 3; i++)
		delete v[i];

	return 0;
}
			

#ifndef VEHICLE_H
#define VEHICLE_H
#include <iostream>
#include <string>

class Vehicle
{
	private:
		std::string producer;
	public:
		//constructor
		Vehicle(std::string s);

		std::string getProducer() const {return producer;}
		void setProducer(std::string producer);

		virtual std::string toString() = 0;

		virtual ~Vehicle();
};
#endif
			

• virtual std::string toString() = 0, pure virtual function. Pure virtual function have no body, or definition in the base class.
• When a class contanis a pure virtual function, the class becomes an abstract class. Not able to create instance from the abstract classa.
• The virtual functions must be overridden in derived classes.
• The variables in base class should be declared as protected for inheritance
• toString() functiions in Car and Bicycle are virtual even the keyword "virtual" are missed since toString() function in Vehicle is virtual
• toString() function in Sedan is virtual since toString in Car is virtual
• ~Car() and ~Bicycle() are virtual even the keyword "virtual" are missed since ~Vehicle() in Vehicle is declared as virtual

• Starting out with C++, Tony Gaddis