【C++之继承知识】

最新推荐文章于 2024-06-05 22:10:49 发布

下课后泡实验室

最新推荐文章于 2024-06-05 22:10:49 发布

阅读量437

点赞数 18

分类专栏： C++基础专栏文章标签： c++ 继承继承的访问权限继承的作用域派生类的默认构造函数继承与友元继承与静态成员

本文链接：https://blog.csdn.net/m0_69455439/article/details/138357195

版权

C++基础专栏专栏收录该内容

23 篇文章 0 订阅

订阅专栏

C++之继承知识

前言：
前面篇章学习了C++对于模板有了新的认识和了解，接下来继续学习，C++的另一个特性继承等相关知识。
/知识点汇总/
前言：

封装：
1.数据和方法放在一起，把想给访问的成员，定义为公有，不想被访问的定义为私有或保护。
2.一个类型放在另一个类型里面，通过typedef成员函数调整，封装另一个全新的类型。
继承：
继承机制是面向对象程序设计使得代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产合新的类，称为派生类。
继承呈现了对象面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前接触的复用是函数复用，继承是属于类的复用。

1、C++中继承的简单介绍

在C++中，继承（Inheritance）是面向对象编程（OOP）的一个重要特性，它允许一个类（称为派生类或子类）继承另一个类（称为基类或父类）的属性和方法。通过这种方式，派生类可以重用基类的代码，并添加或修改一些特定的功能。

1.1、继承的语法

在C++中，使用冒号（:）和访问修饰符（如public、protected、private）来声明继承关系。

//语法 --- 定义格式
class Student : public Person
{
protected:
	int _stulid;//学号
};
Student -- 派生类 --子类
public --- 继承方式
Person ---- 基类 ---父类

class Base {  
public:  
    void baseFunction() {  
        // ...  
    }  
};  
  
class Derived : public Base { // 派生类Derived公有继承基类Base  
public:  
    void derivedFunction() {  
        // ...  
        baseFunction(); // 可以调用基类的公有函数  
    }  
};

1. 2、继承的特性

继承的特性
代码重用
通过继承，派生类可以重用基类的属性和方法，避免重复编写相同的代码。
多态性
通过继承和虚函数，可以实现运行时多态性，即同一操作可以根据不同的对象执行不同的操作。
扩展性
派生类可以在继承基类的基础上添加新的属性和方法，从而扩展基类的功能。

1.3、继承的类型

公有继承（Public Inheritance）：
在公有继承中，基类的公有和保护成员在派生类中仍然是公有和保护成员，基类的私有成员在派生类中仍然是私有的，不能被直接访问。
保护继承（Protected Inheritance）：
在保护继承中，基类的公有和保护成员在派生类中变为保护成员，基类的私有成员在派生类中仍然是私有的。
私有继承（Private Inheritance）：
在私有继承中，基类的公有和保护成员在派生类中变为私有成员，基类的私有成员在派生类中仍然是私有的。注意，在私有继承中，派生类外部的代码不能访问基类的公有成员。

3、继承的简单应用

#include <iostream>
using namespace std;
class Person
{
public:
	void Print()
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
	}
//protected:
protected:
	string _name = "perter";//姓名
	int _age = 18;//年龄
};
class Student : public Person
{
protected:
	int _stulid;//学号
};
class Teacher : public Person
{
protected:
	int _jobid;//工号
};
int main()
{
	Student sd;
	//sd._name += 'x';
	sd.Print();
	return 0;
}

4、继承中的访问修饰符或访问的权限

#include <iostream>
using namespace std;
class Person
{
public:
	void Print()
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
	}
	//protected:
//protected:
	string _name = "perter";//姓名
//private: //----派生类不可见
	int _age = 18;//年龄
};

