C++中的继承 -- 继承的概念和格式，继承基类成员访问方式的变换，继承中的隐藏，派生类的默认成员函数，继承与友元，继承与静态变量，多继承及菱形继承，虚继承，继承与组合

目录

1. 继承

1.1 继承的概念

1.2 继承的定义格式

1.3 继承基类成员访问方式的变化 

1.4 继承类模板

2. 基类和派生类间的转换 

3. 继承中的作用域 

3.1 隐藏规则

4. 派生类的默认成员函数

4.1 4个常见默认成员函数 

4.2 实现一个不能被继承的类 

5. 继承与友元 

6. 继承与静态成员 

7. 多继承及其菱形继承问题 

7.1 继承模型

7.2 虚继承

7.3多继承中指针偏移问题 

 7.4 IO库中的菱形虚拟继承

 8.继承和组合

---

1. 继承

1.1 继承的概念

        继承(inheritance)机制是⾯向对象程序设计使代码可以复⽤的最重要的⼿段，它允许我们在保持原有类特性的基础上进⾏扩展，增加⽅法(成员函数)和属性(成员变量)，这样产⽣新的类，称派⽣类(子类)。继承呈现了⾯向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复⽤，继承是类设计层次的复⽤。

       没有继承之前我们设计了两个类Student和Teacher，Student和Teacher都有姓名/地址/电话/年龄等成员变量，都有identity⾝份认证的成员函数，设计到两个类⾥⾯就是冗余的。

class Student
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
	void identity(){
		// ...
	}
	// 学习
	void study(){
		// ...
	}
protected:
	string _name = "peter"; // 姓名
	string _address;
	string _tel;
	int _age = 18;
	int _stuid;	//学号
};
class Teacher
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
	void identity(){
		// ...
	}
	// 授课
	void teaching(){
		//...
	}
protected:
	string _name = "张三";
	int _age = 18;
	string _address;
	string _tel;
	string _title;	//职称
};

        下面将公共的成员都放到Person类中，Student和teacher都继承Person，就可以复⽤这些成员，就不需要重复定义了。并且Student和Teacher各自独特的属性和行为可以在自己的类里面添加。

class Person
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
	void identity(){
		cout << "void identity()" << _name << endl;
		cout << _age << endl;
	}
protected:
	string _name = "张三"; // 姓名
	string _address;
	string _tel;
private:
	int _age = 18;
};

class Student : public Person
{
public:
	// 学习
	void study(){
		// ...
	}
protected:
	int _stuid;
	// 学号
};

class Teacher : public Person
{
public:
	// 授课
	void teaching(){
		//...
	}
protected:
	string title;
	// 职称
};

int main()
{
	Student s;
	Teacher t;

	s.identity();
	t.identity();
	return 0;
}

1.2 继承的定义格式

        如下图，Person是基类，也称作⽗类。Student是派⽣类，也称作⼦类。

1.3 继承基类成员访问方式的变化 

上图可以总结成一下几点：
        (1)基类的private成员在派⽣类中⽆论以什么⽅式继承都是不可⻅的。但是基类的私有成员被隐式继承到派生类对象中了，只是语法上限制派生类对象不管在类里面还是类外面都不能进行访问。

        (2)基类private成员在派⽣类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派⽣类中能访问，就定义为protected。

                这里如果想用子类对象访问父类的私有变量，可以通过调用父类的公有函数(里面访问了父类的私有变量)来对父类的私有变量进行访问:

class Person
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
	void identity()
	{
		cout << "void identity()" << _name << endl;
	}
	void age()
	{
		cout << _age << endl;
	}
protected:
	string _name = "张三"; // 姓名
	string _address;
	string _tel = "10010";
private:
	int _age = 18;
};

