C++| |继承

继承

---

1.概念

继承（inheritance）是面向对象程序设计使代码复用的手段。它允许程序员在保持原有类特性的基础上进行扩展，从而产生新的类，称为派生类也叫作子类。继承是设计层次的复用

 

2. 定义

2.1 定义格式

插图：定义图

注意：继承符号是：冒号

 

2.2 继承方式和访问限定符

插图：继承方式

插图：访问限定符

 

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

类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	p派生类的rotected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

总结：

1. 基类的private成员在派生类中无论以什么方式继承都是不可见的。不可见：基类的私有成员依旧被继承到了派生类中，但是语法上限制了派生类对象不管在类外还是类内都不能去访问它

2. 如果基类的成员不想在类外被访问，但需要在派生类中能访问，就定义为protected。保护限定符是因继承才出现的

3. 对于上面表格进行总结。基类的私有成员在子类都是不可见的。基类的其他成员在子类的访问方式=Min（成员在基类的访问限定符，继承方式），public > protected > private

4. 关键字class默认的继承方式是private，struct默认的继承方式是public

5. 在实际应用中一般使用的都时public继承，几乎很少使用protected和private继承。因为protected和private继承下来的成员只能在派生类中使用，实际中扩展维护性不高

 

3. 基类和派生类对象赋值转换

• 派生类的对象可以赋值给基类的对象，基类的指针，基类的引用。形象的说法是切片

• 基类对象不可以赋值给派生类对象

• 基类的指针可以通过强制转换赋值给派生类的指针。但是必须是基类的指针指向派生类的对象时才是安全的。

例：

#include <iostream>
#include <string>

class Person
{
public:
	void Show()
	{
		std::cout << "In Basci!" << std::endl;
	}

	//private:
	std::string _name;
	int _age;
};

class Student : public Person
{
public:
	void Display()
	{
		std::cout << "In Derived!" << std::endl;
	}

	//private:
	int _num;
};

int main()
{
	//派生类的对象可以赋值给基类的对象，引用，指针
	Student stu;
	Person p = stu;
	Person& p1 = stu;
	Person* p2 = &stu;

	//基类的对象不可以赋值给派生类
	//stu = p;

	//基类的指针（指向派生类对象）可以赋值给派生类,必须要进行强制类型转换
	Student* pStu = (Student*)p2;
	pStu->_num = 10;
	std::cout << "ok" << std::endl;

	//基类的指针（指向基类的对象）可以赋值给派生类，但是会发生越界问题
	Person pp;
	pStu = (Student*)&pp;
	pStu->_num = 10;
	std::cout << "odk?" << std::endl;
	return 0;
}

 

 

 

4. 继承中的作用域

1. 在继承体系中基类和派生类都有着自己的独立作用域

2. 子类和父类有同名的成员的话，子类成员将屏蔽父类对于同名成员的直接访问，这种情况叫做隐藏，也叫作重定向。（在子类成员函数中，可以使用基类::基类成员 显式访问）

3. 实际中在继承体系中最好不要定义同名的成员

例：

#include <iostream>
#include <string>

class Person
{
protected:
	int _num = 111;
	std::string _name = "yk";
};

class Student : public Person
{
public:
	void Show()
	{
		std::cout << "_num: " << _num << std::endl;
		std::cout << "_name: " << _name << std::endl;
	}

private:
	int _num = 999;
	std::string _name = "oodk";
};

int main()
{
	Student stu;
	stu.Show();//输出999 oodk表示基类的成员变量被隐藏了
	return 0;
}

理解重载和隐藏：

例：

#include <iostream>
#include <string>

class A
{
public:
	void Show()
	{
		std::cout << "In A!" << std::endl;
	}
};

class B : public A
{
public:
	void Show(int i)
	{
		std::cout << "In B!" << std::endl;
	}
};

int main()
{
	//A和B中的Show函数构成了隐藏，因为不在同一个作用域中所以不是重载
	B b;
	b.Show(3);
	b.A::Show();//调用父类中的Show函数必须要显式调用，因为被隐藏了
	return 0;
}

 

 

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

6个默认的成员函数

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函（无参的构造函数），则必须在派生类的构造函数中初始化链表阶段显式调用（可以在初始化阶段的任何一个地方）

2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化

3. 派生类的operator=必须要调用基类的operator=完成基类的复制

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

插图：六大默认成员函数

