C++学习日积月累——继承详解

Posted 2023-03-31 joes_ju

一、继承的概念及定义

1.1 继承的概念

  继承（inheritance）机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称该类为派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认识过程。

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 _stuid;//学号
;

class Teacher :public Person

protected:
	int _jobid;//工号
;

int main()

	Student s;
	Teacher t;
	s.Print();
	t.Print();

	return 0;

  上述代码中，继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。Student和Teacher复用了Person的成员。下图的VS监视窗口可以看出，派生类Student和Teacher复用了Person类的成员。

图1 Visual Studio的监视窗口

1.2 继承定义

1.2.1 定义格式

  在图2中，Person是父类（或基类）；Student是子类（或派生类）。

图2 继承的定义格式

1.2.2 继承关系和访问限定符

  继承关系及访问限定符的关系详见图3所示。

图3 继承关系和访问限定符

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

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

  派生类Student访问基类Person的private成员，基类私有在子类是不可见（即不能用）。

class Person

public:
	void Print()
	
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	
private:
	string _name = "peter";//姓名
	int _age = 18;
;
class Student :public Person

public:
	void func()
	
		cout << _name << endl;
		cout << "void func()" << endl;
	
protected:
	int _stuid;//学号
;

小结：

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它；
2. 基类private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的；
3. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式；
4. 在实际运用中，一般使用的都是public继承，几乎很少使用protected/private继承，也不提倡使用protected/private继承，因为protected/private继承下来的成员都只能在派生类的类里使用，实际工程中扩展维护性不强。

二、基类和派生类对象赋值转换

• 派生类对象 可以赋值给 基类的对象/基类的指针/基类的引用。这里有个形象的说法叫切片或切割。寓意把派生类中父类那部分切来赋值过去。
• 基类对象不能赋值给派生类对象。
• 基类的指针或引用可以通过强制类型转换赋值给派生类的指针或者引用。但是，必须是基类的指针的是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI（Run Time Type Information）的dynamic_cast来进行识别后进行安全转换。

图4 基类/派生类对象赋值转化

class Person

protected:
	string _name;
	string _sex;
	int _age;
;

class Student :public Person

public:
	int _No;
;

void test_inheritance06()

	Student s;
	Person p = s;
	Person& rp = s;
	Person* ptrp = &s;

总结：

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

• 基类的指针可以通过强制类型转换赋值给派生类的指针。

三、继承中的作用域

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

class Person

protected:
	string _name = "Joe Biden";
	int _num = 250;
;

class Student :public Person

public:
	void print()
	
		cout << "姓名：" << _name << endl;
		cout << "身份证：" << Person::_num << endl;
		cout << "学号：" << _num << endl;
	
protected:
	int _num = 110;
;

void test_inheritance()

	Student s1;
	s1.print();

执行结果：

图5 Person基类与Student派生类的作用域

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_inheritance()

	B bb;
	bb.fun(10);

  B中的成员函数fun和A中的fun不是构成重载，因为不在同一作用域；B中的fun和A中的fun构成函数隐藏，成员函数满足函数名相同就构成隐藏。

四、派生类的默认成员函数

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用；
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化；
3. 派生类的operator=必须要调用基类的operator=完成基类的复制；
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序；
5. 派生类对象初始化先调用基类构造再调派生类构造；
6. 派生类对象析构清理先调用派生类析构再调基类的析构；

图6 类的默认成员函数

图7 派生类的默认成员函数

class Person

public:
	//构造函数
	Person(const char* name = "Joes Biden")
		:_name(name)
	
		cout << "Person()" << endl;
	

	//拷贝构造函数
	Person(const Person& p)
		:_name(p._name)
	
		cout << "Person(const Person& p)" << endl;
	

	Person& operator=(const Person& p)
	
		if (this != &p)
		
			_name = p._name;
		

		cout << "Person& operator=(const Person& p)" << endl;
		return *this;
	

	~Person()
	
		cout << "~Person()" << endl;
	

protected:
	string _name;//姓名
;

class Student :public Person

public:
	Student(const char* name, int num)
		:_stuNum(num)
	
		cout << "Student()" << endl;
	

	Student(const Student& s)
		:Person(s)
		, _stuNum(s._stuNum)
	
		cout << "Student(const Student& s)" << endl;
	

	Student& operator=(const Student& s)
	
		if (this != &s)
		
			Person::operator=(s);
			_stuNum = s._stuNum;
		
		cout << "Student& operator=(const Student& s)" << endl;

		return *this;
	

	~Student()
	
		cout << "~Student()" << endl;
	
protected:
	int _stuNum;//学号
