C++继承-CSDN博客

本文链接：https://blog.csdn.net/qq_67569905/article/details/128842491

本文介绍了C++中的继承机制，包括继承的概念、派生类与基类的关系、继承方式（public、protected、private）以及它们对成员访问的影响。还讨论了派生类对象赋值给基类对象的情况，作用域与隐藏原则，以及派生类的默认成员函数如构造函数、拷贝构造函数、赋值运算符和析构函数的处理。此外，文章详细讲解了菱形继承的问题及虚拟继承的解决方案，并对比了继承与组合两种代码复用策略的特点。

摘要由CSDN通过智能技术生成

文章目录

继承的概念及其定义
派生类对象赋值给基类对象
作用域与隐藏
派生类的默认成员函数
菱形继承&&菱形虚拟继承
菱形虚拟继承的原理
继承和组合

继承的概念及其定义

概念：C++的继承机制是面向对象程序设计使代码可以复用的最重要的手段，允许用户在保持原类的特性的基础上进行拓展，这样新产生的类叫做派生类（父类），原类叫做基类（子类）。

定义：

class 派生类名 : 继承方式 基类名

举个例子：

class Person
{
protected:
    std::string _name = "张三";
    int _age = 18;
};
class Student : public Person
{
public:
    int studentId;
};
class Teacher : public Person
{
public:
    int teacherId;
};
int main()
{
    Student s;
    s.studentId = 2109122229;
    Teacher t;
    t.teacherId = 1422124;
    return 0;
}

Person对于Student、Teacher就是基类，而Student、Teacher是Person的派生类。

派生类对象中天然的就有基类对象。

继承方式和访问限定符一样有三种：public、protected、private

继承方式和访问限定符共同决定了类成员的被访问权限！

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

总结：

基类private成员不论以什么继承方式，在派生类中都是不可见的。（不可见的意思是：基类private成员仍会被继承到派生类中，但语法限制无论在类内外都无法访问该基类private成员）；
基类private成员被继承下去后是无法在派生类内被访问的，但如果想能够在派生类外不被访问并且在派生类内能被访问，这时就用protected关键字修饰该成员（protected也就是基于该原因而出现的）；
当派生类的关键字是class时默认为private继承方式，当派生类的关键字是struct时默认为public继承方式；
在实际应用中，public继承方式最为常见，protected和private继承方式非常少见。

派生类对象赋值给基类对象

派生类对象的大小总是比基类对象要大于等于的。

所以，

派生类对象能够赋值给基类对象/基类指针/基类引用，方法就是将派生类对象中基类部分切下来赋值。
基类对象不能够赋值给派生类对象
基类的指针/引用可以通过强制类型转换赋值给派生类的指针/引用，但必须基类的指针是指向派生类对象时才是安全的。如果基类是多态类型，可以使用RTTI（Run-Time Type Information）的dynamicast进行识别后进行安全转换。

作用域与隐藏

派生类一般会在基类的基础上进行拓展，那么就可能会出现拓展的变量/函数名与基类一样，但这是合法的。

class Person
{
public:
    void Func()
    {
        std::cout << "Person::Func()" << std::endl;
    }
public:
    std::string _name = "person";
};
class Student : public Person
{
public:
    void Func()
    {
        std::cout << "Student::Func()" << std::endl;
    }
public:
    std::string _name = "student";
};
int main()
{
    Student s;
    s.Func();
    std::cout << s._name << std::endl;
    s.Person::Func();
    std::cout << s.Person::_name << std::endl;
    return 0;
}

派生类中有两个Func和两个_name，但不会导致函数重载等问题，因为派生类中拓展内容和基类内容是两个不同的作用域；
访问派生类内容时，默认先访问拓展内容，若拓展内无该内容则去基类内容中访问（可添加基类作用域显式访问）；
派生类和基类重名这一现象称为隐藏；
如果是成员函数的隐藏，则只需要函数名相同即可隐藏。

派生类的默认成员函数

派生类中的基类成员会自动先调用基类的默认构造，若基类无默认构造，则必须在派生类的构造函数初始化列表显式调用构造函数；

class A
{
public:
    A(int a)
    	:_a(a)
    {}
public:
    int _a;
};
class B : public A
{
public:
    B(int b)
		:A(10)//类A无默认构造，在B的构造初始化列表处显式调用类A的构造函数,像一个匿名对象一样
    	, _b(b)
    {}
public:
    int _b;
};

派生类的拷贝构造函数中必须调用基类的拷贝构造函数来完成基类成员的拷贝构造；

class A : public string
{
    A(const A& a)
    	:string(a)//这里用派生类对象a切片拷贝构造，使用方法仍然像一个匿名对象
        :_a(a._a)
    {}
public:
    int _a;
};

派生类的赋值运算符重载中必须调用基类的赋值运算符重载来完成基类成员的赋值；

class A : public string
{
    A& operator=(const A& a)
    {
        if(this != &a)
        {
            string::operator=(a);
            _a = a._a;
        }
        return *this;
    }
public:
    int _a;
};

派生类的析构函数完成之后会自动调用基类的析构函数；
构造基类成员先进行，拓展内容后进行；
析构拓展内容先进行，基类成员后进行；
基类和派生类的析构函数默认构成隐藏。

菱形继承&&菱形虚拟继承

C++也是支持多继承的，而多继承的出现就必然会出现菱形继承这种特殊情况。

菱形继承会导致两个问题：

代码冗余（上述例子中，D类中会有两份A类成员）；
二义性（上述例子中，当访问D中的A成员时，会存在歧义，除非主动添加B/C类域）；

class A
{
public:
    int _a;
};
class B : public A
{
public:
    int _b;
};
class C : public A
{
public:
    int _c;
};
class D : public B, public C
{
public:
    int _d;
};

解决上述问题的方法就是菱形虚拟继承，在中间环节的继承中添加上virtual关键字

class A
{
public:
    int _a;
};
class B : virtual public A
{
public:
    int _b;
};
class C : virtual public A
{
public:
    int _c;
};
class D : public B, public C
{
public:
    int _d;
};

菱形虚拟继承的原理

#include <iostream>
class A
{
public:
    int _a;
};
class B : public A
{
public:
    int _b;
};
class C : public A
{
public:
    int _c;
};
class D : public B, public C
{
public:
    int _d;
};
int main()
{
    D d;
    d.B::_a = 1;
    d._b = 2;
    d.C::_a = 3;
    d._c = 4;
    d._d = 5;
    return 0;
}

这是一般菱形继承的内存视角

#include <iostream>
class A
{
public:
    int _a;
};
class B : virtual public A
{
public:
    int _b;
};
class C : virtual public A
{
public:
    int _c;
};
class D : public B, public C
{
public:
    int _d;
};
int main()
{
    D d;
    d._a = 1;
    d._b = 2;
    d._c = 3;
    d._d = 4;
    return 0;
}