c++继承

继承的好处：减少重复的代码；
形式：class A：继承方式 B{}；
A类称为子类或派生类；
B类称为父类或基类；
因此子类的成员包括两类：
一类是从父类继承过来的，一类是自己增加的成员；从基类继承过来的表达其共性，而新增的成员体现了其个性；
继承方式：

注：从父类中继承的私有属性，无论是在子类内还是子类外都无法通过子类进行访问。
子类继承父类后的空间变化：
1.父类中所有非静态成员属性都会被子类继承下去；
2.父类中私有成员属性是被编译器隐藏了，因此访问不到，但确实被继承下去了。

class A
{
public:
	int a;
protected:
	int b;
private:
	int c;
};
class B :public A
{
public:
	int d;
};
void test01()
{
	cout << sizeof(B) << endl;//输出16；
}
int main()
{
	test01();
	return 0;
}

继承中构造和析构的顺序：
子类继承父类后，当创建子类对象，也会调用父类的构造函数；
口诀：先有父后有子，白发送黑发；
意思是：构造函数先执行父类的再执行子类，析构函数子类的先执行父类后执行；

继承同名成员处理方式：
非静态同名
1.访问子类同名成员，直接访问即可；
2.访问父类同名成员，需要加作用域；
即：如果子类出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数（包括重载函数），如果想要访问到父类中被隐藏的同名成员函数，需要加作用域；

class Base
{
public:
	void func(int a)
	{
		cout << "Base中void func(int a)的调用" << endl;
	}
	void func()
	{
		cout << "Base中void func()的调用" << endl;
	}
	int m_A=100;
};
class Son :public Base
{
public:
	void func()
	{
		cout << "Son中void func()的调用" << endl;
	}
	int m_A=200;
};
void test01()
{
     //非静态成员引用必须与特定对象相对，因此要先创建对象。
	Son s1;
	cout << s1.m_A << endl;//200
	cout << s1.Base::m_A << endl;//100
	s1.func();//Son中void func()的调用
	s1.Base::func(100);//Base中void func(int a)的调用
	s1.Base::func();//Base中void func()的调用
}
int main()
{
	test01();
	return 0;
}

静态同名
有两种访问方法：
1.通过对象访问
2.通过类名访问

class Base
{
public:
	void static func(int a)
	{
		cout << "Base中void static func(int a)的调用" << endl;
	}
	void static func()
	{
		cout << "Base中void static func()的调用" << endl;
	}
	int static m_A;
};
int Base::m_A = 100;
class Son :public Base
{
public:
	void static func()
	{
		cout << "Son中void static func()的调用" << endl;
	}
	int static m_A;
};
int Son::m_A = 200;
void test01()
{
	//通过对象访问；
	Son s1;
	cout << s1.m_A << endl;
	cout << s1.Base::m_A << endl;
	s1.func();
	s1.Base::func(100);
	s1.Base::func();
	//输出：
	    //200
		//100
		//Son中void static func()的调用
		//Base中void static func(int a)的调用
		//Base中void static func()的调用
	//通过类名访问
	cout << Son::m_A << endl;
	cout << Son::Base::m_A << endl;
	Son::func();
	Son::Base::func(100);
	Son::Base::func();
	//输出：
	//200
	//100
	//Son中void static func()的调用
	//Base中void static func(int a)的调用
	//Base中void static func()的调用
}
int main()
{
	test01();
	return 0;
}

多继承：
c++允许一个类继承多个类。
语法：class 子类：继承方式 父类1，继承方式 父类2…
多继承可能会引发父类中有同名成员出现，需要加作用域区分。并不建议使用多继承。
菱形继承：
两个子类继承同一个父类，又有某个类同时继承两个子类，这种继承称为菱形继承或钻石继承。
下面展示例子：

class Person
{
public:
	int m_Age;
};
class Man :public Person
{

};
class Woman :public Person
{

};
class Son :public Man, public Woman
{

};
void test01()
{
	Son s1;
	s1.Man::m_Age = 10;
	s1.Woman::m_Age = 20;
	cout << s1.Man::m_Age << endl;//10
	cout << s1.Woman::m_Age << endl;//20
}

发现s1有两个m_Age，且数值不相同。菱形继承导致数据有重份，资源浪费。
如何解决菱形继承同名成员问题？
继承前加上关键字virtual，变成虚继承。

class Person//此时Person 称为虚基类
{
public:
	int m_Age;
};
class Man :public virtual Person
{

};
class Woman :public virtual Person
{

};
class Son :public Man, public Woman
{

};
void test01()
{
	Son s1;
	s1.Man::m_Age = 10;
	s1.Woman::m_Age = 20;
	cout << s1.Man::m_Age << endl;
	cout << s1.Woman::m_Age << endl;
	cout<<s1.m_Age<<endl;//三个输出结果均为20
}

虚继承Son从两个父类中继承两个虚基类指针，指向对应的虚基类表再通过虚基类表记录的偏移量，指向m_Age.同一个Son对象中m_Age只有一份。
上面所说的资源浪费是针对Person类中有大量数据而言的。