C++ 继承

最新推荐文章于 2024-01-20 21:14:03 发布
最新推荐文章于 2024-01-20 21:14:03 发布
阅读量262 收藏 2
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guaiderzhu1314/article/details/113530997
版权

1. 继承的概念

在这里插入图片描述
在这里插入图片描述

  • 子类可以继承基类， 基类去派生子类
  • Human 是基类，Student和Teacher是子类

2. 继承的语法

在这里插入图片描述

  • 一个子类可以继承 多个基类，下面的代码都是只有一个基类。
#include <iostream>
using namespace std;
class Human {// 人类(基类)
public:
    // 常引用才能引用右值
    Human(const string& name, int age):m_name(name), m_age(age){};
    void eat(const string& food){
        cout << "我在吃" << food << endl;
    }
    void sleep(int hour){
        cout << "我睡了" << hour << "个小时" << endl;
    }
// protected属性下，在类的外部依然不能访问， 但是子类能访问基类这些成员变量
// private属性下类的外部和子类都不能访问
protected: 
    string m_name;
    int m_age;
};

class Student:public Human{// 学生类(人类派生的一个子类)
public:
    Student(const string& name, int age, int no):Human(name, age), m_no(no){};
    void learn(const string& course){
        cout << "我在学" << course << endl;
    }
    void who(void){
        cout << "我叫"<< m_name << ",今年" << m_age << "岁,"<< "学号是 " << m_no << endl; 
    }
private:
    int m_no;
};

class Teacher:public Human{// 教师类(人类派生的一个子类)
public:
    Teacher(const string& name, int age, int salary):Human(name, age), m_salary(salary){}
    void teach(const string& course){
        cout << "我在教" << course << endl;
    }
    void who(void){
        cout << "我叫"<< m_name << ",今年" << m_age << "岁,"<< "薪水是 " << m_salary << endl; 
    }
private:
    int m_salary;
};

int main(void){
    Student s("yue han", 18, 666);
    s.who();
    s.eat("炸酱面");
    s.sleep(8);
    s.learn("c++");

    Teacher t("jie ke", 30, 20000);
    t.who();
    t.eat("油泼面");
    t.sleep(9);
    t.teach("c++");
    return 0;
}

$ ./a.out 
我叫yue han,今年18岁,学号是 666
我在吃炸酱面
我睡了8个小时
我在学c++
我叫jie ke,今年30岁,薪水是 20000
我在吃油泼面
我睡了9个小时
我在教c++

3. 公有继承的特性

3.1 任何时候都可以把一个子类对象看作是是一个基类对象

在这里插入图片描述

3.2 向上造型、向下造型 (基类在上，子类在下)

在这里插入图片描述

  • 向上造型，通俗点讲就是，一个基类指针可以指向任何一个子类对象，但是只能访问子类对象中的基类子对象。
    • 向上造型的产物：指向子类对象的基类指针，引用用子类对象的基类引用。
  • 向下造型，要注意使用的合理性。
#include <iostream>
using namespace std;
class Human {// 人类(基类)
public:
    // 常引用才能引用右值
    Human(const string& name, int age):m_name(name), m_age(age){};
    void eat(const string& food){
        cout << "我在吃" << food << endl;
    }
    void sleep(int hour){
        cout << "我睡了" << hour << "个小时" << endl;
    }
// protected属性下，在类的外部依然不能访问， 但是子类能访问基类这些成员变量
// private属性下类的外部和子类都不能访问
protected: 
    string m_name;
    int m_age;
};

class Student:public Human{// 学生类(人类派生的一个子类)
public:
    Student(const string& name, int age, int no):Human(name, age), m_no(no){};
    void learn(const string& course){
        cout << "我在学" << course << endl;
    }
    void who(void){
        cout << "我叫"<< m_name << ",今年" << m_age << "岁,"<< "学号是 " << m_no << endl; 
    }
private:
    int m_no;
};

