[C++知识库] C++继承

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> C++继承 -> 正文阅读

[C++知识库]C++继承

文章目录

继承的概念及定义

概念

继承机制时面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类，继承呈现了面向对象程序设计的层次结构，以前我们接触的复用都是函数复用，继承使类设计层次的复用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K2WBjUj6-1650539710651)(D:\blogs\继承图解.png)]

class Person
{
public:
    void Print()
    {
        cout << "name:" << _name<< endl;
        cout << "age:"  << _age << endl;
    }
protected:
    string _name = "tpm"; // 姓名
    int _age = 18; // 年龄
};
// 继承后父类Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。
class Student :public Person
{
protected:
	int _sid; // 学号
};

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LEFDfyuV-1650539710652)(D:\blogs\继承查看.png)]

继承的定义

下面我们看到Person是父类，也称作基类。Student是子类，也叫做派生类。

在这里插入图片描述

继承关系和访问限定符

在这里插入图片描述

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

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

总结：

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

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

派生类对象可以赋值给基类对象 / 基类指针 / 基类的引用，这里有个形象的说法叫切片或者切割。寓意就是把派生类中父类那部分切来赋值。
基类对象不能赋值给派生类对象
基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。

ps：切片不存在类型转换，是语法天然支持的行为

#include<iostream>
using namespace std;

class Person
{
protected:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};

class Student : public Person
{
public:
	int _No; // 学号

};

int main()
{
	Student s;
	// 之类对象赋值给父类的对象、指针、引用（切片）
	Person per = s;
	Person* pptr = &s;
	Person& rp = s;

	// 基类对象不能赋值给派生类对象
	s = per;

	// 基类的指针可以通过强制类型转换赋值给派生类的指针
	pptr = &s;
	Student* ps = (Student*)pptr;  // 这是可以的
	ps->_No = 10; // 能成功赋值

	pptr = &per; // 这里取的是父类对象的地址
	Student* ps2 = (Student*)pptr;

	return 0;
}

继承中的作用域

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

#include<iostream>
using namespace std;

// 父类
class Person
{
public:
	void say()
	{
		cout << "我是父类" << endl;
	}
protected:
	string _name = "tpm";
	int _num = 1000;
};
// 子类
class Student:public Person
{
public:
	void say()  // 这个函数和父类构成隐藏
	{
		cout << "我是子类" << endl;
	}

	void change(int sid)
	{
		_sid = sid;
		cout << "学号" << sid << endl;
		cout << "_num：" << _num << endl;
	}
protected:
	int _sid;
	int _num = 1234; // 子类中_num成员变量和父类中_num构成隐藏
};

int main()
{
	Student s;
	Person p;
	s.say();
	s.change(1);
	return 0;
}

在这里插入图片描述

PS：这里需要注意的是，父类中say()函数和子类中的say()函数并不构成重载，因为重载的条件是两个函数在同一作用域，而这两个函数是处于不同的作用域。Person中的say()和Student中的say()函数构成隐藏，成员函数满足函数名相同就构成隐藏

派生类的默认成员函数

在一个类中是有6个默认成员函数的，即，构造函数、拷贝构造、赋值拷贝、析构函数等。”默认“的意思是指我们不写，编译器会自动生成一个，那么在派生类中，这几个成员函数是怎么生成的呢？

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

什么情况下我们需要去写这些默认成员函数呢

父类没有默认构造，需要我们自己显示写构造函数
如果子类有资源需要释放，就需要显示写析构函数
如果子类存在浅拷贝问题，就需要自己实现拷贝构造和赋值拷贝

#include<iostream>
using namespace std;

class Person
{
public:
	// 默认构造函数
	Person(const char* name = "tpm")
		:_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;
		_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) // 显示调用基类的构造函数，初始化基类的成员
		, _sid(num)
	{
		cout << "Student()" << endl;
	}
	// 派生类的拷贝构造
	Student(const Student& s)
		:Person(s) // 显示调用基类的拷贝构造，传参是Person = Studnet,发生了切片
		, _sid(s._sid)
	{
		cout << "Student(const Student& s)" << endl;
	}
	// 派生类的赋值拷贝
	Student& operator=(const Student& s)
	{
		cout << "Student& operator=(const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator=(s); // 显示调用基类的赋值拷贝
			_sid = s._sid;
		}
		return *this;
	}
	// 子类的析构
	~Student()
	{
		cout << "~Student()" << endl;
	} 

protected:
	int _sid;
};

int main()
{
	Student s1("tpm", 22);
	Student s2(s1);
	Student s3("zy", 18);
	s1 = s3;
	return 0;
}

在这里插入图片描述

PS：析构函数名会被同一处理成destruct()，所以子类的析构函数跟父类的析构函数就构成隐藏

继承和友元

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

继承与静态成员

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

#include<iostream>
using namespace std;
// 继承与静态成员
class Father
{
public:
	void change()
	{
		_count++;
	}
protected:
	string _name;
public:
	static int _count;
};

int Father::_count = 0;

class Child1:public Father
{
protected:
	int sid;
};

class Child2 :public Father
{
protected:
	int id;
};

int main()
{
	Father f;
	Child1 c1;
	Child2 c2;
	cout << f._count << endl;
	c1.change();
	cout << c1._count << endl;
	c2.change();
	cout << c2._count << endl;
	return 0;
}

在这里插入图片描述

菱形继承和菱形虚拟继承

C++是允许类多继承的，什么意思呢？就是一个子类可能继承了多个父类，，这就叫多继承。

单继承：一个子类只能有一个直接父类时，称这个继承关系为单继承

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

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

在这里插入图片描述

菱形继承存在的问题：菱形继承存在数据冗余和二义性的问题，也就是说，Assistant继承了两份Person的成员，因为它继承了Student和Teacher类，而这两个类中都有person的成员。二义性会导致子类无法明确直到访问的是继承自哪一个的成员

在这里插入图片描述

虚拟继承

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

#include<iostream>
using namespace std;
class Person
{
public:
	string _name;
};

// Student虚继承Person类
class Student:virtual public Person
{
public:
	int _id;
};

// Teacher虚继承Person类
class Teacher :virtual public Person
{
public:
	int _num;
};

// Assistant继承Student和Teacher
class Assistant :public Student, public Teacher
{
public:
	string _majorCourse;
};

int main()
{
	Person p;
	Student s;
	Teacher t;
	Assistant a;

	p._name = "小t";
	s._name = "大明";
	t._name = "张老师";
	a._name = "研究生";

	cout <<"Person中_name的值: " << p._name << endl;
	cout << "Student中_name的值: " << s._name << endl;
	cout << "Teacher中_name的值: " << t._name << endl;
	cout << "Assistan中_name的值: " << a._name << endl;

	return 0;
}

在这里插入图片描述

虚拟继承解决数据冗余和二义性的原理

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;
	return 0;
}

下面的图可以看出D对象中将_a放到了对象组成的最下面，这个_a同时属于B和C

在这里插入图片描述