C++之继承详解

Posted 2022-02-10 小赵小赵福星高照～

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++之继承详解相关的知识，希望对你有一定的参考价值。

继承

文章目录

继承

继承的概念及定义

继承的概念

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

比如在一个学生管理系统中，需要定义学生、老师、保安等等结构体：

学生有它的名字，电话号码，地址，年龄，学号：

class Student

    string _name;
    int _tel;
    string _address;
    int _age;
    
    int _stuID;

老师也有它的名字，电话号码，地址，年龄，外加工号：

class Teacher

    string _name;
    int _tel;
    string _address;
    int _age;
    
    int _workID;

但是我们如果如果这样设计的话，我们发现有好多重复的信息，怎么解决呢？我们将重复的信息提取出来，重新建一个Person类：

class Person

    string _name;
    int _tel;
    string _address;
    int _age;

此时Student、Teacher可以将Person进行复用：

class Student

    Person _p;
    int _stuID;

class Teacher

    Person _p;
    int _workID;

但是一般成员会设置成私有的，Student、Teacher不好去访问Person的成员所以C++就设计出来了继承：

class Person

public:
    void Print()
    
        cout << "name:" << _name << endl;
        cout << "age:" << _age << endl;
    
protected:
    string _name = "peter"; // 姓名
    int _age = 18; // 年龄
;
//Student继承了Person，Student中就拥有了Person的成员
//Person叫做父类/基类
//Student叫子类/派生类
class Student : public Person

protected:
    int _stuID; // 学号
;
class Teacher : public Person

protected:
	int _workID; // 工号
;
int main()

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

继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。Person叫做父类/基类
Student和Teacher叫子类/派生类，这里体现出了Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。调用Print可以看到成员函数的复用。

继承定义

定义格式

我们可以看到Student是派生类，public是继承方式，Person是基类：

继承关系和访问限定符

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

那么在继承当中，基类成员访问方式是怎么变化的呢？

我们首先设定权限大小：

public>protected>private

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

可以通过这个表格可以总结出基类继承给子类的成员的访问方式的变为：min(访问方式，继承方式)，访问方式变为，父类中的访问方式和继承方式中取权限小的。

下面我们看这样的一个代码：

class Person

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

    void func()
    
        Print();//公有的
        _name = "张三";//protected，类内部可以访问_name
        _age = 18;//error,不可见，对象的物理空间上它是存在的，但是语法上不允许子类使用
    
protected:
    int _stuID; // 学号
;
int main()

    Student s;
	
    return 0;

我们将基类成员name设置成保护，age设置成私有，派生类继承方式为public，所以name在子类中的访问方式变为了保护，所以类内部可以访问name，age在子类中的访问方式变为了不可见，注意这里的不可见的意思是：对象的物理空间上它是存在的，但是语法上不允许子类使用，如果我们去修改age是会报错的：

实际上C++早期设计继承方式和访问限定符时，考虑复杂，把各种情况都考虑进去了，但是实际的使用中，用的最多的是public继承。基类成员的访问设定符设置成public或者protected，虽然C++设计的复杂，但是我们尽量用简单的。继承中，一个类中尽量不要使用private。因为private在子类中不可见，尽量用protected

总结：

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

基类和派生类对象赋值转换(切片)

我们写这样的类：

class Person

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

public :
	int _No ; // 学号
;

那么我们创建一个基类对象，创建一个子类对象：

int main()

    Person p;
    Student s;
    p = s;//子类对象赋值给父类对象

我们将子类对象赋值给父类对象这样是可以的，子类赋值给父类的这个过程称为切割或者切片：

同时还可以是指针和引用：

Person *pr = &s;

pr指向父类这一部分成员

Person& ref = s;

ref是父类这一部分的别名

那么我们如果像将父类对象赋值给子类对象呢？

s = p;

这样是错误的，父类对象赋值给子类对象是不可以的

继承中的作用域(隐藏)

我们首先来看下面的例子：

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
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();
;

可以看到基类和子类中有相同名字的成员，那么我们在打印时，会打印父类的num呢还是子类的num呢？我们运行一下：

我们发现打印了子类的num，这里有一个隐藏的概念：

当子类和父类有同名成员时，子类成员会隐藏父类成员。这个称为隐藏或者重定义。

那么我们如果想打印基类的num成员呢？此时我们需要指定类域：

cout<<" 学号:"<<Person::_num<<endl;

可以看到学号发生了改变，它打印了父类的num

接下来再看这样的一份代码：

class A

public:
    void func()
    
        cout<<"func()"<<endl;
    
;
class B:public A

public:
    void func(int i)
    
;
int main()

    B b;
    b.func(10);
    b.A::func();//调用父类的话需要指定作用域

和前面的成员变量一样，成员函数也是相同的道理，这里构成隐藏，要是想访问父类的成员函数需要指定类域

很多人会误解这里的func函数构成重载，但是函数重载的前提要求在同一作用域，两个func函数不在统一作用域，所以A和B类的func函数构成隐藏关系，只要函数名相同就构成隐藏。建议自己定义尽量不要在父子类中定义同名成员变量和函数

总结：

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

派生类的默认成员函数

6个默认成员函数，我们这里讲解4个，取地址重载我们就不说了，因为这两个我们自己很少实现。默认成员函数：“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

首先我们来看构造函数：

构造函数

class Person

public:
    //构造函数
    Person(const char* name = "peter")
    	  : _name(name)
     
     	cout<<"Person()" <<endl;
     
protected:
	string _name;
;
class Student : public Person

public:
    //子类构造函数 我们不写编译器默认生成
    //1.自己的内置类型成员
    //2.自己的自定义类型成员
    //3.继承的父类成员