int main(void){
    Student s("yue han", 18, 666);
    s.who();
    s.eat("炸酱面");
    s.sleep(8);
    s.learn("c++");

    // Student* ==> Human*: 向上造型
    Human* ph = &s;
    ph->eat("苹果");
    ph->sleep(8);
    // ph->who(); // 编译Error

    // Human* ==> Student: 向下造型 (合理，因为ph本来就是指向的Student类对象的指针)
    // Student* = ph; // 编译Error
    Student* ps = static_cast<Student*>(ph);
    ps->who();

    // Human* ==> Student: 向下造型 (不合理)
    // Human创建的对象， 对应在内存里的数据只有m_name, m_age, 
    Human h("li ming", 18);
    // 通过向下造型得到的Student对象，是可以访问m_no的，但h对应内存中没有m_no的数据
    Student* ps2 = static_cast<Student*>(&h);
    // 所以通过 ps2 直接访问 m_no 是有异常的
    ps2->who();
    return 0;
}

$ ./a.out 
我叫yue han,今年18岁,学号是 666
我在吃炸酱面
我睡了8个小时
我在学c++
我在吃苹果
我睡了8个小时
我叫yue han,今年18岁,学号是 666
我叫li ming,今年18岁,学号是 0

3.3 子类 继承/隐藏 基类成员

在这里插入图片描述

  • 虽然子类和基类定义同名的函数，因为作用域不同，不会构成重载关系，但是可以在子类中 通过using 基类名:函数名， 把基类当中的函数声明到当前作用域，这样就可以构成函数重载关系了。但它并不具备通用性。
  • 推荐直接用 类名:: 显示指明
#include <iostream>
using namespace std;
class Base{
public:
    void func(void){
        cout << "Base:func(void)" << endl;
    }
};

class Derived:public Base{
public:
    void func(int i){
        cout << "Derived:func(int)" << endl;
    }
    using Base::func; //但是不具备通用型，因为如果两个函数参数也一样，就没法构成重载关系
};
int main(void){
    Derived d;
    d.func(4);      // Derived:func(int)
    // 子类中 有 using Base::func; 子类中的func(int)和 基类中的func(void)才能构成函数重载
    d.func();       // Base:func(void)
    d.Base::func(); // Base:func(void)
    return 0;
}

4. 继承方式和访问控制属性

4.1 访问控制属性 (public、protected、private)

在这里插入图片描述

4.2 继承方式 (public、protected、private)

在这里插入图片描述

  • 继承方式并不影响在子类内部对基类成员 原本 的 可访问性。
  • 不同的继承方式实质上影响的是 通过 子类 访问 基类中成员时 的 可访问性
    • 1. 通过子类对象在类的外部访问基类成员
    • 2. 在子类的子类中访问基类成员
#include <iostream>
using namespace std;
class A{// 基类
public:
    int m_public;
protected:
    int m_protected;
private:
    int m_private;
};

class B:public A{// 公有继承的子类
};
class C:protected A{// 保护继承的子类
};
class D:private A{// 私有继承的子类
};

// 2. 通过子类的子类访问基类成员
class X:public B{
    void func(void){
        m_public;   // 对基类成员的访问控制属性 public
        m_protected;  // protected
        // m_private; // Error, private

    }
};

class Y:public C{
        void func(void){
        m_public;   //   protected
        m_protected;  // protected
        // m_private; // Error, private

    }
};

class Z:public D{
        void func(void){
        // m_public;     // Error, private
        // m_protected;  // Error, private
        // m_private; // Error, private

    }
};

int main(void){
    // 1. 通过子类对象在类的外部访问基类成员
    B b;
    b.m_public; // 对基类成员的访问控制属性： public
    // b.m_protected;// Error, protected
    // b.m_private; // Error, private
    C c;
    // c.m_public;  // Error, protected
    // c.m_protected;// Error, protected
    // c.m_private; // Error,  private
    D d;
    // d.m_public;  // Error,  private
    // d.m_protected;// Error,  private
    // d.m_private; // Error,   private
    return 0;
}

