day06---继承中的析构和构造

类型兼容性原则

类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。通过公有继承，派生类得到了基类中除构造函数、析构函数之外的所有成员。这样，公有派生类实际就具备了基类的所有功能，凡是基类能解决的问题，公有派生类都可以解决。类型兼容规则中所指的替代包括以下情况：
子类对象可以当作父类对象使用
子类对象可以直接赋值给父类对象
子类对象可以直接初始化父类对象
父类指针可以直接指向子类对象
父类引用可以直接引用子类对象
在替代之后，派生类对象就可以作为基类的对象使用，但是只能使用从基类继承的成员。
类型兼容规则是多态性的重要基础之一。

第一层：子类对象可以当作父类对象使用

#include <iostream>
using namespace std;
class Parent
{
public:
	void printP()
	{
		cout << "woshi die" << endl;
	}

private:

};
class child:public Parent
{
public:
	void printC()
	{
		cout << "我是儿子" << endl;
	
	}

private:
};

void howToParent(Parent *base)
{
	base->printP();
}
void howToParent1(Parent &base)
{
	base.printP();
}
int main()
{
	Parent p1;
	p1.printP();

	child c1;
	c1.printC();
	c1.printP();
	//1.基类指针指向zi类对象
	Parent *p = NULL;
	p = &c1;
	p->printP();
	//2.指针做函数参数
	howToParent(&p1);
	howToParent(&c1);
	//1-3，引用做函数参数列表。
	howToParent1(c1);
	system("pause");
	return 1;
}

第二层意思：用子类的对象初始化父类的对象

如上代码。

继承中的对象模型

继承中，内存分配如上。

继承中的构造析构调用原则

问题：如何初始化父类成员？父类与子类的构造函数有什么关系
在子类对象构造时，需要调用父类构造函数对其继承得来的成员进行初始化
在子类对象析构时，需要调用父类析构函数对其继承得来的成员进行清理

逐步调用，B类在继承到A类的数据成员时，A已经初始化了。C继承到的B类的对象时，也是初始化好的。
代码如下：：

#include
using namespace std;

//结论
//先 调用父类构造函数 在调用 子类构造函数
//析构的顺序 和构造相反
/*
1、子类对象在创建时会首先调用父类的构造函数
2、父类构造函数执行结束后，执行子类的构造函数
3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
4、析构函数调用的先后顺序与构造函数相反
*/

class Parent
{
public:
	Parent(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout << "fu gouzao ..." << endl;
	}
	~Parent()
	{
		cout << "fu xi gou .." << endl;
	}

	void printP(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout << "..." << endl;
	}
private:
	int a;
	int b;
};


class child : public Parent
{
public:
	child(int a, int b, int c) : Parent(a, b)
	{
		this->c = c;
		cout << "zi gouzao" << endl;
	}
	~child()
	{
		cout << "zoxigou" << endl;
	}
	void printC()
	{
		cout << "..." << endl;
	}
protected:
private:
	int c;
};


void playObj()
{
	child c1(1, 2, 3);
}
void main()
{
	//Parent p(1, 2);
	playObj();


	cout << "hello..." << endl;
	system("pause");
	return;
}

输出结果：
fu gouzao …
zi gouzao
zoxigou
fu xi gou …
hello…
请按任意键继续. . .

继承中的同名成员变量处理方法

class  A
{
public:
	int a;
	int b;
	void get()
	{
		cout<<"b=" << b << endl;
	}
private:
};
class B:public A
{
public:
	int b;
	int c;
	void get_child()
	{
		cout << "child_b=" << b << endl;
	}
private:
};
int main()
{
	B b1;
	A a1;
	a1.b = 2;
	b1.b = 1;
	b1.get_child();
	b1.A::b = 100;//这是修改A中的代码。
	b1.get();   //fb1对象调用从A继承过来的get（）方法。
	system("pause");
	return 1;
}

输出结果：
child_b=1
b=100
请按任意键继续. . .

派生类中的static关键字

理论知识
基类定义的静态成员，将被所有派生类共享
根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质 （遵守派生类的访问控制）
 派生类中访问静态成员，用以下形式显式说明：
类名 :: 成员
或通过对象访问 对象名 . 成员
示例代码：
class A
{
A() //构造函数默认是私有的，所以必须声明public.
{
cout<<“A的构造函数”<<endl;
}
public:
/*
static int a;
int b;
/
public:
/
void get()
{
cout<<"b "<<b<<endl;
}
void print()
{
cout<<"AAAAA "<<endl;
}
*/
protected:
private:
};

//int A::a = 100; //这句话 不是简单的变量赋值 更重要的是 要告诉C++编译器 你要给我分配内存 ,我再继承类中 用到了a 不然会报错…

/*
class B : private A
{

public:
int b;
int c;
public:
void get_child()
{
cout<<"b "<<b<<endl;
cout<<a<<endl;
}
void print()
{
cout<<"BBBB "<<endl;
}
protected:
private:
};
*/

//1 static关键字 遵守 派生类的访问控制规则

//2 不是简单的变量赋值 更重要的是 要告诉C++编译器 你要给我分配内存 ,我再继承类中 用到了a 不然会报错…

//3 A类中添加构造函数
//A类的构造函数中 A的构造函数是私有的构造函数 …
//被别的类继承要小心…
//单例场景 … UML

void main()
{
A a1;
//a1.print();

 //B b1;
// b1.get_child();
system("pause");

}

void main01()
{
// B b1;
//b1.a = 200;
system(“pause”);
}

总结：

1> static函数也遵守3个访问原则
2> static易犯错误（不但要初始化，更重要的显示的告诉编译器分配内存）
3> 构造函数默认为private

多继承

示例：

#include <iostream>
using namespace std;
class base1
{
public:
	base1(int b1)
	{
		this->b1 = b1;
	}
	void printb1()
	{
		cout << "b1" << b1<<endl;
	}
private:
	int b1;
};
class base2
{
public:
	base2(int b2)
	{
		this->b2 = b2;
	}
	void printb2()
	{
		cout << "b2" << b2<<endl;
	}
private:
	int b2;
};
class  B:public base1,public base2
{
public:
	**B(int b1,int b2,int c):base1(b1),base2(b2)  //初始化。**
	{
		this->c = c;
	}
	void printc()
	{
		cout << "c" << c<<endl;
	}
private:
	int c;
};
int main()
{
	B b1(5, 5, 6);
	b1.printb1();
	b1.printb2();
	b1.printc();
	system("pause");
	return 1;
}

输出：b15
b25
c6
请按任意键继续. . .

虚继承

如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性

分析：

总结：
 如果一个派生类从多个基类派生，而这些基类又有一个共同
的基类，则在对该基类中声明的名字进行访问时，可能产生
二义性
 如果在多条继承路径上有一个公共的基类，那么在继承路径的某处
汇合点，这个公共基类就会在派生类的对象中产生多个基类子对象
 要使这个公共基类在派生类中只产生一个子对象，必须对这个基类
声明为虚继承，使这个基类成为虚基类。
 虚继承声明使用关键字 virtual

实验：注意增加virtual关键字后，构造函数调用的次数。