插图：默认成员函数调用顺序

 

例：

#include <iostream>
#include <string>


class Person
{
public:
	Person(std::string name)
		: _name(name)
	{
		std::cout << "In Person Construction!" << std::endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		std::cout << "In Person Construction=!" << std::endl;
	}

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

		return *this;
	}

	~Person()
	{
		std::cout << "In Person Destruction!" << std::endl;
	}

private:
	std::string _name;
};


class Student : public Person
{
public:
	Student(std::string name)
		: Person(name)
		, _name(name)
	{
		std::cout << "In Student Construction!" << std::endl;
	}

	Student(const Student& p)
		: Person(p)
		, _name(p._name)
	{
		std::cout << "In Student Construction=!" << std::endl;
	}

	Student& operator=(const Student& p)
	{
		if (this != &p)
		{
			//必须先对基类的成员进行拷贝构造
			Person::operator=(p);
			_name = p._name;
			std::cout << "In Student operator=!" << std::endl;
		}

		return *this;
	}

	~Student()
	{
		std::cout << "In Student Destruction!" << std::endl;
	}

private:
	std::string _name;
};

int main()
{
	Student s1("jack");
	Student s2(s1);
	Student s3("rose");
	s1 = s3;
	return 0;
}

【面试题】：实现一个不能被继承的类

• C++98：构造函数私有化，派生类调用不到基类的构造函数，则无法继承

• C++11：使用关键字final（最终）

 

6. 继承与友元

友元关系不能继承,也就是说基类友元不能访问子类私有和保护成员

例：

class A
{
public:
	friend void Display(const A& a);
public:
	void Show()
	{
		std::cout << "In A!" << std::endl;
	}

private:
	int _num = 34;
};


class B : public A
{
public:
	void Show()
	{
		std::cout << "In B!" << std::endl;
	}

private:
	std::string _name = "yk";
};

void Display(const A& a)
{
	std::cout << "Freind function In A!" << "_num" << a._num << std::endl;
	//std::cout << "Freind function In A!" << "_num" << b._name << std::endl; 
}

int main()
{
	A a;
	Display(a);//输出Friend function In A!_num34 
	return 0;
}

 

 

7. 继承与静态成员

基类定义了static静态成员，则整个继承体系中只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例

例：

class A
{
public:
	friend void Display(const A& a);
public:
	void Show()
	{
		std::cout << "_count" << _count << std::endl;
	}

	A()
	{
		_count++;
	}

private:
	int _num = 34;

public:
	static int _count;
};

int A::_count = 0;


class B : public A
{
public:
	void Show()
	{
		std::cout << "In B!" << std::endl;
	}

private:
	std::string _name = "yk";
};

class C : public A
{

private:
	int _c = 0;
};

void Display(const A& a)
{
	std::cout << "Freind function In A!" << "_count" << a._count << std::endl;
	//std::cout << "Freind function In A!" << "_num" << b._name << std::endl; 
}

int main()
{
	B b1;
	B b2;
	B b3;
	Display(b3);//_count 3

	C c;
	c.Show();//_count 4
	return 0;
}

 

 

8. 复杂菱形继承和菱形虚拟继承

基于代码：

class Person
{

private:
	std::string _name;
};

class Student : public Person
{

private:
	int _num;
};

class Teacher : public Person
{

private:
	int _id;
};

class Assistant : public Student, Teacher
{

private:
	std::string _majorCourse;
};

单继承：一个子类只有一个直接父类

插图：

多继承：一个子类有两个或者以上直接父类

插图：

菱形继承：菱形继承是多继承的一种特殊情况

插图：

菱形继承的问题：菱形继承有数据冗余和二义性问题

例：

class Person
{

public:
	std::string _name;
};

class Student : public Person
{

protected:
	int _num;
};

class Teacher : public Person
{

protected:
	int _id;
};

class Assistant : public Student, public Teacher
{

protected:
	std::string _majorCourse;
};

int main()
{
	Assistant as;
	//as._name = "YK";//出现错误，因为数据二义性，必须显式调用
	as.Student::_name = "YK";
	as.Teacher::_name = "LW";
	return 0;
}

【解决方法】

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。在上面的继承关系中，在Student和Teacher继承Person使用虚拟继承，即可解决问题.

虚拟继承就是让最终继承下来的子类之后只有一个_name数据，也就对不管对于改变Student还是Teacher都是将其全部都改变了。不会在出现改变Student中的 _name，Teacher中的 _name没有发生改变