class Student : public Person
{
public:
	void study()
	{
		// ...
		//cout << _age << endl;	//父类private限制的成员变量和成员函数子类不能直接使用
		//但是子类对象可以通过调用父类的公有函数(里面访问了父类的私有变量)来对父类的私有变量进行访问
		age();
		cout << _tel << endl;	//protected限制的成员变量和成员函数子类可以使用
	}
protected:
	int _stuid;
	// 学号
};

int main()
{
	Student s;
	s.study();
	return 0;
}

        (3)基类的私有成员在派⽣类都是不可⻅。基类的其他成员在派⽣类的访问⽅式 == Min(成员在基类的访问限定符，继承⽅式)，public > protected >private。

        (4)在继承时，继承方式可以不用显式写出，使⽤关键字class时默认的继承⽅式是private，使⽤struct时默认的继承⽅式是public，不过最好显⽰的写出继承⽅式。

        (5)在实际运⽤中⼀般使⽤都是public继承，⼏乎很少使⽤protetced/private继承，也不提倡使⽤protetced/private继承，因为protetced/private继承下来的成员都只能在派⽣类的类⾥⾯使⽤，实际中扩展维护性不强。

1.4 继承类模板

        这里就是在定义类的时候加上继承就行了。需要注意的是，在子类中调用父类的接口时，需要指定类域。解释看下面代码中的push()函数。

#include <iostream>
#include <vector>
#include <list>
#include <deque>
using namespace std;

//#define CONTAINER std::vector
//#define CONTAINER std::list
#define CONTAINER std::deque

namespace XiaoC
{
	template<class T>
	class stack : public CONTAINER<T>
	{
	public:
		void push(const T& x)
		{
			//如果不加类限定符，在调用push的时候就会去父类里面找
			//但是类里面的函数都是按需实例化，在调用子类的push之前父类里面没有实例化的push_back()
			//所以找不到
			//push_back(x);

			CONTAINER<T>::push_back(x);
		}

		void pop()
		{
			CONTAINER<T>::pop_back();
		}

		const T& top()
		{
			return CONTAINER<T>::back();
		}

		bool empty()
		{
			return CONTAINER<T>::empty();
		}
	};
}

int main()
{
	XiaoC::stack<int> s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);

	while (!s1.empty())
	{
		cout << s1.top() << " ";
		s1.pop();
	}
	cout << endl;

	return 0;
}

2. 基类和派生类间的转换 

        (1) 通过public继承的子类对象可以赋值给父类对象/指针/引用。这⾥有个形象的说法叫切⽚或者切割。寓意把派⽣类中基类那部分切出来，基类对象/指针/引⽤指向的是派⽣类中切出来的基类那部分。

        (2) 基类对象不能赋值给派⽣类对象。

        (3) 基类的指针或者引⽤可以通过强制类型转换赋值给派⽣类的指针或者引⽤。但是基类的指针必须是指向派⽣类对象时才是安全的。这⾥基类如果是多态类型，可以使⽤RTTI(Run-Time TypeInformation)的dynamic_cast 来进⾏识别后进⾏安全转换。

int main()
{
	Student sobj;

	// 1.通过public继承的子类对象可以赋值给父类对象/指针/引用 -- 这里没有类型转换(中间没有临时变量产生)
	Person pobj = sobj;
	Person* pp = &sobj;
	Person& rp = sobj;	
	rp._name = "张三";	//rp是子类当中父类的那一部分

	//类型转换 -- 中间会产生临时对象，必须使用const修饰的引用才能接收
	//int i = 1;
	//double d = i;
	//const double& rd = i;

	//2.父类对象不能赋值给子类对象，这里会编译报错
	//sobj = (Student)pobj;

	// 父类指向子类对象的指针可以通过强制转换赋值给子类指针 -- 父类必须是多态类型
	Student* ps1 = dynamic_cast<Student*>(pp);
	cout << ps1 << endl;

	//父类指向父类对象的指针强制转换赋值给子类指针，地址打印出来是空指针
	pp = &pobj;
	Student* ps2 = dynamic_cast<Student*>(pp);
	cout << ps2 << endl;

	return 0;
}