4.3 向上造型在 私有/保护继承中不在适用

#include <iostream>
using namespace std;
class Base{
public:
    int m_data;
};

class Derived_public:public Base{};
class Derived_private:private Base{};

int main(void){
    Derived_public d1;
    Base* pb1 = &d1;
    pb1->m_data;

    // 向上造型在 私有/保护继承中不在适用
    // 通过d2对基类成员m_data的访问控制属性应该是private, 相当于访问属性变小
    Derived_private d2;
    // 这时再向上造型，转为Base基类类型，好像又可以访问m_data了，相当于访问属性变大，这时很矛盾的，不被允许的
    // Base* pb2 = &d2; // Error
    return 0;
}

5. 子类的的构造和析构

5.1 子类的构造

在这里插入图片描述

5.2 子类的析构

在这里插入图片描述

#include <iostream>
using namespace std;
class Base{
public:
    Base(void):m_data(0){
        cout << "Base 缺省构造" << endl;
    }
    Base(int i):m_data(i){
        cout << "Base 有参构造" << endl;
    }
    ~Base(void){
        cout << "Base 析构" << endl;
    }
    int m_data;
};

class Member{
public:
    Member(void):m_i(0){
        cout << "Member 缺省构造" << endl;
    }
    Member(int i):m_i(i){
        cout << "Member 有参构造" << endl;
    }
    ~Member(void){
        cout << "Member 析构" << endl;
    }
    int m_i;
};

class Derived:public Base{
public:
    // 如果没有显示指明，将调用基类的的无参构造函数来初始化基类子对象
    Derived(void){
        cout << "Derived 缺省构造" << endl;
    }
    // Base(i) 显示指明基类子对象的初始化方式
    // m_mem(i) 显示指明成员子对象的初始化方式
    Derived(int i):Base(i), m_mem(i){
        cout << "Derived 有参构造" << endl;
    }
    ~Derived(void){
        cout << "Derived 析构" << endl;
    }
    Member m_mem;
};


int main(void){
    Derived d1;
    Derived d2(100);
    return 0;
}

$ ./a.out 
Base 缺省构造
Member 缺省构造
Derived 缺省构造
Base 有参构造
Member 有参构造
Derived 有参构造
# 析构和构造的过程对称相反
Derived 析构
Member 析构
Base 析构
Derived 析构
Member 析构
Base 析构

5.3 一个内存泄露的风险

int main(void){
    // 注意下面的代码有内存泄露风险
    // 在堆区创建一个对象（1.malloc分配内存，2.调Derived的构造函数），然后向上造型
    Base* pb = new Derived;
    // 销毁堆区的对象(1.调基类Base的析构函数（因为pb是基类指针） 2.free内存)
    delete pb;
    // 上面只是调用了基类的析构函数，只是会把基类中维护的动态资源释放掉。
    // 没有调子类和成员对象的析构函数。而子类和成员对象当中的动态资源是没有被释放的。
    // 这将造成内存泄露
    pb = NULL;
    return 0;
}

$ ./a.out 
Base 缺省构造
Member 缺省构造
Derived 缺省构造
Base 析构
  • 这个风险可以用虚析构函数来解决掉