//class Student : public Person
//class Student : protected Person //公有遇见私有或保护，权限缩小。//保护遇见私有，变私有
class Student : public Person
{
public:
	void func()
	{
		cout << "name: " << _name << endl;
		//cout << "age: " << _age << endl;//不能直接访问父类的私有成员，不可见==不能访问
		//不过可以间接使用：调用父类的成员函数间接使用
		Print();
	}
protected:
	int _stulid;//学号
};
class Teacher : public Person
{
protected:
	int _jobid;//工号
};
int main()
{
	int i = 1;
	double d = i;
	string s = "111111";
	//const string& s = "111111";
	//不相关类型之间不支持转换
	//string str = i;

	//子类可转父类 --- 前提是公有
	//Student st;
	//Person p = st;

	//public继承
	//每个子类对象都是一个特殊的父类对象 --- 子可以给父，父不能给子(因为子继承有父的成员，而父不一定都有子的成员)

	//切割/切片复制兼容
	Student st;
	Person p = st;
	//复制兼容 -- 编译器进行特殊处理
	Person& ref = st;
	Person* ptr = &st;

	ref._name += 'x';
	ptr->_name += 'y';

	return 0;
}

小结：

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

5、继承中的构造函数和析构函数

构造函数 在派生类中，如果需要初始化基类的成员，可以在派生类的构造函数中调用基类的构造函数。这通常通过初始化列表来完成。
析构函数 派生类的析构函数在基类析构函数之前被调用。这是为了确保在派生类部分被销毁之前，基类部分已经得到了适当的清理。

6、继承中的覆盖和重载

覆盖（Overriding） 在派生类中重新定义基类的虚函数，这种机制被称为覆盖或重写。通过覆盖，派生类可以改变基类虚函数的行为。
重载（Overloading）在基类或派生类中，可以使用相同的函数名但不同的参数列表来定义多个函数，这被称为函数重载。

7、继承中的作用域

#include <iostream>
using namespace std;
class Person
{
public:
	void Print()
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
	}
protected:
	string _name = "perter";//姓名
	int _age = 18;//年龄
	int _num = 0;
};
class Student : public Person
{
public:
	void func()
	{
		//Student中有两个_num时，如何访问呢？---作用域优先级
		cout << _num << endl;//子类成员会屏蔽父类对同名成员的直接访问 -- 称为隐藏

		//如果就想访问父类的_num呢？--- 指定作用域访问
		cout << Person::_num << endl;
	}
protected:
	int _stulid = 0;//学号
	int _num = 1;
};
int main()
{
	Student sd;
	sd.func();
	return 0;
}

小结：

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

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

8.1、6个默认成员函数

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类
中，这几个成员函数是如何生成的呢？

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

#include <iostream>
using namespace std;

class Person
{
public:
	//Person(const char* name = "peter")
	Person(const char* name)
		: _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; // 姓名
};
//派生类的编译器的默认构造函数有做些什么？
//1.把父类成员看作一个整体
//2.自己的成员
// a、内置类型
// b、自定义类型
// （规则与之前的相同，内置类型不做处理，自定义类型调用自己的默认构造函数）
//3.
class Student : public Person
{
public:
	//父类没写默认构造就自己写
	//Student(int num,const char* str,const char* name)
	//	:_name(name)//不允许单独对父类的成员进行初始化
	//	,_num(num)
	//	,_str(str)
	//{}
	//派生类 = 父类 + 子类，父类的调用·父类·构造函数初始化(把父类当作一个整体)
	Student(int num, const char* str, const char* name)
		:Person(name)//不允许单独对父类的成员进行初始化
		, _num(num)
		, _str(str)
	{}
protected:
	//Person _p;//看作整体来使用
	int _num;
	string _str;

};
int main()
{
	//父类提供了默认构造
	//Student s;

	//父类没写默认构造就自己写
	Student s(1, "abc", "peter");
	return 0;
}

8.2、派生类 = 父类 + 子类，父类的调用·父类·构造函数初始化(把父类当作一个整体)

#include <iostream>
using namespace std;

