多态与虚函数3

#include <iostream>  

using namespace std;

class Y
{
private:
	int i;
public:
	Y(){}
	Y(int ii) : i(ii) {}
};

class X : public Y  // 这个是继承，在继承的时候，X 类中含有的函数与Y 函数相同，则将Y类的此函数屏蔽掉，无论参数是否相同，只要函数一样就将其屏蔽掉，  
{
private:
	int i;
	float f;
	char c;
	char* s;
public:
	X() : Y(10), i(7), f(1.6), c('b'), s("xiao")  // 在冒号后面是进行初始化，是初始化列表，  
	{
		cout << "X()" << endl;
	}
};
class Base1
{
public:
	Base1(int)  // 构造函数不能是虚的，
	{
		cout << "Base1 constructor\n";
	}
	virtual ~Base1() // 析构函数必须是虚的，调用此析构函数的时候调用的是所有被重写的析构函数，
	{
		cout << "Base1 destructor\n";
	}
};

class Member1
{
public:
	Member1(int)
	{
		cout << "Member1 constructor\n";
	}
	~Member1()
	{
		cout << "Member1 destructor\n";
	}
};
class Member2
{
public:
	Member2(int)
	{
		cout << "Member2 constructor\n";
	}
	~Member2()
	{
		cout << "Member2 destructor\n";
	}
};
class Member3
{
public:
	Member3(int)
	{
		cout << "Member3 constructor\n";
	}
	~Member3()
	{
		cout << "Member3 destructor\n";
	}
};
class Member4
{
public:
	Member4(int)
	{
		cout << "Member4 constructor\n";
	}
	~Member4()
	{
		cout << "Member4 destructor\n";
	}
};

class Derived1 : public Base1
{
	Member1 m1;
	Member2 m2;
public:
	Derived1(int) : m1(1), m2(2), Base1(3)
	{
		cout << "Derived1 constructor\n";
	}
	~Derived1()
	{
		cout << "Derived1 destructor\n";
	}
};

class Derived2 : public Derived1
{
	Member3 m3;
	Member4 m4;
public:
	Derived2() : m4(1), m3(2), Derived1(4)
		// 调用此类的构造函数的时候先要执行初始化列表，要先执行继承的构造函数再执行m3 和 m4  

	{
		cout << "Derived2 constructor\n";
	}
	~Derived2()
	{
		cout << "Derived2 destructor\n";
	}
};

int main()
{
	//X x;  
	/*Derived2 d2;*/
	Base1* b = new Derived2();

	delete b;

	return 0;
}