[C++] 상속된 클래스에서 형변환 & 가상 함수

#include <iostream>
using namespace std;

/*** Class alpha ***/
class alpha
{
public:
	int _x;
public:
	alpha();
	alpha(int x);
	alpha(const alpha& pt);
	void print();
};

alpha::alpha()
{
	_x=0;
}

alpha::alpha(int x)
{
	_x=x;
}

alpha::alpha(const alpha& pt)
{
	_x=pt._x;
}

void alpha::print()
{
	cout << "alpha Call" << endl;
}
/*** Class beta ***/
class beta : public alpha
{
public:
	int _y;
public:
	beta();
	beta(int y);
	beta(const beta& pu);
	void print();
};

beta::beta()
{
	_y=0;
}

beta::beta(int y)
{
	_y=y;
}

beta::beta(const beta &pu)
{
	_y=pu._y;
}
void beta::print()
{
	cout << "beta Call" << endl;
}

/*** Class gamma ***/
class gamma : public beta
{
public:
	int _z;

	gamma();
	gamma(int z);
	gamma(const gamma& pv);
	void print();
};

gamma::gamma()
{
	_z=0;
}
gamma::gamma(int z)
{
	_z=z;
}
gamma::gamma(const gamma& pv)
{
	_z=pv._z;
}
void gamma::print()
{
	cout << "gamma Call" << endl;
}
/*** main ***/
int main()
{
	// 클래스 타입 선언
	alpha a;
	a.print();
	beta b;
	b.print();
	gamma c;
	c.print();
	cout << endl;

	// 포인터로 선언

	alpha* aa=&a;
	beta* bb=&b;
	gamma* cc=&c;
	aa->print();
	bb->print();
	cc->print();
	cout << endl;

	// 클래스 포인터가 gamma객체를 가리킬때

	alpha* aaa=&c;
	beta* bbb=&c;
	gamma* ccc=&c;
	bbb->print();
	aaa->print();
	ccc->print();
	cout << endl;

	// 클래스 포인터가 alpha 객체를 가리킬때
	alpha* a4=&a;
	//beta* b4=&a; 에러, beta객체가 alpha객체보다 많은 멤버를 가진다.
	//gamma* c4=&a; 에러, gamma객체가 alpha객체보다 많은 멤버를 가진다.
	a4->print();
	//b4->print();
	//c4->print();

	return 0;
}

가상함수가 없는 원본 코드일때

class alpha에서 print()함수가 virtual 함수일때의 결과

class beta에서 print()함수가 virtual 함수일때의 결과

class gamma에서 print()함수가 virtual 함수일때의 결과