class Person
{
public:
	//Person(const char* name = "peter")
	Person(const char* name)
		: _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 B
{
public:
	B(int num, const char* str, const char* name)
		:_p(name)
		,_num(num)
		,_str(str)
	{}
private:
	Person _p;//看作整体来使用
	int _num;
	string _str;
};

int main()
{
	B b(1, "abcd", "只能");
	return 0;
}

8.3、派生类的拷贝构造

1.内置类型不做处理(浅拷贝)
2.自定义类型会去调用它的拷贝构造(深拷贝)
3.父类会去调用父类自己的拷贝构造(父类看作一个自定义类型)

#include <iostream>
using namespace std;

class Person
{
public:
	//Person(const char* name = "peter")
	Person(const char* name)
		: _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(int num, const char* str, const char* name)
		:Person(name)
		, _num(num)
		, _str(str)
	{
		cout << "Student()" << endl;
	}

	//s2(s1) -- 拷贝构造
	//切割/切片复制兼容
	//复制兼容 -- 编译器进行特殊处理
	Student(const Student& s)
		:Person(s)//直接传参，自动切片/切割
		, _num(s._num)
		, _str(s._str)
	{}

	//s3 = s2赋值构造
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//注意：派生类的与父类的同名，构成隐藏,需要指定作用域
			_num = s._num;
			_str = s._str;
			//_name = s._name;//父类复用
		}
		return *this;
	}
	//析构一般编译器就足够使用了，一些特定的资源需要手动释放
	~Student()
	{
		//一般手动就是复用父类的析构就行了
		//~Person();//多态和编译器的处理，造成隐藏
		//但是发现，此处不能显示的调用
		//由于多态中，析构函数的名字会被统一处理成destruct，造成了隐藏；比如刚才的operator的子类隐藏父类的原因，
		//导致子类的析构会隐藏父类
		//解决：指定其作用域
		cout << "~Student" << endl;
		//Person::~Person();//注意显示的写就无法保证析构是先子后父，所以一般就让子类析构结束后，系统自动调用
		//cout << "~Student" << endl;
	}
private:
	int _num;
	string _str;
};

void test1()
{
	Student b(1, "abcd", "哈哈");
	Student s2(b);
	Student s3(1, "abcd", "呵呵");
	s2 = s3;

	//析构函数和定位new可直接显示调用
	Person p("析构");
	p.~Person();
}

//构造要保证先父后子
//析构要保证先子后父
void test2()
{
	Student s1(1, "abcd", "只能");
}
int main()
{
	//test1();
	test2();
	return 0;
}

9、复用的几个体现

1.函数逻辑的复用
2.模板的复用(本质是交给编译器处理)
3.继承(派生类 = 父类 + 子类 --》内置类型、自定义类型、父类看作整体的自定义类型)

9.1、继承与友元

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

#include <iostream>
using namespace std;
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;//父类友元不能访问子类私有和保护成员
	//解决：直接父子都写一个友元类即可
	cout << s._stuNum << endl;
}
void main()
{
	Person p;
	Student s;
	Display(p, s);
}

9.2、继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。

#include <iostream>
using namespace std;

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::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}

int main()
{
	//思考：这里的静态成员变量count会是几份呢？
	//父类静态成员属于当前类，也属于当前类的所有派生类，即公开的，是公用的
	TestPerson();
	return 0;
}

9.3、复杂的菱形继承及菱形虚拟继承

基本格式：
1.单继承：一个子类只有一个直接父类时称这个继承关系为单继承
class PostGraduate:public Student ----> class Student:public Person --> class Person
2.多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
class Assistant:public Student,public Teather ----> class Student和 class Teather
3.菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。
在Assistant的对象中Person成员会有两份。
class Assistant:public Student,public Teather ----> class Student:public Person 和 class Teather:public Person --> class Person

9.4 、菱形继承就容易可能出现隐含的问题

1.数据冗余
2.二义性
解决方案：虚继承 – virtual关键字

#include <iostream>
using namespace std;
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; // 主修课程
};
void Test()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	Assistant a;
	//a._name = "peter";
	a._name = "peter";//virtual

	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}
int main()
{
	Test();
	return 0;
}

小结：

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

10、总结

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

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

实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected private。

使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

在实际运用中一般使用都是public继承，几乎很少使用protetced / private继承，也不提倡使用protetced / private继承，因为protetced / private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
6.建议：在实际中在继承体系里面最好不要定义同名的成员。