多态与虚函数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;
}