C++面向对象--------继承篇

于 2024-10-11 19:40:45 发布
阅读量347 收藏 5
点赞数 13
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64136247/article/details/142861523
版权

目录

一.继承（重点）

1.1 概念

1.2 构造函数

1.2.1 派生类与基类的构造函数关系

1.2.2 解决方案

1.2.2.1 补充基类的无参构造函数

1.2.2.2 手动在派生类中调用基类构造函数

1.2.2.2.1 透传构造

1.2.2.2.2 委托构造

1.2.2.2.3 继承构造

1.3 对象的创建与销毁流程（掌握）

1.4 多重继承（掌握）

1.4.1 概念

1.4.2 可能出现的问题

1.4.2.1 问题1-重名问题（掌握）

1.4.2.2 问题2-菱形继承（熟悉）

二.权限

2.1 公有继承

2.2 保护继承

2.3 私有继承

一.继承（重点）

1.1 概念

继承是面向对象的三大特性之一，主要体现了代码复用的思想。

继承就是在一个已存在的类的基础上，建立一个新的类。并拥有其特性。

● 已存在的类被称为“基类”或者“父类”

● 新建立的类被称为“派生类”或者“子类”

#include <iostream>

using namespace std;

// 基类
class Father
{
private:
    string name = "孙";
public:
    void set_name(string name)
    {
        this->name = name;
    }

    string get_name()
    {
        return name;
    }

    void work()
    {
        cout << "我的工作是厨师，我负责炒菜" << endl;
    }
};

// 派生类
class Son:public Father // public:继承权限，基类的所有权限，在派生类中保持不变
{

};

int main()
{
    Son son;
    cout << son.get_name() << endl;

    son.work();
    return 0;
}
上面的代码，Son类的功能几乎与Father类重叠。在实际的开发使用过程中，派生类会做出一些与基类的差异化。

● 修改继承来的基类内容

○ 属性：1、公有属性可以直接改。更改后基类的属性也会改变，因为改的是同一份变量。私有属性，需要使用基类的公有函数进行更改。

○ 函数：函数隐藏，通过派生类实现一个同名同参数的函数，来隐藏基类的函数。

● 新增派生类的内容

#include <iostream>

using namespace std;

// 基类
class Father
{
private:
    string name = "孙";
public:
    void set_name(string name)
    {
        this->name = name;
    }

    string get_name()
    {
        return name;
    }

    void work()
    {
        cout << "我的工作是厨师，我负责炒菜" << endl;
    }
};

// 派生类
class Son:public Father // public:继承权限，基类的所有权限，在派生类中保持不变
{
public:
    void init()
    {
//        name = "王"; // 错误 基类的私有属性，派生类无法直接访问
        set_name("王");
    }

    void work()
    {
        cout << "我是程序猿，我在打代码" << endl;
    }

    void game()
    {
        cout << "我不光干活，我还打游戏，原神启动。杂交版启动" << endl;
    }
};


int main()
{
    Son son;
    son.init();
    cout << son.get_name() << endl; // 王

    son.work(); // 我是程序猿，我在打代码
    son.game(); // 我不光干活，我还打游戏，原神启动。杂交版启动

    son.Father::work(); // 调用基类被隐藏的成员函数

    return 0;
}

基类与派生类是相对的，一个类可能存在又是基类又是派生类的情况，取决于那两个类进行比较。

1.2 构造函数

1.2.1 派生类与基类的构造函数关系

构造函数与析构函数不能被继承。

#include <iostream>

using namespace std;

// 基类
class Father
{
private:
    string name = "孙";
public:
    // 有参构造函数
    Father(string name):name(name){}

    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
public:

};

int main()
{
//    Son s; // 找不到基类的无参构造函数
    Son s("张"); // 没有匹配的构造函数

    return 0;
}

1.2.2 解决方案

1.2.2.1 补充基类的无参构造函数
#include <iostream>

using namespace std;

// 基类
class Father
{
private:
    string name = "孙";
public:
    // 补充基类无参构造函数
    Father()
    {
        cout << "构造函数被调用了" << endl;
    }
    // 有参构造函数
    Father(string name):name(name){}

    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
public:
    // 编译器自动添加的构造函数
    Son():Father()
    {
        cout << "派生类构造函数被调用了" << endl;
    }

};

