Halo，这里是Ppeua。平时主要更新C++，数据结构算法，Linux与ROS…感兴趣就关注我bua！

0. 继承概念

​ 设想一个场景,你需要设计学生、老师、教授…的类,除了每个身份中独有的信息,例如:学号,工号,教授身份号,但是他们都有一个共同的属性,就是人.所以我们可以先设计一个类:人.

每设计一个新的类都可以复用人这个类,增加了代码的复用性.这就是C++中的新特性:继承

我们之前接触的函数重载是函数层面的复用,继承则是类层面的复用

class Person{
public:void print(){cout<<age<<" "<<name<<endl;}int age=0;string name="Peter";string address;int tel;
};
class Student:public Person
{
public:int _stuid;
};

我们可以通过调用来看看其结构模型.

int main()
{Person p1;cout<<p1.name<<endl;Student s1;cout << s1._stuid;
}

子类中可以共享父类中的变量,父类不可以访问子类的变量.

0.1 继承访问限定符

在类中有访问限定符,同样的,在继承方式上也有访问限定符.

派生类(子类)可以通过以下方式来继承基类(父类):

在这里新出现了一个权限符号,protected.它与private是类似的:

protected修饰的变量在类外与private类似,不能被访问.

但是在派生类中可以访问protected修饰的变量,而不能访问private修饰的变量

所以权限的大小的关系为:

public>protected>private

所以,在权限的继承中有一个最小原则.

1. 以public来继承,可以继承的变量为:public,protected
2. 以protected来继承.可以继承的变量为:protected
3. 以private来继承,无可以继承的变量

通常情况下,我们一般用public来继承,protected/private的继承方式实用性不高

1. 基类和派生类对象赋值兼容转换

派生类可以转换为基类,而基类并不能转换为派生类.

例如上面Person与Student的例子:

可以实现
Person p1;
Student s1;
p1=s1;
不能实现
s1=p1;

这其实很好理解.父类中的属性往往比子类中的成员多,子类中的成员可以通过切割多余的成员转换到父类中.

通过这样的方式,这中间不涉及强制类型转换.我们可以通过以下这个例子来看.

我们知道,强制类型转换会产生一个临时变量.例如:

int a=10;
double b=a;

这当中会产生一个临时变量double a,来赋值给b.

Person &p1=s1;

如果产生了临时变量,这个赋值是不可以的.但通过编译器验证,我们发现这样是可以的.侧面的说明这并不是引用.

但对于p1的成员进行修改,s1也会同样被修改.

Student s1;
Person p1 = s1;
p1.name = "H";

Before:

After:

虽然这种限制(子类可以转父类,父类不可转子类)可以通过指针直接访问内存的方法解除

原来指向的是student对象,现在强制转换为student指针是可以的.

Student s1;
Person *p1 = &s1;
Student* sp1 = (Student*)p1;
sp1->age = 10;

原来指向的是person对象,现在强制转换为student指针则会发生越界

Student s1;
Person pp1;
Person *pp1 = &s1;
Student* sp1 = (Student*)pp1;
sp1->age = 10;

2. 继承中的作用域

一个{}是一个作用域,所以在基类和派生类中,都有自己的作用域.

所以当在派生类中定义与基类相同的名的变量的时候就会构成隐藏:隐藏父类的相关变量

当在派生类中定义与基类相同的函数时(只需要名字相同),就会构成重定义(隐藏):重定义父类相关函数

如果需要访问父类被隐藏的属性,需要在前加类域限定符才能访问

#include<iostream>
using namespace std;
class Person {
public:void print(){cout <<"Person:" << age << endl;}int age = 0;
};
class Student :public Person
{
public:void print(int i){cout <<"Student:" << age << endl;}int age=10;};
int main()
{Student s1;cout << s1.age; //10s1.print(1);// student:10cout << s1.Person::age;//0s1.Person::print();//person:0return 0;
}

3. 派生类中的默认成员函数

总的来说,派生类中的所有涉及父类的行为都要从父类当中去寻找相关方法论:

