05-C++ 类和对象-继承

最新推荐文章于 2024-06-15 10:30:23 发布
最新推荐文章于 2024-06-15 10:30:23 发布
阅读量1.3k 收藏 24
点赞数 24
分类专栏： C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhb_feng/article/details/135290427
版权

类与对象-03

继承与派生

1. 继承的概念

c++最重要的特征是代码重用，通过继承机制可以利用已有的数据类型，来定义新的数据类型，新的类不仅拥有旧类的成员，还拥有新定义的成员。

一个 B 类继承于 A 类，或称从类 A 派生类 B。这样的话，类 A 成为基类（父类），类 B 成为派生类（子类）。

派生类中的成员，包含两大部分：

  • 一类是从基类继承过来的，
  • 一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

2. 继承的优点

1）减少重复的代码，减轻程序整体的体量。

2）继承的好处，可以将共性的内容封装成一个基类(父类)，遇到专项业务时，可以扩展基类变为一个新类，在新类中重点扩展功能。

3. 继承的语法

class 子类:继承方式 父类名
{ 
	子类新增自己的数据和方法；
};

4. 继承方式

  • public(推荐)：子类将 原封不动的继 承父类成员，但是 不能直接访问 父类 私有的成员

  • protected：子类 将 继承到 父类的成员 转换为 protected修饰的成员，但是 不能直接访问 父类 私有的成员

  • private：子类将 继承到 的 所有父类成员 转换为 私有的成员，但是 不能直接访问 父类 私有的成员

在这里插入图片描述

示例1：public 

#include <iostream>
using namespace std;
class A
{
public:
    int a;
    void testA()
    {
        cout << "testA" << endl;
    }
};
class B:public A
{
};
int main(int argc, char *argv[])
{
    B b;
    b.a = 10;
    b.testA();  //testA
    return 0;
}

示例2：protected ，若是protected继承，父类中的public将变为 protected，只能在当前类或子类中使用。

#include <iostream>
using namespace std;
class A
{
public:
    int a;
    void testA()
    {
        cout << "testA" << endl;
    }
};
class B:protected A
{
public:
    void testB()
    {
        cout << a << endl;
        testA();
    }
};
int main(int argc, char *argv[])
{
    B b;
    //此时是protected继承，父类中的public将变为 protected，只能在当前类或子类中使，
    //所以下面报错
    //b.a = 10;//报错
    //b.testA();//报错
    b.testB(); //93 testA
    return 0;
}

5. 注意

  1. 子类可以继承父类所有成员，但是父类私有成员不可访问
  2. 子类 不能继承父类 的 构造函数、拷贝构造、析构函数，但是子类中可以调用
  3. 子类可以多继承
  4. 子类在 创建对象 时会 调用父类构造函数，如果 没有明确 写出 调用的父类构造 函数，默认调用 父类无参构造 ，此时如果父类 没有无参构造，程序报错
  5. 子类调用父类构造函数，在 子类构造函数后使用初始化列表方式调用父类构造函数
  6. operator=不能被继承

示例：

#include <iostream>
#include <cstring>
using namespace std;
class Anim{
private:
    char type[50];
    int age;
    char sex[10];
public:
    Anim(){
        cout << "Anim无参构造" << endl;
    }
    Anim(char *type,char *sex,int age)
    {
        strcpy(this->type,type);
        strcpy(this->sex,sex);
        this->age = age;
        cout << "Anim有参构造" << endl;
    }
    Anim(const Anim& anim)
    {
        strcpy(this->type,anim.type);
        strcpy(this->sex,anim.sex);
        this->age = anim.age;
    }
    void setType(char *type)
    {
        strcpy(this->type,type);
    }
    char* getType()
    {
        return type;
    }
    void setSex(char *sex)
    {
        strcpy(this->sex,sex);
    }
    char* getSex()
    {
        return sex;
    }
    void setAge(int age)
    {
        this->age = age;
    }
    int getAge()
    {
        return age;
    }
};
class A{

};
//3、子类可以多继承
class Yang:public Anim,public A
{
public:
    Yang(){}

    //5、初始化列表调用父类构造函数
    Yang(char *type,char *sex,int age):Anim(type,sex,age){

    }
};

int main(int argc, char *argv[])
{
    //Yang y;
    //1、子类可以继承父类所有成员，但是父类私有成员不可访问
    //y.age;
    //2、子类不能继承父类的构造函数,拷贝构造,析构函数
    //Yang y("绵羊","公",18); //Anim有参构造
    //4、创建子类对象时会调用父类构造函数
    //默认调用父类无参构造
    //Yang y;
    //如果子类构造函数在初始化列表中指定调用父类的构造函数
    //那么就不会默认调用父类无参构造
    //Yang y("山羊","公",3);
    //如果父类中没有无参构造,子类没有明确写出调用父类构造函数
    //此时子类将调用父类无参构造,但是父类没有无参构造
    //程序报错
    Yang y;
    return 0;
}