3. 继承中的作用域 

3.1 隐藏规则

        (1) 继承体系中基类和派生类都有独立的作用域。

        (2) 派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。(在派⽣类成员函数中，可以使⽤ 基类::基类成员 显⽰访问基类成员)

#include <iostream>
using namespace std;

class Person
{
protected:
	string _name = "小李子"; // 姓名
	int _num = 111; // 身份证号
};

class Student : public Person
{
public:
	void Print()
	{
		cout << _num << endl;
		cout << Person::_num << endl;	//基类::基类成员
	}
protected:
	int _num = 999; // 学号
};

int main()
{
	Student s;
	s.Print();
	return 0;
}

        (3) 如果是成员函数的隐藏，只需要函数名相同就构成隐藏(返回类型和函数形参列表可以不同)。

        这里用下面代码来进行理解：

class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		cout << "func(int i)" << i << endl;
	}
};
int main()
{
	B b;
	b.fun(10);
	b.fun();
	//调用父类函数的正确写法如下
	//b.A::fun();
	return 0;
};

         这里因为fun()函数在分别在子类和父类的作用域里面，函数名又相同，所以两个fun()函数构成隐藏关系(重载关系必须是在同一作用域里面)。

        b.fun()这个调用在这里会报错，因为这里是一个子类对象，会先在B类里面找fun()函数，找到了即使是参数列表不匹配也不会再去父类里面找了。

        (4)在实际中继承体系⾥⾯最好不要定义同名的成员。

4. 派生类的默认成员函数

        了解默认成员函数可以跳转到类和对象(2)类和对象(3).

4.1 4个常见默认成员函数 

        1. 派⽣类的构造函数必须调⽤基类的构造函数初始化基类的那⼀部分成员。如果基类没有默认的构造函数，则必须在派⽣类构造函数的初始化列表阶段显⽰调⽤。

        2. 派⽣类的拷⻉构造函数必须调⽤基类的拷⻉构造完成基类的拷⻉初始化。

        3. 派⽣类的operator=必须要调⽤基类的operator=完成基类的复制。需要注意的是派⽣类的
operator=隐藏了基类的operator=，所以显⽰调⽤基类的operator=，需要指定基类作⽤域。

        4. 派⽣类的析构函数会在被调⽤完成后⾃动调⽤基类的析构函数清理基类成员。因为这样才能保证派⽣类对象先清理派⽣类成员再清理基类成员的顺序。

class Person
{
public:
	Person(const char* name = "xxx")
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;
		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};

class Student : public Person
{
public:
	Student(const char* name, int num, const char* addrss)
		:Person(name)	//如果父类没有默认构造函数，在子类的初始化列表中显式的调用该构造函数
		//:_name(name) 不允许直接初始化父类成员,必须调用父类的构造函数，初始化子类中父类的那一部分
		, _num(num)
		, _addrss(addrss)
	{}

	// 严格说Student拷贝构造默认生成的就够用了
	// 如果有需要深拷贝的资源，才需要自己实现
	Student(const Student& s)
		:Person(s)	//父类对象在子类中是最先被声明的,Person的拷贝构造需要传一个Person对象，这里是将子类对象传给父类的引用
		, _num(s._num)
		, _addrss(s._addrss)
	{
		// 深拷贝
	}

	// 严格说Student赋值重载默认生成的就够用了
	// 如果有需要深拷贝的资源，才需要自己实现
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			// 父类和子类的operator=构成隐藏关系,所以这里需要显式的调用父类的赋值重载，不然就会一直调用子类的重载造成栈溢出
			Person::operator=(s);

