Polymorphism in C++

Every time I have a job interview, people ask me questions regarding polymorphism and the role of virtual keyword in C++. It saddens me that I did not know the answer to them, and this post is to explain what they are to others who may be asked the same questions in their job interviews.

First, polymorphism in programming means that an object may take different forms. Assume you have Polygon class, from which you derive Rectangle and Triangle classes. You have an object that will be either Rectangle or Triangle, but you do not know what it will be until the runtime. In order to write code such that it shares as much as it can, we can write the following:

	#include <stdio.h>
	#include <stdlib.h>
	#include <string>
	using namespace std;
	class Polygon {
	public:
	Polygon(string name=string("polygon")) : name(name) {
	printf("Polygon()\n");
	}
	virtual void print() {
	printf("This is a polygon object with name: %s\n", name.c_str());
	}
	virtual int area(int w, int h) {
	return -1;
	}
	virtual ~Polygon() {
	printf("~Polygon()\n");
	}
	void non_virtual_print() {
	printf("This is a polygon object with name: %s\n", name.c_str());
	}
	protected:
	string name;
	};
	class Triangle : public Polygon {
	public:
	Triangle(string name=string("triangle")) : Polygon(name) {
	printf("Triangle()\n");
	}
	void print() {
	printf("This is a triangle object with name: %s\n", name.c_str());
	}
	int area(int w, int h) {
	return w*h/2;
	}
	~Triangle() {
	printf("~Triangle()\n");
	}
	void non_virtual_print() {
	printf("This is a triangle object with name: %s\n", name.c_str());
	}
	};
	class Rectangle : public Polygon {
	public:
	Rectangle(string name=string("rectangle")) : Polygon(name) {
	printf("Rectangle()\n");
	}
	void print() {
	printf("This is a rectangle object with name: %s\n", name.c_str());
	}
	int area(int w, int h) {
	return w*h;
	}
	~Rectangle() {
	printf("~Rectangle()\n");
	}
	void non_virtual_print() {
	printf("This is a rectangle object with name: %s\n", name.c_str());
	}
	};
	int main(int argc, char** argv) {
	int num_vertices = atoi(argv[1]);
	Polygon *ptr;
	switch (num_vertices) {
	case 3: ptr = new Triangle(); break;
	case 4: ptr = new Rectangle(); break;
	default: ptr = new Polygon(); break;
	}
	ptr->print();
	ptr->non_virtual_print();
	printf("area with w=3 and h=4 is %d\n", ptr->area(3, 4));
	delete ptr;
	return 0;
	}

view raw poly.cpp hosted with ❤ by GitHub

Compile it
$ g++ poly.cpp

and running the program with various inputs should help us understand what is going on:
$ ./a.out 2
Polygon()
This is a polygon object with name: polygon
This is a polygon object with name: polygon
area with w=3 and h=4 is -1
~Polygon()

$ ./a.out 3
Polygon()
Triangle()
This is a triangle object with name: triangle
This is a polygon object with name: triangle
area with w=3 and h=4 is 6
~Triangle()
~Polygon()

$ ./a.out 4
Polygon()
Rectangle()
This is a rectangle object with name: rectangle
This is a polygon object with name: rectangle
area with w=3 and h=4 is 12
~Rectangle()
~Polygon()

Note that only virtual methods take polymorphic behavior, meaning that the method corresponding to the object's class is executed. This is the role of the keyword virtual. Another thing to note is that for virtual destructor, the base class' destructor is still called, unlike regular methods that are overriden.