C++继承

前言 

接下来，我们进入C++继承的学习吧。

1.继承的概念和定义

 1.1继承的概念

我们在日常的生活和工作中，会发现大量重复的工作，代码也一样，每次设计一个类都要写很多重复的代码，在每个类中，我们这样想，可不可以定义一个公共使用的代码块，然后把重复的东西都放在这里面，我们需要的时候就去调用这样的设计是不是看着更加简洁和合理呢，所以这里就引入了继承的概念。 继承的本质就是类的复用，跟函数的复用差不多，函数复用是定义一个函数来实现调用，继承就是定义一个基类（父类）供其他子类来实现复用。

继承 (inheritance) 机制是面向对象程序设计 使代码可以复用 的最重要的手段，它允许程序员在 保持原有类特

性的基础上进行扩展 ，增加功能，这样产生新的类，称派生类。继承 呈现了面向对象程序设计的层次结构 ，

体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用， 继承是类设计层次的复用 。

#include<iostream>
#include<stdlib.h>
using namespace std;
class person
{
public:
	void print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;

	}
protected:
	string  _name = "peter";//姓名
	int _age = 18;//年龄
};
class student :public person
{
protected:
	int sid = 10;//学号
};
class teacher :public person
{
protected:
	int jid = 50;//工号
};

int main()
{
	teacher t1;
	student s1;
	s1.print();
	t1.print();
}

1.2 继承的定义

 

 

 

使用关键字 class 时默认的继承方式是 private ，使用 struct 时默认的继承方式是 public ， 不过最好显示的 写出继承方式 。 在实际运用中一般使用都是 public 继承，几乎很少使用 protetced/private 继承 ，也不提倡使用

protetced/private 继承，因为 protetced/private 继承下来的成员都只能在派生类的类里面使用，实际中 扩展维护性不强。

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

 赋值兼容规则，

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用 。这里有个形象的说法叫切片或者切 割。寓意把派生类中父类那部分切来赋值过去。

基类对象不能赋值给派生类对象

 实际当中，公有继承，子类赋值给父类，叫做切片，父类不能给子类赋值

子类对象不仅可以赋值给父类，指针引用都可以嗷。

父类的指针和引用可以使用强制类型转换，最好使用dynamic_cat来判断一下。

3.继承中的的作用域

• 在继承体系中基类和派生类都有独立的作用域。
• 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定 义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
• 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
• 注意在实际中在继承体系里面最好不要定义同名的成员。

class Person
{
protected:
	string _name = "小李子"; // 姓名
	int _num = 111; // 身份证号
};
//子类隐藏父类的同名成员变量，自己有用自己的，自己没有用父亲的。就近原则
class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:" << _name << endl;

		cout << " 身份证号:" << Person::_num << endl;
		cout << " 学号:" << _num << endl;
	}
protected:
	int _num = 999; // 学号
};
//void Test()
//{
//	Student s1;
//	s1.Print();
//};
//在继承中函数名相同就是隐藏关系，显示调用父类，指定作用域就可以
//注意这里不是函数重载的关系嗷
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		A::fun();
		cout << "func(int i)->" << i << endl;
	}
};
void Test()
{
	B b;
	b.fun(10);
	b.A::fun();//限定作用域就可以调用父类
};
int main()
{
	Test();
	return 0;
}

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

 派生类的默认成员函数，分为基类的默认成员函数和自己自定义的默认成员函数，相比较与之前的内容，多了一部分父类的继承而来的东西，这下用于构造和析构等等成员函数就有了一定的逻辑顺序在里面，我们来看下面这一个例子。

class Person
{
public:
    //基类的初始化
	Person(const char* name = "peter")
		: _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)
		: Person(name)
		, _num(num)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		: Person(s)
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}

	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}
	//编译器先对子类的析构先析构，然后自动调用父类的析构函数，完成销毁回收工作。
	~Student()
	{
		//Person::~Person();//这里我们直接析构子类的自定义类型即可，类似与栈先析构后进来的
		cout << "~Student()" << endl;
	}
protected:
	int _num; //学号
};
void Test()
{
	Student s1("bob", 18);
	Student s2(s1);
	Student s3("zqz", 17);
	s1 = s3;
}
int main()
{
	Test();
	return 0;
}

---

运行结果如下 ：

执行顺序如下：

 注意事项：

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

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

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

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

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

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

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;
}
void main()
{
	Person p;
	Student s;
	Display(p, s);
}

6.继承与静态成员

 静态成员，在整个继承体系里面都是存在的，类似与之前的全局变量在整个生命周期存在一样，可以在每一个基类或者派生类里面谁便进行访问。

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

class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};
void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;
	Student s5;
	cout << " 人数 :" << Person::_count << endl;
	cout << " 人数 :" << Student::_count << endl;
	cout << " 人数 :" << s1._count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}
int main()
{
	TestPerson();
	return 0;
}

7.菱形继承和菱形虚拟继承

 单继承：一个子类只有一个直接父类时称这个继承关系为单继承 （一脉单传）

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

一个父亲有多个孩子

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

单继承： 

多继承：

菱形继承：

7.1 菱形继承的问题？

从上面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在 Assistant

的对象中 Person 成员会有两份。会有来自学生的person还有来自于老师的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; // 主修课程
};
void Test()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	Assistant a;
	/*a._name = "peter";
*/
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	/*a._name = "peter";*/
}
int main()
{
	Test();
	return 0;
}

7.2 菱形继承的虚继承

 为了解决上面菱形继承带来的数据冗余和二义性，这里介绍一下虚继承，

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在 Student 和 Teacher 的继承 Person 时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

class Person
{
public:
	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:
	string _majorCourse; // 主修课程
};
int main()
{
	Assistant a;
	a._name = "peter";
	return 0;
}

7.3 如何解决数据冗余和二义性（虚继承的原理 ）

这里可以分析出 D 对象中将 A 放到的了对象组成的最下面，这个 A 同时属于B 和 C ，那么 B 和 C 如何去找到公共的 A 呢？ 这里是通过了 B 和 C 的两个指针，指向的一张表。这两个指 针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的 A 。

 每次通过偏移量来找到A的地址，得到A的值。

class A
{
public:
	int _a;
};
// class B : public A
class B : virtual public A
{
public:
	int _b;
};
// class C : public A
class C : virtual public A
{
public:
	int _c;
};
class D : public B, public C
{
public:
	int _d;
};
int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	d._a = 0;
	return 0;
}

8.总结