6. 构造与析构的执行顺序

继承中的构造和析构：

  • 子类对象在创建时会首先调用父类的构造函数
  • 父类构造函数执行完毕后，才会调用子类的构造函数
  • 当父类构造函数有参数时，需要在子类初始化列表(参数列表)中显示调用父类构造函数
  • 析构函数调用顺序和构造函数相反

在这里插入图片描述

示例1：子类继承父类

#include <iostream>

using namespace std;
class A{
public:
    A(){
        cout << "A的构造函数" << endl;
    }
    ~A(){
        cout << "A的析构函数" << endl;
    }
};
class B:public A{
public:
    B(){
        cout << "B的构造函数" << endl;
    }
    ~B(){
        cout << "B的析构函数" << endl;
    }
};
int main(int argc, char *argv[])
{
    B b;
    return 0;
}
//A的构造函数
//B的构造函数
//B的析构函数
//A的析构函数

示例2：子类继承父类，该子类中还要其他类的成员

#include <iostream>

using namespace std;
class A{
public:
    A(){
        cout << "A的构造函数" << endl;
    }
    ~A(){
        cout << "A的析构函数" << endl;
    }
};
class C{
public:
    C(){
        cout << "C的构造函数" << endl;
    }
    ~C(){
        cout << "C的析构函数" << endl;
    }
};
class B:public A{
private:
    C c;
public:
    B(){
        cout << "B的构造函数" << endl;
    }
    ~B(){
        cout << "B的析构函数" << endl;
    }
};
int main(int argc, char *argv[])
{
    B b;
    return 0;
}
//A的构造函数
//C的构造函数
//B的构造函数
//B的析构函数
//C的析构函数
//A的析构函数

7. 继承中父子类成员重名

7.1 成员变量重名

调用方式：

  • 操作子类成员变量：子类对象.成员变量名
  • 操作父类提供的成员变量：子类对象.父类名::成员变量名

示例：

#include <iostream>

using namespace std;
class Basic{
public:
    int x;
    int y;
    Basic(int x):x(x){}
};
class Son:public Basic{
public:
    int x;
    //子类构造函数中必须调用父类构造函数
    //默认调用父类无参构造
    Son(int x1, int x2):Basic(x1){
        this->x = x2;
    }
};

int main(int argc, char *argv[])
{
    Son son(10,100);
    //当父子类成员变量重名时
    //此时子类对象中有两个名称相同的变量
    //1个是继承父类的
    //1个是子类特有的
    //获取子类特有的该变量
    cout << son.x << endl;//100
    //获取父类提供的x变量
    cout << son.Basic::x << endl;//10
    //没有重名的成员直接获取
    cout << son.y << endl; //随机数
    return 0;
}
7.2 成员函数重名

概念：

  • 子类成员函数名 与 父类成员函数名 重名，此时 子类该函数就是对父类名为该函数名的函数进行 重定义。
  • 重定义
    • 继承关系中
    • 子类函数名与父类函数名相同
  • 特点：屏蔽父类该函数

调用方式：

  • 操作子类成员 函数：子类对象.成员函数名(实参列表)
  • 操作父类提供的成员函数：子类对象.父类名::成员函数名(实参列表)

示例：

#include <iostream>

using namespace std;
class Fu{
public:
    void test(){
        cout << "fu test()" << endl;
    }
    void test(int a){
        cout << "fu test(int)" << endl;
    }
    void test(int a, int b){
        cout << "fu test(int, int)" << endl;
    }
    void fun01(){
        cout << "fu fun01()" << endl;
    }
};
class Zi:public Fu{
public:
    void test(){
        cout << "zi test()" << endl;
    }
};

int main(int argc, char *argv[])
{
    Zi zi;
    //当父子类函数名重名时
    //子类调用重名函数,默认调用的是子类自己的函数
    zi.test();      //zi test()
    //子类调用继承于父类的 重名函数
    zi.Fu::test();  //fu test()
    zi.Fu::test(1);  //fu test(int)
    zi.Fu::test(10,20);  //fu test(int, int)

    //子类调用继承于父类的 非重名函数
    zi.fun01();     //fu fun01()
    return 0;
}

8. 多继承

概念：一个子类继承与 多个父类

语法：

class 子类名:继承方式1 父类1, 继承方式2 父类2, ...
{
	子类特有成员
}

父类构造顺序:

  • 子类对象创建时，按继承 编写的顺序 依次执行父类对象构造，与子类构造函数后初始化列表中的顺序无关