int main()
{
    Son s; // 找不到基类的无参构造函数
//    Son s("张"); // 没有匹配的构造函数

    return 0;
}
1.2.2.2 手动在派生类中调用基类构造函数
1.2.2.2.1 透传构造

在派生类的构造函数中，调用基类的构造函数，实际上编译器自动添加的构造函数，调用基类无参构造函数时，采用的就是这种方式。

#include <iostream>

using namespace std;

// 基类
class Father
{
private:
    string name = "孙";
public:
    // 有参构造函数
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
public:
    // 透传构造
    Son():Father("张"){}

    // 派生类有参构造函数，调用基类有参构造函数
    Son(string fn):Father(fn){}
};

int main()
{
    Son s;
    cout << s.get_name() << endl;

    Son s1("王");
    cout << s1.get_name() << endl;

    return 0;
}
1.2.2.2.2 委托构造

一个类的构造函数可以调用这个类的另一个构造函数，但是要避免循环委托。

委托构造的性能要低于透传构造，但是代码的维护性“更好”。因为通常一个类中构造函数都会委托给能力最强（参数最多）的构造函数，在代码重构时，只需要更改这个能力最强的构造函数即可。

#include <iostream>

using namespace std;

// 基类
class Father
{
private:
    string name = "孙";
public:
    // 有参构造函数
    
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
public:
    // 委托构造
    Son():Son("张"){}

    // 派生类有参构造函数，调用基类有参构造函数
    Son(string fn):Father(fn){}
};

int main()
{
    Son s;
    cout << s.get_name() << endl;

//    Son s1("王");
//    cout << s1.get_name() << endl;

    return 0;
}
1.2.2.2.3 继承构造

C++11 新增的写法，只需要一句话，就可以自动给派生类添加n（n为基类构造函数的个数（不包含默认无参构造函数））个构造函数。并且每个派生类的构造函数的格式都与基类相同，每个派生类的构造函数都通过透传构造调用对应格式的基类构造函数。

#include <iostream>

using namespace std;

// 基类
class Father
{
private:
    string name = "孙";
public:
    Father():Father("张"){}
    // 有参构造函数
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
public:
    using Father::Father;
//    // 委托构造
//    Son():Son(){}

//    // 派生类有参构造函数，调用基类有参构造函数
   // Son(string fn):Father(fn){}
};

int main()
{
    Son s;
    cout << s.get_name() << endl;

//    Son s1("王");
//    cout << s1.get_name() << endl;

    return 0;
}

1.3 对象的创建与销毁流程（掌握）

在继承中，构造函数与析构函数的调用顺序

#include <iostream>

using namespace std;
class Value
{
private:
    string str;
public:
    Value(string str):str(str)
    {
        cout << str << "构造函数" << endl;
    }

    ~Value()
    {
        cout << str <<"析构函数" << endl;
    }
};


class Father
{
public:
    static Value s_value;
    Value val = Value("Father成员变量");

    Father()
    {
        cout << "Father 构造函数被调用了" << endl;
    }

    ~Father()
    {
        cout << "Father 析构函数被调用了" << endl;
    }
};

Value Father::s_value = Value("静态FatherValue被创建了");


class Son:public Father
{
public:
    static Value s_value;
    Value val = Value("Son成员变量");   // int i = int(10);
    Son()
    {
        cout << "Son 构造函数被调用了" << endl;
    }

    ~Son()
    {
        cout << "Son 析构函数被调用了" << endl;
    }
};

Value Son::s_value = Value("静态SonValue被创建了");

int main()
{
    cout << "主函数开始执行" << endl;
    {   // 局部代码块
        Son s;
        cout << "对象执行中" << endl;
    }
    cout << "主函数结束了" << endl;
    return 0;
}

上面的执行结果中，得到那些规律？

● 以对象执行中 为轴，上下对称。

● 在创建的过程中，同类型的内存区域，基类先开辟。对象创建：（先基类后派生类）。对象销毁（先派生类，后基类）。

● 静态的创建早于非静态。