private:
    int _id;
    string _address;
;
int main()

    Student s;
    return 0;

这里我们发现我们没有定义父类对象，但是打印的显示，调用了父类的构造函数为什么呢？是因子类构造函数我们不写，编译器默认生成构造函数，默认生成的构造函数会这样处理：

继承的父类成员调用父类的默认构造函数初始化
自己的自定义类型成员(调用自定义类型的构造函数)
自己的内置类型成员，不处理(除非给了声明时缺省值)

我们调试发现，确实是这样子的：

父类里的_name已经初始化了，内置类型并没有处理，_address调用string类的默认构造函数进行初始化。

如果我们没有写父类写了构造函数，我们就要自己实现子类构造函数，不然会报错父类没有合适的默认构造函数

在显式写子类构造函数时，对父类的成员初始化时需要注意的是父类被看成一个整体：

Student(const char* name,int id,const char* address)
    :_id(id)
    ,_address(address)

那么我们怎么给父类的成员进行初始化呢？将父类看成一个整体进行初始化：

Student(const char* name,int id,const char* address)
	:Person(name)    
    :_id(id)
    ,_address(address)

注意：

不在初始化列表显式的调用父类的构造函数初始化的话，编译器会调用默认的构造函数去初始化

那么构造函数处理完，我们再来看拷贝构造函数：

拷贝构造函数

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;
    
protected:
	string _name;
;
class Student : public Person

public:
private:
    int _id;
    string _address;
;
int main()

    Student s;
    Student s1(s);
    return 0;

我们可以看到它调用了父类的拷贝构造函数，子类拷贝构造函数我们不写编译器默认生成
默认生成的拷贝构造函数会这样处理：

继承的父类成员调用父类的拷贝构造函数初始化
自己的自定义类型成员(调用自定义类型的拷贝构造函数)
自己的内置类型成员，进行值拷贝

那么我们要是自己怎么实现呢？我们怎么对父类的那一部分进行拷贝呢？还记不记得前面讲的切片，这里就用到了：

Student(const Student& s)
       :Person(s)//切片  这里不写会调用默认构造函数
       ,_id(s._id)
       ,_address(s._address)

如果这里不写Person(s)，这里会调用默认构造函数：

如果要自己实现，就要类似这样处理，但是像这里的Student是不需要自己去实现的，默认实现的就够用，只有当子类中存在深浅拷贝问题才需要自己实现。

下面我们来看赋值重载：

赋值重载函数

class Person

public:
	//赋值重载
     Person& operator=(const Person& p)
     
         cout<<"Person operator=(const Person& p)"<< endl;
         if (this != &p)
         _name = p ._name;

     	return *this ;
	 
protected:
	string _name;
;
class Student : public Person

public:
private:
    int _id;
    string _address;
;
int main()

    Student s;
    Student s1;
    s1 = s;
    return 0;

子类赋值重载函数我们不写编译器默认生成，默认生成的赋值重载函数会这样处理：

继承的父类成员调用父类的赋值重载函数
自己的自定义类型成员(调用自定义类型的赋值重载函数)
自己的内置类型成员，进行值拷贝

那么需要自己实现呢？这样实现：

Student& operator=(const Student& s)

    if(*this != s)
    
        _id = s._id;
        _address = s._address;
        operator=(s);
    
    return *this;

我们发现这样写代码之间崩了，为什么呢？是因为子类的operator=和父类的operator=构成了隐藏。并且这里发生了切片，所以需要指定作用域：

Student& operator=(const Student& s)

    if(*this != s)
    
        _id = s._id;
        _address = s._address;
        Person::operator=(s);//切片
    
    return *this;

最后，我们来看一下析构函数：

析构函数

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:
private:
    int _id;
    string _address;
;
int main()

    Student s;
    Student s1;
    s1 = s;
    return 0;

当我们不去显式写析构函数时：

析构函数我们不写编译器默认生成，默认生成的析构函数会

继承的父类成员调用父类的析构函数
自己的自定义类型成员(调用自定义类型的析构函数)
自己的内置类型成员，不会处理

如果要自己实现呢？

~Student()

    ~Person();
    //清理子类的资源

这样是错误的，因为子类析构函数和父类析构函数构成隐藏，因为编译器会对析构函数名做特殊处理，所有类的析构函数名都会被处理成统一名字destructor()，为什么编译器会做这样的处理呢？因为析构函数在底层要构成多态的重写

我们需要加类域：

~Student()

    Person::~Person();
    //清理子类的资源

但是我们发现多析构了，为什么呢？因为子类的析构函数在执行结束之后会自动调用父类的析构函数

为了保证先构造的后释放，因为在构造函数中规则是父类是先被构造的，然后再构造子类的，所以子类的析构函数在执行结束之后会自动调用父类的析构函数，这样才能保证子类先调用析构函数清理，再调用父类析构函数清理，顺序符合一致的规则

所以我们不需要显式写父类的析构，因为编译器在子类析构执行完后会自动的去调用

~Student()

    //清理子类的资源
    //自动的调用父类的析构

继承和友元

class Person

public:
    friend void Print(const Person& p,const Student& s);
protected :
    string _name = "张三"; // 姓名
;
class Student : public Person

protected:
	int _num = 999; // 学号
;
void Print(const Person& p,const Student& s)

    cout<<" 姓名:"<<p._name<< endl;
    cout<<" 学号:"<<s._num<<endl;

void Test()

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

我们看到Print函数是基类的友元，那么友元关系可以继承吗？

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

继承与静态成员

基类定义了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 C++入门访问权限管控和继承机制详解
 C++继承详解
 C++继承详解
 [C/C++]详解C++中的继承
 [C/C++]详解C++中的继承
 C++ 继承 详解