;

void test_inheritance()

	Student s1("张三疯", 88);
	Student s2(s1);
	Student s3("joes", 27);
	s1 = s3;

执行结果：

图8 派生类Student的默认函数

五、继承与友元

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

class Student;
class Person

public:
	friend void display(const Person& p, const Student& s);
protected:
	string _name = "joes";//姓名
;

class Student :public Person

protected:
	int _stuNum = 250;//学号
;

void display(const Person& p, const Student& s)

	cout << p._name << endl;
	cout << s._stuNum << endl;


void test_inheritance04()

	Person p;
	Student s;
	display(p, s);

执行结果：

图9 友元关系无法继承

六、继承与静态成员

基类定义了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 test_inheritance()

	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << "人数：" << Person::_count << endl;
	Student::_count = 0;
	cout << "人数：" << Person::_count << endl;

执行结果：

图10 基类的静态成员执行情况

C++学习20 虚基类详解

多继承时很容易产生命名冲突，即使我们很小心地将所有类中的成员变量和成员函数都命名为不同的名字，命名冲突依然有可能发生，比如非常经典的菱形继承层次。如下图所示：

类A派生出类B和类C，类D继承自类B和类C，这个时候类A中的成员变量和成员函数继承到类D中变成了两份，一份来自 A-->B-->D 这一路，另一份来自 A-->C-->D 这一条路。

在一个派生类中保留间接基类的多份同名成员，虽然可以在不同的成员变量中分别存放不同的数据，但大多数情况下这是多余的：因为保留多份成员变量不仅占用较多的存储空间，还容易产生命名冲突，而且很少有这样的需求。

为了解决这个问题，C++提供了虚基类，使得在派生类中只保留间接基类的一份成员。

声明虚基类只需要在继承方式前面加上 virtual 关键字，请看下面的例子：

#include <iostream>
using namespace std;
class A{
protected:
    int a;
public:
    A(int a):a(a){}
};
class B: virtual public A{  //声明虚基类
protected:
    int b;
public:
    B(int a, int b):A(a),b(b){}
};
class C: virtual public A{  //声明虚基类
protected:
    int c;
public:
    C(int a, int c):A(a),c(c){}
};
class D: virtual public B, virtual public C{  //声明虚基类
private:
    int d;
public:
    D(int a, int b, int c, int d):A(a),B(a,b),C(a,c),d(d){}
    void display();
};
void D::display(){
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
    cout<<"c="<<c<<endl;
    cout<<"d="<<d<<endl;
}
int main(){
    (new D(1, 2, 3, 4)) -> display();
    return 0;
}

本例中我们使用了虚基类，在派生类D中只有一份成员变量 a 的拷贝，所以在 display() 函数中可以直接访问 a，而不用加类名和域解析符。

请注意派生类D的构造函数，与以往的用法有所不同。以往，在派生类的构造函数中只需负责对其直接基类初始化，再由其直接基类负责对间接基类初始化。现在，由于虚基类在派生类中只有一份成员变量，所以对这份成员变量的初始化必须由派生类直接给出。如果不由最后的派生类直接对虚基类初始化，而由虚基类的直接派生类（如类B和类C）对虚基类初始化，就有可能由于在类B和类C的构造函数中对虚基类给出不同的初始化参数而产生矛盾。所以规定：在最后的派生类中不仅要负责对其直接基类进行初始化，还要负责对虚基类初始化。

有的读者会提出：类D的构造函数通过初始化表调了虚基类的构造函数A，而类B和类C的构造函数也通过初始化表调用了虚基类的构造函数A，这样虚基类的构造函数岂非被调用了3次？大家不必过虑，C++编译系统只执行最后的派生类对虚基类的构造函数的调用，而忽略虚基类的其他派生类（如类B和类C）对虚基类的构造函数的调用，这就保证了虚基类的数据成员不会被多次初始化。

最后请注意：为了保证虚基类在派生类中只继承一次，应当在该基类的所有直接派生类中声明为虚基类，否则仍然会出现对基类的多次继承。

可以看到：使用多重继承时要十分小心，经常会出现二义性问题。上面的例子是简单的，如果派生的层次再多一些，多重继承更复杂一些，程序员就很容易陷人迷 魂阵，程序的编写、调试和维护工作都会变得更加困难。因此很多程序员不提倡在程序中使用多重继承，只有在比较简单和不易出现二义性的情况或实在必要时才使用多重继承，能用单一继承解决的问题就不要使用多重继承。也正由于这个原因，C++之后的很多面向对象的编程语言（如Java、Smalltalk、C#、PHP等）并不支持多重继承。