示例1：

#include <iostream>

using namespace std;
class A{
public:
    int x;
    A(int a):x(a){}
};
class B{
public:
    int x;
    B(int a):x(a){}
};
class C:public A,public B
{
public:
    int x;
    C(int a,int b,int c):x(a),A(b),B(c){}
};
int main(int argc, char *argv[])
{
    C c(1,2,3);
    //获取c类中的x
    cout << c.x << endl;    //1
    //获取c类中继承与A类的x
    cout << c.A::x << endl; //2
    //获取c类中继承与B类的x
    cout << c.B::x << endl; //3
    return 0;
}

示例2：

#include <iostream>

using namespace std;
class A{
    public:
    A(){
        cout << "A的构造函数" << endl;
    }
    ~A(){
        cout << "A的析构函数" << endl;
    }

};
class B{
    public:
    B(){
        cout << "B的构造函数" << endl;
    }
    ~B(){
        cout << "B的析构函数" << endl;
    }
};
class C:public B,public A{
    public:
    C():A(),B(){
        cout << "C的构造函数" << endl;
    }
    ~C(){
        cout << "C的析构函数" << endl;
    }
};
int main(int argc, char *argv[])
{
    C c;
    return 0;
}
//B的构造函数
//A的构造函数
//C的构造函数
//C的析构函数
//A的析构函数
//B的析构函数

9. 菱形继承(了解)

概念：

A的子类A1与A2

B类多继承A1与A2类

此时这种关系称为菱形继承

注意：

  • 菱形继承会导致子类用于多份祖先数据，当孙子类调用成员(函数或数据)时，会产生二义性。
  • 如:
    • A类中提供num成员变量
    • A1与A2类属于A的子类,，那么A1与A2类将各自拥有一份num
    • B作为A1与A2的子类，那么 B将拥有两个num

在这里插入图片描述

示例：

#include <iostream>
#include <cstring>
using namespace std;
class Anim{
public:
    char name[50];
    Anim(char *name)
    {
        strcpy(this->name, name);
    }
};
class Yang:public Anim{
public:
    Yang(char *name):Anim(name)
    {

    }
};
class Tuo:public Anim{
public:
    Tuo(char *name):Anim(name)
    {

    }
};
class YangTuo:public Yang, public Tuo{
public:
    YangTuo(char *name01, char *name02):Yang(name01),Tuo(name02)
    {

    }
};
int main(int argc, char *argv[])
{
    YangTuo yt("tom", "jerry");
    cout << yt.Yang::name << endl;  //tom
    cout << yt.Tuo::name << endl;   //jerry
    
    cout << &(yt.Yang::name) << endl;   //0x61fe2c
    cout << &(yt.Tuo::name) << endl;    //0x61fe5e

    return 0;
}

菱形继承类布局：

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

在这里插入图片描述

10. 虚继承

概念：使用 virtual修饰继承关系

语法：

class 子类名:virtual 继承关系 父类名
{

};

解决问题：

解决菱形继承的调用二义性，多个类只保存一份相同数据

如:

  • A类中提供num成员变量
  • A1与A2类属于A的子类，那么A1与A2类将各自拥有一份num
  • B作为A1与A2的子类，那么B将拥有两个num，此时调用num会出现二义性
  • 所以只能虚继承使其存储一个num.

示例：

#include <iostream>
#include <cstring>
using namespace std;
class Anim{
public:
    char name[50];
    Anim(char *name)
    {
        strcpy(this->name, name);
    }
};
class Yang:virtual public Anim{
public:
    Yang(char *name):Anim(name)
    {

    }
};
class Tuo:virtual public Anim{
public:
    Tuo(char *name):Anim(name)
    {

    }
};
class YangTuo:public Yang, public Tuo{
public:
    YangTuo(char *name01, char *name02):Anim(name01),Yang(name01),Tuo(name02)
    {

    }
};

int main(int argc, char *argv[])
{
    YangTuo yt("tom", "jerry");
    cout << yt.Yang::name << endl;  //tom
    cout << yt.Tuo::name << endl;   //tom

    cout << &(yt.Yang::name) << endl;   //0x61fe5c
    cout << &(yt.Tuo::name) << endl;    //0x61fe5c
    return 0;
}

虚继承类布局：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