例：

class Person
{

public:
	std::string _name;
};

class Student : virtual public Person
{

protected:
	int _num;
};

class Teacher : virtual public Person
{

protected:
	int _id;
};

class Assistant : public Student, public Teacher
{

protected:
	std::string _majorCourse;
};

int main()
{
	Assistant as;
	as._name = "YK";//可以使用了，由于只有一个_name数据了，不会在产生二义性的问题
	as.Student::_name = "YK";
	as.Teacher::_name = "LW";
	return 0;
}

虚拟菱形继承的原理：

使用以下例子来再借助内存窗口观察对象成员的模型

• 菱形继承的内部结构

class A
{

public:
	int _a;
};

class B : public A
{

public:
	int _b;
};

class C : public A
{

public:
	int _c;
};

class D : public B, public C
{

public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 2;
	d.C::_a = 1;
	d._b = 2;
	d._c = 3;
	d._d = 4;
	return 0;;
}

这是没有虚拟继承，只是菱形继承，就会产生数据二义性问题。对于菱形继承对于类D创建的对象里面只有两个类，类B和类C，但是类B和类C内部又有一个类类A，这样就会产生对于类D创建一个对象这个两个类A，这样就会产生数据冗余和二义性问题。

插图：内存模型

 

可以看到对于一个对象d，内部有着两个类B和C，但是对于B和C内部有分别有着一个类A，这样就有两个类A存于对象d中，就会导致数据冗余和二义性。

画图理解：

插图：

 

可以看到一个对象中有着两个_a数据

 

• 虚拟菱形继承内部结构

class A
{

public:
	int _a;
};

class B : virtual public A
{

public:
	int _b;
};

class C : virtual public A
{

public:
	int _c;
};

class D : public B, public C
{

public:
	int _d;
};

int main()
{
	D d;
	d._a = 0;//可以赋值，没有二义性问题
	d.B::_a = 2;
	d.C::_a = 1;
	d._b = 2;
	d._c = 3;
	d._d = 4;
	return 0;;
}

对于虚拟菱形继承，对于一个对象d来说，内部也是有着类B和类C，类B和类C内部都有着一个指向类A的指针，虚拟菱形继承相对于菱形继承，就是对于类A不再是类B和类C私有的了，类A对于类B和类C是共有的

如图：内存结构

 

内部不仅有着类B类C还有这着一个类B和类C共有的类A，类B和类C内部都有一个指向类A的指针

如何实现不存在数据二义性问题：

• 但是对于属于类B和类C的类A可以看到它内部没有地址空间，所以其实他只是一个指针，也就是一个地址

• 而只有共有的类A才有这地址空间可以存放数据_a,所以对于类B和类C内部的类A的指针，指向的就是这个独立的类A。从而实现了数据一致性了

d对象将类A放到了组成的最下面，这个类A同时属于类B和类C，那么B和C如何去找到共有的A呢？

• 这里是通过B和C的两个指针，指向的一张表。这两个指针叫做虚基表指针，这两个表叫做虚基表。虚基表中存在着偏移量，通过偏移量可以找到下面的类A

• 如图：

可以看到对于类B和类C都有着一个虚基表指针，指向一个虚基表，该虚基表下面就是偏移量，从该位置偏移多少就可以找到共有的类A

对于对象d中的类B和类C为什么要去找属于自己的类A呢？

• 因为对于类B和类C均是类D的父类。如果是父类的话就有可能产生切片，所以就要找到属于自己的数据，这样的话才不会发生切片错误

对于Person关系菱形虚拟继承的原理解释：

如图：

 

 

10. 总结

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有了菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题

2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如java

3. 继承和组合

   • public继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象

   • 组合是一种has-a的关系。假设B组合了A，每个B对象都有着一个A对象

   • 优先使用对象组合，而不是类继承（高内聚，低耦合）

   • 继承允许你根据基类类的实现来定义派生类的实现，这种通过生成派生类的复用称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对于派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

   • 对象组合是类继承之外的另一种复用选择。对象组合要求被组合的对象具有良好定义的接口。这种复用风格称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于保持每一个类被封装，内聚性高。

   • 实际中尽量使用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地，有些关系就适合用继承，另外实现多态，也必须要继承。类之间的关系可以使用继承，可以使用组合就用组合。