C++ 继承

继承

• 好处：减少重复代码
• 语法：class 子类 ： 继承方式 父类
  子类也称为派生类，父类也称为基类。

派生类中的成员，包含两大部分：

• 一类是从基类继承过来的，
• 一类是自己增加的成员。从基类继承过来的表现其共性，而新增的成员体现了其个性。

---

继承方式

• 继承方式一共有三种：
  1、公共继承
  2、保护继承
  3、私有继承
• 父类

class A
{
public:
	int a;
protected:
	int b;
private:
	int c;
};

• 公共继承

class B : public A
{
public:
	int a;
protected:
	int b;
不可访问:
	int c;
};

• 保护继承

class B : protected A
{
protected:
    int a;
	int b;
不可访问:
	int c;
};

• 私有继承

class B : private A
{
private:
	int a;
	int b;
不可访问:
	int c;
};

---

继承中的对象模型

#include <iostream>
using namespace std;
class Base {
public:
	int a;
protected:
	int b;
private:
	int c;
};
class son1 : public Base {
public:
	int s_a;
};
void test() {
	cout << "son1的大小为： " << sizeof(son1) << endl;
	//16
}
int main(void)
{
	test();
	return 0;
}

结论：父类中的私有成员也是被子类继承下去了，只是由于编译器给隐藏后访问不到。

---

继承中构造和析构的顺序

#include <iostream>
using namespace std;
class Base {
public:
	Base() {
		cout << "Base(父类)构造函数的调用" << endl;

	}
	~Base() {
		cout << "Base(父类)析构函数的调用" << endl;
	}
};
class son1 : public Base {
public:
	son1() {
		cout << "Son1(子类)构造函数的调用" << endl;
	}
	~son1() {
		cout << "Son1(子类)析构函数的调用" << endl;
	}
};
void test() {
	son1 p;
}
int main(void)
{
	test();
	return 0;
}

• 输出结果：
  Base(父类)构造函数的调用
  Son1(子类)构造函数的调用
  Son1(子类)析构函数的调用
  Base(父类)析构函数的调用

总结：继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反。

---

继承同名(静态)成员处理方式

1、访问子类同名成员，直接访问即可。
2、访问父类同名成员，需要加作用域。
3、当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数。
4、同名静态成员处理方式和非静态处理方式一样，只不过有两种访问方式（通过对象和通过类名）。
注意：静态成员处理方式中通过类名访问方式的写法。

#include <iostream>
using namespace std;
class Base {
public:
	int m_a = 100;
	void func() {
		cout << "父类中func()函数的调用" << endl;
	}
	void func(int a) {
		cout << "父类中func(int a)函数的调用,a = " << a << endl;
	}
	static int m_b;
	static void fab() {
		cout << "父类中静态成员函数fab()函数的调用" << endl;
	}
	static void fab(int a) {
		cout << "父类中静态成员函数fab(int a)函数的调用,a = "  << a << endl;
	}
};
int Base::m_b = 300;
class son1 : public Base {
public:
	int m_a = 200;
	void func() {
		cout << "子类中func()函数的调用" << endl;
	}
	static int m_b;
	static void fab() {
		cout << "子类中静态成员函数fab()函数的调用" << endl;
	}
};
int son1::m_b = 400;
void test1() {
	son1 p;
	cout << "p.m_a = " << p.m_a << endl;//调用子类的成员变量
	cout << "p.Base::m_a = " << p.Base::m_a << endl;//调用父类的成员变量
	p.func();//调用子类的成员函数
	p.Base::func();//调用父类的成员函数
	p.Base::func(10);//父类中成员函数重载的调用
}

void test2(){//继承同名静态成员处理方式
	//通过对象进行访问
	son1 q;
	cout << "q.m_b = " << q.m_b << endl;
	cout << "q.Base::m_b = " << q.Base::m_b << endl;
	q.fab();
	q.Base::fab();
	//通过类名进行访问
	cout << "q.m_b = " << son1::m_b << endl;
	cout << "q.Base::m_b = " << son1::Base::m_b << endl;
	Base::fab();
	son1::Base::fab();
	son1::Base::fab(500);
}

int main(void)
{
//	test1();
	test2();
	return 0;
}

---

多继承语法

• 语法：class 子类 : 继承方式 父类1 , 继承方式 父类2…
• 注意：多继承可能会引发父类中有同名成员出现，需要加作用域区分。
  C++实际开发中不建议使用多继承。

---

菱形继承

• 概念：两个派生类继承同一个基类，又有某个类同时继承两个派生类，这种继承被称为菱形继承，或者砖石继承。

#include <iostream>
using namespace std;
class father {
public:
	int m_age;
};
//继承前加virtual关键字后，变为虚继承
//此时公共的父类father称为虚基类
class son1 : virtual public father{};
class son2 : virtual public father {};
class grandson : public son1, public son2{};
void test()
{
	grandson age;
	age.son1::m_age = 18;
	age.son2::m_age = 20;
	cout << "age.son1::m_age = " << age.son1::m_age << endl;
	cout << "age.son2::m_age = " << age.son2::m_age << endl;
	cout << "age.m_age = " << age.m_age << endl;
	//打印的都为20，是最后修改的值。
}
int main(void)
{
	test();
	return 0;
}

总结：
1、菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义。
2、利用虚继承（关键字：virtual）可以解决菱形继承问题。