C++继承和多态

最新推荐文章于 2024-09-13 17:43:09 发布
最新推荐文章于 2024-09-13 17:43:09 发布
阅读量602 收藏 17
点赞数 14
分类专栏： C语言 数据结构 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_81342533/article/details/141058346
版权

前言

        继承和多态发生在类里面，继承就相当于一个类能够继承另一个类的函数和成员。继承的类被称为子类，被继承的类被称为父类。本文会简单的举例一些继承的使用和介绍一些继承的多种因素，各种注意事项之类的内容。

        另外，这里是根据我自己的理解做的一些讲述，一些部分可能不全面。这时请参考其他博主的博客。

一、什么是继承

        继承，会保持原有特性的基础上进行扩展，增加成员函数，成员变量。例如：水果是在植物这个类里面的，所以水果包含植物的特性。这时水果被称为子类也称为派生类，而植物被称为父类也称为基类。

        在C++中继承分为三种方式public继承、protect继承、private继承。对应的父类中三种不同的成员有不同的继承效果。具体效果如下所示：

        其中基类的private成员在派生类中都是不可见的，public继承会继承所有相对应的属性。

二、继承的写法

        继承的写法需要给明继承的方式以及继承的对象，写在派生类对象的分号后面：

class Person
{
protected:
    string _name;
};

class Student : public Person
{
protected:
    string _id;
}

        例如上图，Student就public继承了Person。当然继承方式不写会有默认的继承方式，class的默认继承方式是private继承，struct的默认继承方式是public继承。

        也可以增加模版继承，不过如果需要调用末班中的函数就需要声明清楚模版是什么，例如：

template<class T>
class Stack : public vector<T>
{
public:
    void push(const T& x)
    {
        vector<T>::push_back(x); // 显示调用
    }

    size_t size()
    {
        return vector<T>::size(); // 显示调用
    }
};