			_num = s._num;
			_addrss = s._addrss;
		}

		return *this;
	}

	// 严格说Student析构默认生成的就够用了
	// 如果有需要显示释放的资源，才需要自己实现
	// 析构函数都会被特殊处理成destructor() 
	~Student()
	{
        cout << "~Student()" << endl;
		// 子类的析构和父类析构函数也构成隐藏关系
		// ~Person();	//因为构成隐藏，这样是调不动的 
		// 规定：不需要显示调用，子类析构函数之后，会自动调用父类析构
		// 这样保证析构顺序，先子后父，显示调用取决于实现的人，不能保证
		// 先子后父
		//Person::~Person();
		//delete _ptr;
	}
protected:
	int _num = 1; //学号
	string _addrss = "西安市高新区";

	int* _ptr = new int[10];
};

int main()
{
	Student s1("张三", 1, "西安市");
	Student s2(s1);
	Student s3("李四", 2, "咸阳市");
	s1 = s3;

	return 0;
}

        5. 派⽣类对象初始化先调⽤基类构造再调派⽣类构造。

        6. 派⽣类对象析构清理先调⽤派⽣类析构再调基类的析构。

        7. 因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同。那么编译器会对析构函数名进⾏特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派⽣类析构函数和基类析构函数构成隐藏关系。

4.2 实现一个不能被继承的类 

        ⽅法1：基类的构造函数私有，派⽣类的构成必须调⽤基类的构造函数，但是基类的构成函数私有化以后，派⽣类看不⻅就不能调⽤了，那么派⽣类就⽆法实例化出对象。

class Base
{
public:
	void func5() { cout << "Base::func5" << endl; }
protected:
	int a = 1;
private:
	 //C++98的⽅法
	Base()
	{}
};

class Derive : public Base
{
	void func4() { cout << "Derive::func4" << endl; }
protected:
	int b = 2;
};

        ⽅法2：C++11新增了⼀个final关键字，final修改基类，派⽣类就不能继承了。

class Base final
{
public:
	void func5() { cout << "Base::func5" << endl; }
protected:
	int a = 1;
};

class Derive : public Base
{
	void func4() { cout << "Derive::func4" << endl; }
protected:
	int b = 2;
};

5. 继承与友元 

        友元关系不能继承，也就是说基类友元不能访问派⽣类私有和保护成员 。解决方式就是在派生类中也声明友元。

//前置声明
class Student;

class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};

class Student : public Person
{
	//友元关系不能被继承,解决方式就是在派生类中也添加友元
	//friend void Display(const Person& p, const Student& s);
protected:
	int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;
}
int main()
{
	Person p;
	Student s;
	// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员
	// 解决⽅案：Display也变成Student 的友元即可
	Display(p, s);
	return 0;
}

6. 继承与静态成员 

        基类定义了static静态成员，则整个继承体系⾥⾯只有⼀个这样的成员。⽆论派⽣出多少个派⽣类，都只有⼀个static成员实例。其实就和一个类的静态成员一样，只不过父类的静态成员也被子类的作用域限制。

class Person
{
public:
	string _name;
	static int _count;
};
int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum;
};

int main()
{
	Person p;
	Student s;

	// 这里的运行结果可以看到非静态成员_name的地址是不一样的
// 说明子类继承下来了，父子类对象各有一份
	cout << &p._name << endl;
	cout << &s._name << endl;

	// 这里的运行结果可以看到静态成员_count的地址是一样的
	// 说明子类和父类共用同一份静态成员
	cout << &p._count << endl;
	cout << &s._count << endl;

	// 公有的情况下，父子类指定类域都可以访问静态成员
	cout << Person::_count << endl;
	cout << Student::_count << endl;

	Person::_count++;

	cout << p._count << endl;
	cout << s._count << endl;

	return 0;
}

7. 多继承及其菱形继承问题 

7.1 继承模型

        单继承：⼀个派⽣类只有⼀个直接基类时称这个继承关系为单继承。

         多继承：⼀个派⽣类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前⾯，后⾯继承的基类在后⾯，派⽣类成员在放到最后⾯。

         菱形继承：菱形继承是多继承的⼀种特殊情况。菱形继承的问题，从下⾯的对象成员模型构造，可以看出菱形继承有数据冗余和⼆义性的问题，在Assistant的对象中Person成员会有两份。