1. 派生类初始化的时候会先调用父类的初始化函数,在调用自己的.若父类没有默认构造函数则需要在派生类中的初始化列表中调用父类构造函数传入参数.(**为什么需要在初始化列表中调用不在函数体里调用呢?**自定义类型成员（且该类没有默认构造函数时）在初始化列表中调用相关文章:初始化列表

   class Person{
   public:Person(int sage):age(sage){}void print(){cout<<age<<" "<<name<<endl;}int age=0;string name="Peter";string address;int tel;
   private:int s=0;
   };
   class Student:public Person
   {
   public:Student(int _age):Person(_age){}int _stuid;
   };
   

2. 拷贝构造与赋值运算符重载需要通过显式调用父类中的方法来完成.

   class person
   {
   public:person(const char *name="peter"):_name(name){cout<<"person()";}person(const person&p1):_name(p1._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;}string _name;};
   class student:public person
   {
   public:student(const char*name="zhangsan",int id=0):person(name),_id(id){cout<<"student()"<<endl;}student(const student&s1):person(s1),_id(s1._id){}student& operator=(const student& s1){if(this!=&s1){//出现隐藏，想要调用父类的=person::operator=(s1);_id=s1._id;}return *this;}void print(){cout<<_id<<" "<<_name<<endl;}
   private:int _id;
   };
   

3. 析构函数不需要显式调用父类(也不能),编译器会自己调用完派生类的析构函数,在调用基类的析构函数

   其实这也很好理解.从函数栈帧方面:先创建父类再创建子类,自然先析构子类再析构父类.

   从内存保护方面:在子类中有可能调用了父类的成员对象，如果先消除父类，会导致子类中出现野指针的情况

4.友元

父类的友元不能访问子类的成员变量。（父亲的朋友不是孩子的朋友）

class B;
class A{
friend void print(const A& a1,const B& b1);
private:int a=10;};
class B:public A{
private:int b=100;
};
void print(const A& a1,const B&b1)
{cout<<a1.a<<endl; //rightcout<<b1.a<<endl; //rightcout<<b1.b<<endl; //error
}

在上面的例子中可以看到:print函数可以访问A的private,而不能访问B中的private

5.继承中的静态成员

静态成员只会存在一份.在父类当中,子类中可以继承静态成员.但是继承的是访问权,只能访问不能修改

且其是存在类当中,也就是无论几个对象,访问的都是同一个静态成员

class B;
class A{
friend void print(const A& a1,const B& b1);
public:static int count;
private:int a=10;
};
int A::count=10;
class B:public A{
public:void print(){cout<<count<<" "<<endl;}private:int b=100;};void print(const A& a1,const B&b1)
{cout<<a1.count<<endl;cout<<b1.count<<endl;cout<<A::count;
}int main()
{A a1;B b1;print(a1, b1);//10A::count++;print(a1, b1);//11}

6.菱形继承

在c++中,多继承的结构模型是这样的,使用不当时会导致出现菱形继承的情况.导致内存中会重复出现一些变量.也会导致二义性

例如,在person中有一个表示年龄的age,在student与teacher中各有表示年龄的age,当professor继承student与teacher时,就会有两个age.这在现实环境中显然是不合理的

#include<iostream>
using namespace std;
class Person {
public:int age = 10;
};class Student :public Person
{
public:int stuid = 1;};
class Teacher :public Person
{int teaid = 2;
};
class Professor:public Student,public Teacher
{int profeid = 3;
};
int main()
{Professor p1;p1.Student::age = 100;p1.Teacher::age = 200;}

其在内存中的模型为:

可以看到此时出现数据冗余二义性.

C++解决这个问题的方法则是:菱形虚拟继承

7.菱形虚拟继承

一个新的关键字:virtual,在之后用到很多,但每个地方的含义都不大相同.

在继承方面,我们用virtual来修饰基类.也就是在上方结构模型的腰部

class Person {
public:int age = 10;
};class Student :virtual public Person
{
public:int stuid = 1;};
class Teacher :virtual public Person
{int teaid = 2;
};
class Professor:public Student,public Teacher
{int profeid = 3;
};
int main()
{Professor p1;p1.Student::age = 100;p1.Teacher::age = 200;cout<<sizeof(p1);
}

此时的内存模型为

结构模型为:

我们发现,重复出现的变量age修饰完只出现了一个.

观察内存模型,我们发现原来存age的地方,变成了一个指针.而age被放在了整个对象的最后一个位置.

打开内存模型,我们发现,这个指针指向了一块内存空间.叫虚基表.其中第一个位置为:0(其存放的为虚表偏移量) 第二个位置存着该指针相较于age的偏移量

为什么要这样设计呢:

1. 解决了数据冗余

2. 相同的对象可以调用同一个虚基表

3. 存放偏移量让切割成为了可能

   这里可以这样理解,当我创建了一个teacher的对象,将professor传入,则完成了切割,数据从teacher的指针开始访问,若我此时想要访问a,我直接读取偏移量即可.

总结

继承使C++底层变得复杂了起来,在日常使用中,需要避免出现菱形继承的问题.

更推荐使用组合:在一个类中调用另一个封装完的类,此时被调用的类的细节对调用类来说是不可见的.

相较于继承,更推荐使用组合的方式.高内聚低耦合一直是我们设计程序的原则

型,我们发现原来存age的地方,变成了一个指针.而age被放在了整个对象的最后一个位置.

[外链图片转存中…(img-WM0k8lWU-1692871122130)]

打开内存模型,我们发现,这个指针指向了一块内存空间.叫虚基表.其中第一个位置为:0(其存放的为虚表偏移量) 第二个位置存着该指针相较于age的偏移量

为什么要这样设计呢:

1. 解决了数据冗余

2. 相同的对象可以调用同一个虚基表

3. 存放偏移量让切割成为了可能

   这里可以这样理解,当我创建了一个teacher的对象,将professor传入,则完成了切割,数据从teacher的指针开始访问,若我此时想要访问a,我直接读取偏移量即可.

总结

继承使C++底层变得复杂了起来,在日常使用中,需要避免出现菱形继承的问题.

更推荐使用组合:在一个类中调用另一个封装完的类,此时被调用的类的细节对调用类来说是不可见的.

相较于继承,更推荐使用组合的方式.高内聚低耦合一直是我们设计程序的原则

相关文章:优先使用对象组合,而不是类继承