1.4 多重继承（掌握）

1.4.1 概念

C++支持多重继承，即一个派生类可以有多个基类。派生类对于每个基类的关系仍然可以看作是一个单继承。

#include <iostream>

using namespace std;


class Sofa
{
public:
    void sit()
    {
        cout << "沙发可以坐着" << endl;
    }
};

class Bed
{
public:
    void lay()
    {
        cout << "床可以躺着" << endl;
    }
};

// 多重继承
class SofaBed :public Sofa,public Bed
{
public:
};


int main()
{
    SofaBed sb;
    sb.lay();
    sb.sit();
    return 0;
}

1.4.2 可能出现的问题

1.4.2.1 问题1-重名问题（掌握）

当多个基类具有重名成员时，编译器在编译的过程中会出现二义性的问题。

解决方式：使用基类的类名::方式调用。

#include <iostream>

using namespace std;


class Sofa
{
public:
    void sit()
    {
        cout << "沙发可以坐着" << endl;
    }

    void clean()
    {
        cout << "打扫沙发" << endl;
    }
};

class Bed
{
public:
    void lay()
    {
        cout << "床可以躺着" << endl;
    }

    void clean()
    {
        cout << "打扫床" << endl;
    }
};

// 多重继承
class SofaBed :public Sofa,public Bed
{
public:
};


int main()
{
    SofaBed sb;
    sb.lay();
    sb.sit();
    sb.Sofa::clean();
    sb.Bed::clean();
    return 0;
}
1.4.2.2 问题2-菱形继承（熟悉）

当一个基类有多个派生类，且这些派生类又有一个共同基类时。就会出现二义性问题，这种继承方式称为菱形（钻石）继承。

有两种解决方式：

1、使用基类的类名::方式调用

#include <iostream>

using namespace std;

// 家具厂
class Furniture
{
public:
    void func()
    {
        cout << "家具厂里有家具" << endl;
    }
};

class Sofa:public Furniture
{
public:

};

class Bed:public Furniture
{
public:

};

// 多重继承
class SofaBed :public Sofa,public Bed
{
public:
};


int main()
{
    SofaBed sb;
    sb.Bed::func();
    sb.Sofa::func();

    return 0;
}
2、使用虚继承（熟悉）

当出现虚继承时，Furniture类会生成一张虚基类表。这个表并不会占用任何对象的存储空间，属于Furniture类持有，在程序启动时加载进内存，表中记录了Furniture函数的调用地址偏移量。

Bed和Sofa对象会出现一个隐藏的成员变量指针，指向Furniture类中的虚基类表，占用对象四个字节。

SofaBed继承Sofa和Bed时，SofaBed类对象会同时拥有两个虚基类表指针成员，在调用时通过查表解决二义性。

#include <iostream>

using namespace std;

// 家具厂
class Furniture
{
public:
    void func()
    {
        cout << "家具厂里有家具" << endl;
    }
};

class Sofa:virtual public Furniture
{
public:

};

class Bed:virtual public Furniture
{
public:

};

// 多重继承
class SofaBed :public Sofa,public Bed
{
public:
};


int main()
{

    SofaBed sb;
    sb.func();


    return 0;
}

二.权限

类内

派生类中

全局

private

√

×

×

protected

√

√

×

public

√

√

√

2.1 公有继承

上面的代码中一直使用的就是公有继承，公有继承也是使用最多的一种继承方式。

在公有继承中，派生类可以继承基类的成员，但是不可以访问基类的私有成员，基类的公有成员与保护成员在派生类中权限不变。

2.2 保护继承

在保护继承中，派生类可以继承基类的成员，不可以访问基类的私有成员，基类的公有成员与保护成员在派生类中都是保护权限。（只能在基类和派生类中访问，外部无法访问）。

2.3 私有继承

在私有继承中，派生类可以继承基类的成员，但是不可以访问基类的私有成员，基类的公有成员与保护成员在派生类中权限都是私有权限。

#include <iostream>

using namespace std;


class Base
{
private:
    string str1 = "私有成员";
protected:
    string str2 = "保护成员";
public:
    string str3 = "公有成员";
};