class Person
{
public:
	string _name; // 姓名
};

class Student : public Person
{
protected:
	int _num; //学号
};

class Teacher : public Person
{
protected:
	int _id; // 职⼯编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};
int main()
{
	// 编译报错：error C2385: 对“_name”的访问不明确
	Assistant a;
	//a._name = "peter";	//这里会有个二义性
	// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	return 0;
}

7.2 虚继承

        C++语法复杂，其实多继承就是⼀个体现。有了多继承，就存在菱形继承，有了菱形继承就有
菱形虚拟继承，底层实现就很复杂，性能也会有⼀些损失，所以最好不要设计出菱形继承。多继承可以认为是C++的缺陷之⼀，后来的⼀些编程语⾔都没有多继承，如Java。

         在这里为了解决菱形继承产生的数据冗余和二义性问题，引入了虚继承这个概念，如果Person类产生数据冗余和二义性，在下面Student和Teacher类当中继承时加上virtual关键字，这样在Assistant对象中的成员就只有一份了。

class Person
{
public:
	string _name; // 姓名
};

// 使⽤虚继承Person类
class Student : virtual public Person
{
protected:
	int _num; //学号
};

// 使⽤虚继承Person类
class Teacher : virtual public Person
{
protected:
	int _id; // 职⼯编号
};

// 教授助理
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

int main()
{
	// 使⽤虚继承，可以解决数据冗余和⼆义性
	Assistant a;
	a._name = "peter";
	return 0;
}

7.3多继承中指针偏移问题 

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main()
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;

	cout << p1 << endl;
	cout << p2 << endl;
	cout << p3 << endl;
	return 0;
}

        p3指针是Derive对象的指针，指向该对象的开头。由于子类对象里面的成员变量存储的顺序是先存储先继承的父类成员，再存储后继承的父类成员，最后存储自己的成员变量。所以这里p1的地址和p3相同，因为Base1这个类里面只有一个int对象，所以p2指针相对偏移了4个字节。

 7.4 IO库中的菱形虚拟继承

        这里的说的就是C++中里面的istream类型和ostream类型，iostream类型就是继承了这两个类，而这两个类又继承了上面的ios这个类，构成了菱形继承。 

        库里面也是通过虚继承进行处理的。

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits>
{};

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits>
{};

 8.继承和组合

         (1)public继承是⼀种is-a的关系。也就是说每个派⽣类对象都是⼀个基类对象(比如说：基类是"车"，派生类是"BenZ",这里就可以说BenZ是一种车)。

         (2)组合是⼀种has-a的关系。假设B组合了A，每个B对象中都有⼀个A对象(比如说："轮胎"是一个类，"车"是一个类，"车"这个类下面的成员变量有"轮胎"，这就叫做组合)。

// stack和vector的关系，既符合is-a，也符合has-a

//这种实现就是通过继承实现的
template<class T>
class stack : public vector<T>
{};

//这种实现就是通过组合实现的
template<class T>
class stack
{
private:
    vector<T> _v;
};

        (3) 继承允许你根据基类的实现来定义派⽣类的实现。这种通过⽣成派⽣类的复⽤通常被称为⽩箱复⽤(white-box reuse)。术语“⽩箱”是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可⻅ 。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依赖关系很强，耦合度⾼。

        (4)对象组合是类继承之外的另⼀种复⽤选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接⼝。这种复⽤⻛格被称为⿊箱复⽤(black-box reuse)，因为对象的内部细节是不可⻅的。对象只以“⿊箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使⽤对象组合有助于你保持每个类被封装。

        (5)优先使⽤组合，⽽不是继承。实际尽量多去⽤组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就⽤继承，另外要实现多态，也必须要继承。类之间的关系既适合⽤继承(is-a)也适合组合(has-a)，就⽤组合。