int main()
{
    Stack<int> st;
    st.push(1);
    st.push(2);
    st.push(3);
    st.push(4);
    cout << st.size() << endl;
    return 0;
}

        这种也就是模版的按需实例化，如果不写vector<T>::指定，那么编译会报错。

        在继承中有以下特性：

        1、子类对象可以复制给父类对象/指针/引用（因为是有的时候能对子类进行切割找到父类）

        2、父类对象不能复制给子类对象。指针和引用可以，但是需要原来的指针和引用指向的是子类对象。如果需要判断父类的指针/引用是否指向子类，可以使用dynamic_const(）函数。

三、继承中的函数

        由于基类和派生类是继承关系，所以基类的成员在派生类其他成员的前面。

1、构造函数

        构造函数如果不显示调用，子类会自动调用父类的默认构造，如果没有默认构造，就需要主动显示调用，构造函数会优先调用父类的构造函数：

class Person
{
public:
    Person(const int& id)
        :_id(id)
    {}

protected:
    int _id;
};

class Student : public Person
{
public:
    Student(const char* name, const int id = 1)
        :Person(id)
        ,_name(name)
    {}

    void Print()
    {
        cout << "name:" << _name << endl;
        cout << "id:" << _id << endl;
    }

protected:
    string _name;
};


int main()
{
    Student s1("张三");
    s1.Print();
    return 0;
}

2、拷贝构造

        如果没有写会调用默认构造，一般来说默认的拷贝构造已经够用了，除非需要深拷贝。

        总体来说，拷贝构造和构造函数差不多，这里我觉得也不需要过多举例了。

3、赋值重载

        子类的赋值重载“operator=”需要显示调用父类的“operator=”，因为构成了隐藏。隐藏是什么会在下一节中提到，这里先声明一下有这个东西。具体使用方法：

class Person
{
public:
    Person(const int& id)
        :_id(id)
    {}

    Person& operator=(Person man)
    {
        _id = man._id;
        return *this;
    }

    void Print()
    {
        cout << "id:" << _id << endl;
    }

protected:
    int _id;
};

class Student : public Person
{
public:
    Student(const char* name, const int id = 1)
        :Person(id)
        ,_name(name)
    {}

    void Print()
    {
        cout << "name:" << _name << endl;
        Person::Print();
    }

    Student& operator=(Student student)
    {
        Person::operator=(student);
        _name = student._name;
        return *this;
    }

protected:
    string _name;
};


int main()
{
    Student s1("张三");
    Student s2("古月方源", 99999);
    s1 = s2;
    s1.Print();
    return 0;
}

        这里的赋值重载其实也可以算是拷贝构造的例子，因为在赋值的时候同时调用了默认的拷贝构造。而在例子中也间接的可以提现出函数影藏的效果，在调用Student的“=”时，重载的函数中需要指定内域去访问Person的“=”。

4、析构函数

        析构函数也是默认的足够了，只有需要手动释放资源得到时候才需要自己实现，子类中的内容析构完成会自动调用父类的析构，这个顺序是为了确保释放资源时的安全性。需要注意的是，析构函数虽然看起来名字不一样，但是实际上是一样的，如果手动调用析构函数的话需要注明内域。

class Person
{
public:
    Person(const int& id)
        :_id(id)
    {}

    Person& operator=(Person man)
    {
        _id = man._id;
        return *this;
    }

    void Print()
    {
        cout << "id:" << _id << endl;
    }

    ~Person()
    {
        cout << "~Person()" << endl;
    }

protected:
    int _id;
};

class Student : public Person
{
public:
    Student(const char* name, const int id = 1)
        :Person(id)
        ,_name(name)
    {}

    void Print()
    {
        cout << "name:" << _name << endl;
        Person::Print();
    }

    Student& operator=(Student student)
    {
        Person::operator=(student);
        _name = student._name;
        return *this;
    }

    ~Student()
    {
        cout << "~Student()" << endl;
    }

protected:
    string _name;
};


int main()
{
    Student s1("张三");
    Person p1(0);
    return 0;
}

        这里p1后创建先析构，然后析构s1的子类，最后是父类。

四、继承关系

1、不能被继承

        如果希望类不被继承可以增加关键字final在类的后面：

class bot final
{
protected:
    int _level = 0;
};

class hard_bot : bot
{
protected:
    int _number;
};

int main()
{
    return 0;
}

        这样bot就不能被继承了。

        注意final关键字只能在C++11之后的版本使用。

2、友元的继承

        友元函数不会被继承，父类的友元函数不是子类的友元函数，无法访问子类的成员。如果想要访问子类的成员，需要在子类中也添加友缘声明。如下会出错：

class bot
{
    friend void func();
protected:
    int _level = 0;
};

class hard_bot : public bot
{
protected:
    int _number = 5;
};

void func()
{
    bot b1;
    hard_bot b2;

    cout << b1._level << endl;
    cout << b2._number << endl;
}

int main()
{
    func();
    return 0;
}

        所以需要增加子类的友元声明。

class bot
{
    friend void func();
protected:
    int _level = 0;
};

class hard_bot : public bot
{
    friend void func();
protected:
    int _number = 5;
};

void func()
{
    bot b1;
    hard_bot b2;

    cout << b1._level << endl;
    cout << b2._number << endl;
}

int main()
{
    func();
    return 0;
}

3、静态成员

        静态成员存在于类中，每个类的对象都可以使用，所以只有一个。即使在继承之后也不会增加，仍然只有一个。

class bot
{
public:
    void func()
    {
        _level++;
    }

    void print()
    {
        cout << _level << endl;
    }

protected:
    static int _level;
};

int bot::_level = 0;

class hard_bot : public bot
{
protected:
    int _number = 5;
};

int main()
{
    bot b1;
    hard_bot b2;
    hard_bot b3;

    b1.func();
    b1.print();
    b2.print();
    b3.print();
    return 0;
}

五、继承模型

1、单继承

        只有一个直接父类，这是称为单继承，以上举例均是单继承。如图所示，也可以理解为C继承A，D继承B。

2、多继承

        有两个或是以上的父类，这时称为多继承。如图所示，可以理解为E同时继承了C和D。也可以如下面代码，番茄是水果也是蔬菜。

class vegetable
{
protected:
    string _name;
};

class fruits
{
protected:
    string _name;
};

class tomato : public vegetable, public fruits
{
protected:
    string _id;
};

3、菱形继承（不推荐使用）

        如下图所示，菱形继承的关系就是父类友共同的父类。

        这样子继承在D中会有两份A，所以所占空间会很大。为了消除菱形继承的这种空间占用，C++有虚拟继承。在B和C的那里虚拟继承A，这样D中的A只会有一份。

class A
{
private:
    string _a;
};

class B : public A
{
private:
    string _b;
};

class C : public A
{
private:
    string _c;
};

class D : public B, public C
{
private:
    string _d;
};

class _B : virtual public A
{
private:
    string _b;
};

class _C : virtual public A
{
private:
    string _c;
};

class _D : public _B, public _C
{
private:
    string _d;
};

int main()
{
    cout << "sizeof(D)=" << sizeof(D) << endl;
    cout << "sizeof(_D)=" << sizeof(_D) << endl;
    return 0;
}

六、其他

1、多继承和父类指针

class B
{
private:
    string _b;
};

class C
{
private:
    string _c;
};

class D : public B, public C
{
private:
    string _d;
};


int main()
{
    D d;
    B* p1 = &d;
    C* p2 = &d;
    D* p3 = &d;
    cout << "p1 = "<< p1 << endl;
    cout << "p2 = "<< p2 << endl;
    cout << "p3 = "<< p3 << endl;
    return 0;
}

        由以上代码不难看出继承之间的空间关系，D先继承B然后是C，所以B中的成员在内存空间最前面，然后是C和D。另外在提取指针的时候p2会自动偏移到存放C内容的地方。这些关系都是计算机设计者安排的特性。

2、继承和组合

        组合就是直接嵌套，他和继承的关系如下：

template<calss T>
class stack1 : public vector<T>
{
protected:    
    int _size;
};

class stack2
{
protected:    
    vector<int> _v;
    int _size;
};

        他们所占的空间都是相同的，但是组合的方式更加多变，一般也更为方便。这主要是提现在接口方面。stack2能更好的适应接口，而继承的话接口就多了有不便之处。

结语

        本来在开始写博客的时候想好了怎么写结语的，但是写到最后的时候发现自己忘记了写啥。随便扯几句也不会有人发现吧。

        关于继承其实能讲的不算多，主要是理论为主，举例为辅。内容也比较短，这不是说继承简单，而是说虚继承的部分底层太难讲，感觉讲不明白。简单的来说虚继承就是最后改成了用指针继承，如果继承了相同的类会识别出来，不创建更多的空间。

        扩展内容也不是没有，不过感觉用处不大，本文也就不多做描述了。

随缘与奇迹
关注
专栏目录
C语言模式实现C++继承和多态的实例代码
08-29
多态可以分为编译时多态和运行时多态。编译时多态是通过重载函数来实现的，运行时多态是通过虚函数来实现的。静态多态是编译器在编译期间完成的，动态多态是在函数执行期间判断所引用对象的实际类型。 在C++中，...
浅谈c++的精髓之继承和多态
09-10
### 面向对象编程与C++中的继承和多态 #### 1. 面向对象编程思想的诞生 面向对象编程（Object-Oriented Programming, OOP）的引入，是为了克服传统面向过程编程的一些局限性。面向过程编程，如C语言，更侧重于按...
C++ 继承和多态
鄭高兴
12-30 1182
(1) 继承是C++源生支持的一种语法特性，是C++面向对象的一种表现(2) 继承特性可以让派生类“瞬间”拥有基类的所有（当然还得考虑权限）属性和方法(3) 继承本质上是为了代码复用(4) 类在C++编译器的内部可以理解为结构体，派生类是由基类成员叠加派生类新成员得到的父类的public成员 在子类中是public的父类的protected成员 在子类中是protected的父类的private成员 在子类中是private的，权限进一步降低，只能通过父类的public方法间接访问。
C++继承和多态核心重点知识刨析，一文必拿下
小杰312的博客
03-02 3410
C++继承和多态核心重点知识刨析，思考着学习
c++继承 和 多态
weixin_45993900的博客
07-20 868
c++继承和多态
C++ 继承与多态
XXXTENTAC1ON的博客
03-23 2399
继承与多态介绍继承的概念与定义 介绍 继承机制 是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员保持原有类特性的基础上进行扩展，增加功能；这样产生新的类，称派生类；继承呈现了面向对象程序设计的层次结构；体现了由简单到复杂的认识过程 多态性 是考虑在不同层次的类中，以及在统一类中，统么的成员函数之间的关系问题。函数的重载，运算符的重载，属于编译时的多态性；以虚基类为基础的运行时的多态性是面向对象程序设计的标志性特征；体现了类推和比喻的思想方法 早期绑定：编译时就确定了调用关系 晚绑定：程序运行的过
C++继承和多态常见面试题
weixin_63143943的博客
02-20 1241
C++继承和多态
C++的继承和多态
linzixi0220的博客
01-30 1791
继承与派生 面向对象程序设计的三大特征是封装、继承和多态。其中继承体现的是一种持续发展的、开放的编程态度。继承和派生可以在不破坏原有类的封装特性的情况下获得原有类的数据和功能，并在此基础上增加新的数据和功能。基类是为解决以前的老问题而设计的，但在遇到新问题时其功能就有局限，这是在继承的基础上进行派生则能够在基类的基础上添加功能来解决新问题。因此通过继承和派生可提高代码的可重用性和持续性。 继承与派生概念：保...
【C++】继承和多态
Qiuhan_909的博客
07-20 1395
C++继承和多态
C++——继承和多态
weixin_57133901的博客
03-07 2387
多态： 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。 1.1两种多态： 1.1.1编译时多态（早绑定）： 编译时的多态通过函数的重载和运算符的重载来实现的。 就像是未出生的男女孩定下的娃娃亲。 1.1.2运行时多态（晚绑定）
[C++] 继承和多态
weixin_51654781的博客
05-31 2207
对C++ 继承和多态较为详细的笔记， 内存布局， 虚表等
C语言实现C++继承和多态的代码分享
08-29
C语言实现C++继承和多态的代码分享 本文主要讲诉了C和C++的区别，以及如何使用C语言模拟实现C++继承和多态，并附上示例代码。下面是相关知识点的总结： 1. C语言和C++的区别： * C语言是面向过程的语言，而C++是...
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 689
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
最新发布
qq_74190237的博客
09-13 148
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
【c++23种设计模式概述】
m0_45463480的博客
09-09 783
c++23种设计模式概述。
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 1050
💫往期文章👇：
C语言作用域
天道酬勤
09-07 1020
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 824
set、map仿STL模拟实现
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值