class Son:private Base
{
public:
    Son()
    {
//        cout << str1 << endl; // 错误str1为私有成员，派生类中无法访问
        cout << str2 << endl;
        cout << str3 << endl;
    }
};

class Sun:public Son
{
public:
    Sun()
    {
//        cout << str1 << endl; // 错误str1为私有成员，派生类中无法访问
//        cout << str2 << endl; // 错误str2 在Son类中是私有成员，派生类无法访问
//        cout << str3 << endl; // 错误str3 在Son类中是私有成员，派生类无法访问
    }
};

int main()
{
    Sun s1;
//    cout << s1.str1 << endl; // 错误，私有权限类外无法访问
//    cout << s1.str2 << endl; // 错误，私有权限类外无法访问
//    cout << s1.str3 << endl; // 错误，私有权限类外无法访问
    return 0;
}
嵌入式----HR
关注
C++面向对象 - 继承与派生的应用
Junds0的博客
10-27 4050
声明一个基类 Animal，有私有整型成员变量 age，构造其派生类 dog，在其成员函数 SetAge(int n)中直接给 age 赋值，看看会有什么问题，把 age 改为公有成员变量，再在 Dog 类用成员函数 ShowAge() 输出变量 age 的值。创建一个助教实例，姓名为Li Hao，编号为011401，性别为Male，1988年6月1日生，身份证号为12345619880601，职务为TA，部门为CST，班号为cst61，专业为computer science，导师为Liu Ming。
C++面向对象 - 多态性的应用
Junds0的博客
04-06 2374
List 类提供 5 个虚函数，其中有 4 个是纯虚函数，需要用户在子类中实现。这上面的调用显然都是合法的。但是现在要求实现如下效果：第 3 行的函数执行的是适合 ArrayList 输出的代码，而第 4 行执行的是适合 LinkedList 输出的代码。即，虽然调用的函数一样，但需要根据当时的实参类型选择合适的实现。用户需要编写 IList 类，IList 类只提供 5 个纯虚函数，分别是增、删、查、改和显示函数。但是对面向对象的基础而言（对 C++ 而言就是公有继承），重要的是公有函数的继承。
C++ 面向对象 - 类的继承与派生
qq_65628600的博客
06-16 1630
C++ 面向对象 - 类的继承与派生
头歌Educoder实验：C++ 面向对象 - 类的继承与派生
m0_64262556的博客
12-21 3940
在前面的关卡中，我们学习的派生类都只有一个基类，称为单继承。C++ 语言支持一个子类同时继承多个父类，就像单继承时一样，继承多个父类也就相当于同时有了多个父类的公有成员和保护成员，而且可以单独为每一个父类指定继承的方式。多继承访问基类成员大体与单继承一致，但当继承的多个父类中有同名的成员时，要访问其中一个成员就不能简单的只写成员名了，必须使用作用域运算符（，函数按照狼类，人类的顺序调用两个基类的 PrintState 函数，输出他们的成员变量值。如果要继承多个类，只需将父类的类名依次写在子类类名的冒号（
C++面向对象 - 继承、派生和多态
念去去
07-26 5573
公有继承 —— 学生信息类 任务描述 本关任务：采用公有继承设计学生信息类。 相关知识 继承 继承是使代码可以复用的重要手段，也是面向对象程序设计的核心思想之一。简单的说，继承是指一个对象直接使用另一对象的属性和方法。 C++ 中的继承关系就好比现实生活中的父子关系，继承一笔财产比白手起家要容易得多，原始类称为基类，继承类称为派生类，基类是对派生类的抽象，派生类是对基类的具体化。它们是类似于父亲和儿子的关系，所以也分别叫父类和子类。而子类又可以当成父类，被另外的类继承。 继承方式 不同的继承方式决定了基类成
C++面向对象-类继承练习
null1132214759的博客
05-14 2942
假设某销售公司有一般员工，销售员工和销售经理。月工资计算办法：       一般员工月薪=基本工资       销售员工月薪=基本工资+销售额*提成率        销售经理月薪=基本工资+职务工资+销售额提成率       编写程序，定义一个表示基本员工的基类Employee，他包含三个表示员工基本信息的成员： 编号number，姓名name，和基本工资basicSalary。 由
C++面试题-面向对象-面向对象概念
《好好先生》专栏
01-11 2920
C++面试题-面向对象-面向对象概念 问：说说C++和C的主要区别？ 答： C语言属于面向过程语言，通过函数来实现程序功能。而C++是面向对象语言，主要通过类的形式来实现程序功能。 使用C++编写的面向对象应用程序比C语言编写的程序更容易维护、扩展性更强。 C++多用于开发上层应用软件，而C语言代码体积小、执行效率高，多编写系统软件和嵌入式开发。 例如：Windows操作系统、Linux...
lua面向对象-----继承的实现
soldier_d的博客
03-09 3665
前言 在lua里是没有类的概念的，但是可以利用表（table）和元表特性来实现面向对象和继承。lua的表类似于一个对象，每个对象都有自己的方法和属性。当访问一个表中不存在的属性时，系统不会直接返回错误，而是访问该表的元表中的 __index 元方法。 __index 元方法既可以是一个方法，也可以是一张表，当 __index 为表时，从 __index 指示的表中查询不存在的属性，当 __index 为方法时，访问不存在的属性会触发调用此方法。 示例 利用这一特性，继承可以如下来实现： local bas
【C++】---继承
weixin_75128035的博客
05-08 1353
继承机制是面向对象程序设计当中使代码复用的重要手段，它允许程序员，在保持原有类特性的基础上，进行拓展，增加功能，产生新的类，这个新的类就叫做：派生类。继承的出现，呈现出面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们所接触到的复用都是函数的复用，而继承的出现则是体现了：类设计层次的复用。// 基类public:protected:// 派生类：stuprotected:int stu_ID;// 派生类：teaprotected:int job_ID;
头歌C++面向对象 - 类的多态性与虚函数
代码不会敲的博客
06-02 7036
一、实训目的 1.掌握虚函数的基本使用。 2.掌握虚析构函数的使用。 3.掌握纯虚函数和抽象类的使用。二、实训内容 1.人与复读机 设计人类、英语学生类和复读机类三个类。 2.复读机的毁灭 设计三个复读机类并实现一个普通函数。 3.计算图像面积 设计一个矩形类、一个圆形类和一个图形基类，计算并输出相应图形面积。三、实训所实现系统主要功能1.人与复读机 人类（ Chinese ） 它有一个虚函数 greet，函数输出中文问候，即你好。英语学生类（ EnglishLearner ） 继承 Chinese 类，重
C++-面向对象编程-000-面向对象
01-06
目录一、面向对象概述(1)封装(2)继承(3)多态二、面向对象与面向过程编程1.面向过程编程(1)软件重用性差(2)软件可维护性差(3)开发出的软件不能满足用户需要2.面向对象编程3.面向对象的特点(1)代码容易修改(2)代码复用...
2022年陈天华-面向对象程序设计C++第三版-ppt-第一章完整.ppt
11-02
"2022年陈天华-面向对象程序设计C++第三版-ppt-第一章完整.ppt" 本资源是《面向对象程序设计》的第一章ppt课件，主要介绍面向对象程序设计的基本概念、特点、语言和软件开发。通过本章的学习，学生将了解面向对象...
C++面向对象程序设计-学生管理系统
03-11
《C++面向对象程序设计-学生管理系统》 在IT领域，C++是一种强大的编程语言，以其面向对象的特性被广泛应用于系统开发，特别是在构建复杂的、性能要求高的应用中。本项目“学生管理系统”就是利用C++的面向对象编程...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1268
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C++】List
最新发布
m0_46676283的博客
10-08 272
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
（STL）map与set的封装--采用红黑树
2302_80190394的博客
10-04 829
（STL）map与set的封装--采用红黑树
C++之多态篇(超详细版)
2302_79795375的博客
10-04 898
public:cout
C++ | Leetcode C++题解之第463题岛屿的周长
Ddddddd_158的博客
10-08 504
C++ | Leetcode C++题解之第463题岛屿的周长
【STL】queue的模拟实现
gaogo
10-07 246
利用deque实现queue的模拟实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值