半只因
关注
专栏目录
C++中类的继承
m0_53536818的博客
09-07 1151
继承的定义： 一个类属于另外一个类的一部分 该类拥有另外一个类的所有的属性和方法 如果一个类继承另外一个类，那么该类拥有另外一个类的所有的属性和方法 在C++中，定义一个类可以继承其他的类 支持多继承，即一个类有多个父类 继承多个类时，每个类的继承方式都可以不一样 继承方式有： public 公开继承 protected 保护继承 private 私有继承 C++中默认的（缺省的）继承方式为私有继承 在继承中，被继承的类称为父类或基类，继承父类的类称为子类或派生类 继承的意义： 子类拥有父类的属性
C++ 继承详解及实例代码
09-01
C++继承是面向对象编程中的一个核心概念，它允许创建一个新的类（子类或派生类）基于已存在的类（基类或父类）。通过继承，子类不仅可以获得基类的所有成员（包括数据成员和成员函数），还可以添加新的功能或者重写...
C++中类的多继承
热门推荐
阳光日志
07-19 3万+
在写这一主题的文章之前，在网上找到一篇很非常好的文章C++之继承与多态。就没有必要做重复造轮子的事件了，那就从这篇文章开始吧！在c++中一个类可以从多个基类中派生(即可以有多个父类)，这就是多继承。多继承的方式主要有两种：1. 简单版本 类C会同时拥有类A和类B的特性(属性和方法，也就是两个类的所有成员)。这种方式很简单这里就不多说，主要讲下面这种方式。2. 复杂版本 同样的，这个结构中
C++类的继承
潜心钻研技术
02-07 2138
继承的概念和定义 概念 我们知道C++是一个面向对象的语言，继承是面向对象程序设计使代码可以复用的最重要的手段，使在逻辑上是继承关系的对象在用类来描述对象语言层面实现了代码复用，这样产生的新的类叫做派生类 例如用学生系统来举例 图中的学生管理系统建立了四个类用来描述 人、学生、老师、助教，但是我们发现学生、助教、老师这三个类都有人这个类的属性，在这个属性上才会多出来一些不同的特征，例如学生可能会有学号、班级…，于是学生从人继承部分属性就是类中的继承，人这个类叫做 父类 或者 基类 ，学生这个类别叫做 子类
2. C++ 继承
LinuxTaoist的博客
10-11 208
1. 简介 继承 ，表示两个类的关系，即通过已存在的类来创建一个新的类。其中已存在的类称为基类，新创建的类则称为派生类。 注： C++的继承类似于C语言中的结构体与结构体变量的关系：在C语言中，首先建立结构体以及其内部的结构体成员，然后以此结构体作为数据类型定义若干个结构体变量。如此一来，这些结构体变量就都包含了构建的结构体成员。 基类&派生类 由上面的介绍，基本了解了基类与派生类的...
C++类 继承 （笔记）
weixin_45848751的博客
06-07 1471
写在前面， 我是1024Person，目前是C++道路上的一只小白 记笔记就要写博客 继承_理论概念__使用语法__继承中的构造和析构__多继承__菱形继承_ 继承作为类的三大特性之一，在C++中占据着极为重要的地位！！！通过继承来实现快速的扩展功能，在不改变源代码的情况下进行功能的快速扩展，这也是继承的最大的用处之一 虽然重要，但是并不难 理论概念 1、在C++中，继承描述的是类与类之间的关系的，他是一个很简单很直观的 概念，类似于现实生活中的儿子继承父亲的财产 2、被继承的类叫做基类（父类），继承.
c++继承分类
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许我们创建新的类，这些新类可以扩展已存在的类的功能。在这个“c++继承分类”主题中，我们将深入探讨C++中的继承机制，以及如何在Qt环境中利用这一特性进行开发...
C++ 继承机制易犯的错误
01-21
继承作为面向对象的基本特征之一，其使用率极高。不管是为了实现软件的基本功能，还是再程序的重构的过程中，我们总是会用到继承机制。正是因为其用途极为广泛，而且使用简单，大众程序员对其真正的内部实现机制的...
08_31_C++ 继承的二义性
07-01
08_31_C++ 继承的二义性08_31_C++ 继承的二义性08_31_C++ 继承的二义性08_31_C++ 继承的二义性08_31_C++ 继承的二义性08_31_C++ 继承的二义性08_31_C++ 继承的二义性08_31_C++ 继承的二义性08_31_C++ 继承的二义性08...
C++类之间的继承
实践求真知
03-17 1091
一被继承成员的访问权限 1代码 #include &lt;iostream&gt; using namespace std; class CPolygon { protected: int width, height; public: void set_values(int a, int b) { width = a; height = b; } }; clas...
C++类继承
ABBzm的博客
01-27 564
#C++类继承 继承的好处之一就是使用了可以重复使用的代码，不用重复的造轮子。 继承的类是由基类派生来的，所以要先有一个基类： 派生类继承了基类的所有东西，但是也要在一定的规则下使用和操作基类的成员了。 格式： 格式：class B:public A{ .... .. . } B是派生类；冒号表示类B继承自类A；public表示公有派生，公有派生将使基类的公有成员成为派生类的公有成员，而基类的私有成员也将成为派生类的一部分，只是只能使用基类的公有方法和保护方法访问。 B类有两个基本
C++ 继承方式
gxt_kt的博客
01-19 1420
C++ 继承方式 文章目录C++ 继承方式一、了解继承方式首先需要了解类的权限：二、继承时权限的变化1.公共继承2.保护继承3.私有继承三、代码理解四、深入研究，加深理解五、全部代码（由于故意写出错误帮助理解，编译通不过） 继承方式： 1.公共继承。2.保护继承。3.私有继承 用法： class 子类 : 继承方式 父类{ 内容 } 一、了解继承方式首先需要了解类的权限： public:类内类外都能访问 protected/private:类内能访问，类外不能访问 二、继承时权限的变化 1.公共继承 p
【C++类与对象】继承
最新发布
qq_50563459的博客
01-20 531
3、当子类中出现和父类同名的成员函数，子类的同名成员函数会隐藏掉父类中所有同名成员函数（包括重载的），如果想访问到需要加作用域。父类中所有的非静态成员属性都会被子类继承，父类中私有的成员属性被编译器隐藏不可访问但被继承。可能会引发父类中同名，不明确出现二义性，可以使用作用于访问父类中的同名。子类继承父类后，当创建子类对象，也会调用父类的构造函数。先构造父类，再构造子类，析构的顺序与构造的顺序相反。2、访问父类同名成员，需要加载作用域（1、访问子类同名成员，直接访问即可。子类也成为派生类，父类成为基类。
c++继承 和 多态
weixin_45993900的博客
07-20 904
c++继承和多态
C++之继承
weixin_65592314的博客
03-28 1185
c++继承相关知识
C++继承
Lunaandai的博客
09-01 562
一.继承的概念 先举一个例子：儿子继承了父亲的基因，于是儿子有些特征会与父亲相同，但是儿子也会产生其他特征。c++中，一个类在得到了(共享得到)另一个类或者另几个类的成员变量和成员函数后，又增加新的功能，从而产生了新的类，该新类与另一个类或另几个类的关系，就叫继承。 该新类被称为子类（派生类），而另一类或者另几个类被称为父类（基类）。 如果父类只有一个就叫做单继承，如果有多个就叫做多继承。 单继承： class 子类名：继承权限 父类名1 { //类体 }; 多继
【c++】 继承
leijie1123的博客
10-27 432
学习继承的内容，以及菱形继承和怎么解决菱形继承的二义性和数据冗余
类继承（c++细节篇六）
qq_39838607的博客
04-03 241
类继承 1.已有的类称为父类或基类 新创建的类称为子类或派生类。 继承方式有三种： a.公有继承。 b.私有继承。 c.保护继承。 保护继承 基类的public和protected成员的访问属性在派生类中保持不变，但基类的private成员不可直接访问。 派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。 通过派生类的对象只能访问基类的public成员。 保护继承 基类的public和protected成员都以protected身份出现在派生
C++类：多继承
xupenglong的博客
07-26 175
c++ 类的多继承
C++继承详解与示例
"C++继承介绍，讲解了C++中的继承概念，包括public继承以及virtual、non-virtual和pure virtual成员函数的区别。通过示例代码展示了如何使用继承，并且验证了基类指针可以调用派生类对象的方法，但反之不行。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值