小玖工作坊
关注
  • 24
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 面向对象 - 类的继承与派生
Junds0的博客
04-14 2380
第1关：公有继承 —— 学生信息类 本关任务：采用公有继承设计学生信息类。 #include "people.h" // People 类定义在这里面 #include <string> #include <iostream> using namespace std; /********** Begin **********/ //公有继承 People class Student:public People { public: void PrintSID();
【C++】类和对象-继承
debug...
07-18 986
C++三大特性之继承
[C++核心编程-04]----C++类和对象之封装
一伦明悦的博客
05-08 1040
在C++中，类和对象是面向对象编程的基本概念，是实现封装、继承和多态的重要手段。（1）类a、类是用户定义的数据类型，用来描述对象的属性和行为。通过类可以封装数据和方法，定义了对象的状态和行为。b、类的成员包括数据成员和成员函数，数据成员用来描述对象的属性，成员函数用来描述对象的行为。类的成员可以设置为私有(private)、公有(public)或保护(protected)。
c++类和对象---继承
m0_50046535的博客
04-15 641
继承是面向对象三大特性之一 1、继承的基本语法 语法： class 子类名 ：继承方式 父类名 子类 也叫 派生类 父类 也叫 基类 class basepage { public: void header() { cout << "首页，公开课、登录、注册..." << endl; } void footer() { cout << "帮助、交流、地图..." << endl; } void left() { cou
6.5 类与对象 【C++】 ----继承
dylan的博客
01-26 157
新建一个类Employee ——》 基类：输入Person 引言：①一个类Employee它首先是个人（即基于类Person）； ②main.cpp只需要包含头文件"Employ.h" ，不需要包含 “Person.h” （因为在Employ.h已经引用了Person.h） 完善信息： 【这里懒得到Employee.cpp里定义函数，直接在.h里定义函数了】 下面这个： Emp...
C++实验一-类与简单对象.doc
11-15
7. 面向对象程序设计的基本思想、基本方法和基本步骤：面向对象程序设计是基于对象和类的程序设计思想，强调模块化、抽象化和继承性。 8. MS Visual C++6.0 或 DEV C++调试 C++程序的基本方法、基本步骤：调试 C++...
C++程序设计基础课件第-讲类和对象完美版资料.ppt
11-14
本资源摘要信息涵盖了C++程序设计基础课件第-讲类和对象的主要内容，包括类的定义、对象的定义、对象的初始化、成员函数的特性、静态成员、友元、局部类和嵌套类等知识点。 类的定义是C++程序设计中的基本概念之一...
C++类与对象-继承（详细讲解）
03-24
C++类与对象-继承（详细讲解）
完整word版-《C++面向对象程序设计》期末考试试题.doc
11-24
8. 唯有类 A 的友元函数、友元类中的非静态成员函数和类 A 中的非静态成员函数可以访问类 A 的私有成员。 9. 对于类 A 的一个对象 a,执行语句 a.f(100); 成功，那么 f 的函数原型可以是 A& f( int, int=50 )。 10....
Dev-C++编译程序器
07-31
C++既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。 C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计...
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1010
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 145
BCSP-X 11题 C++代码详解
【c++进阶(三)】STL之vector的介绍和使用
最新发布
weixin_62196764的博客
06-15 693
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 753
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 324
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 292
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
C语言：详解gcc驱动程序完成编译、汇编、链接的过程
前进，才知道自己的渺小
06-06 1564
gcc是一个命令，严格意义上说，它只是一个驱动程序，而不是一个编译器。gcc负责调用GNU工具链中的预处理器、编译器、汇编器、链接器等工具，通过传递不同的选项给gcc命令，可以让其只完成某些步骤，比如下面的命令，用于只对源文件进行预处理。
【C++】 基础复习 ｜ 数据类型，输入，输出流 scanf printf
专注于人工智能的算法与应用
06-11 827
是 C 语言中两个非常重要的标准输入输出函数，它们分别用于从标准输入（通常是键盘）读取数据和向标准输出（通常是屏幕）打印数据。在这种情况下如果想控制输出，即满足一定格式输出，比如保留几位小数什么的，就要用manipulator了。需要变量的地址 ，即前面需要加一个&。函数用于从标准输入读取数据，并根据格式字符串解析这些数据。存储内存地址的变量。用户定义的复合数据类型，用于将不同类型的数据组合在一起。称做流式输入输出，
深度搜索算法3（c++）
mmz1207的博客
06-08 387
农夫约翰总是想要一个农场的地图，所以他拍摄了一张N行M列的卫星照片。一部分的照片看起来像这样： 他认为每个联通块都是一个谷仓或一头奶牛。农夫约翰认为一个联通块是谷仓，当且仅当它是一个完整的矩形，否则该联通块是一头奶牛。在下面的照片中，有三个谷仓（大小分别为2x1,2x5和1x1）和两头奶牛。计算他的卫星照片中谷仓和奶牛的数量。行2..N + 1：行i + 1表示照片的行i包含M个字 符（且不含空格）。行1：两个空格分隔的整数：N和M。行1：照片中的谷仓数量。行2：照片中的奶牛数量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值