类和对象-继承

已于 2024-03-12 20:35:28 修改
阅读量726 收藏 5
点赞数 15
分类专栏： 编程语言 文章标签： c++
于 2024-03-09 20:48:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/axzy5863/article/details/136571919
版权

师从黑马程序员

基本语法

有些类与类之间存在特殊的关系，例如：

定义这些类时，下一级别的成员除了拥有上一级的共性，还有自己的特性。

这时候我们就可以考虑继承技术，减少重复代码

语法：class 子类：继承方式  父类

子类也称为派生类          父类也称为 基类

#include <iostream>
#include <string>
using namespace std;

/*
//普通实现页面

//Java页面
class Java
{
public:
    void header()
    {
        cout<<"首页、公开课、登录、注册...（公共头部）"<<endl;

    }
    void footer()
    {
        cout<<"帮助中心、交流合作、站内地图..."<<endl;
    }
    void left()
    {
        cout<<"Java\Python、C++...(公共分类列表)"<<endl;

    }
    void content()
    {
        cout<<"Java学科视频"<<endl;
    }
};
//Pythin页面
class Python
{
public:
    void header()
    {
        cout<<"首页、公开课、登录、注册...（公共头部）"<<endl;

    }
    void footer()
    {
        cout<<"帮助中心、交流合作、站内地图..."<<endl;
    }
    void left()
    {
        cout<<"Java\Python、C++...(公共分类列表)"<<endl;

    }
    void content()
    {
        cout<<"Python学科视频"<<endl;
    }
};

//C++页面
class Cpp
{
public:
    void header()
    {
        cout<<"首页、公开课、登录、注册...（公共头部）"<<endl;

    }
    void footer()
    {
        cout<<"帮助中心、交流合作、站内地图..."<<endl;
    }
    void left()
    {
        cout<<"Java\Python、C++...(公共分类列表)"<<endl;

    }
    void content()
    {
        cout<<"C++学科视频"<<endl;
    }
};

*/

//继承页面

//公用页面
class BasePage
{
public:
    void header()
    {
        cout<<"首页、公开课、登录、注册...（公共头部）"<<endl;

    }
    void footer()
    {
        cout<<"帮助中心、交流合作、站内地图..."<<endl;
    }
    void left()
    {
        cout<<"Java\Python、C++...(公共分类列表)"<<endl;

    }

};

//Java页面
class Java:public BasePage
{
public:
    void content()
    {
        cout<<"Java 学科视频"<<endl;
    }
};
//Python页面
class Python:public BasePage
{
public:
    void content()
    {
        cout<<"Python 学科视频"<<endl;
    }
};
//C++页面
class Cpp:public BasePage
{
public:
    void content()
    {
        cout<<"C++ 学科视频"<<endl;
    }
};
void test01()
{
    cout<<"Java下载视频页面如下："<<endl;
    Java ja;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();

    cout<<"--------------------"<<endl;
     cout<<"Java下载视频页面如下："<<endl;
    Python py;
    py.header();
    py.footer();
    py.left();
    py.content();

    cout<<"--------------------"<<endl;
     cout<<"C++下载视频页面如下："<<endl;
    Cpp cpp;
    cpp.header();
    cpp.footer();
    cpp.left();
    cpp.content();


}

int main()
{
    test01();

    system("pause");
    return 0;
}

继承方式

公共继承              保护继承            私有继承

#include <iostream>
#include <string>
using namespace std;

//公共继承
class Base1
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};


class Son1:public Base1
{
public:
    
    void func()
    {
        m_A=10;//父类中的公共权限成员 到子类中依然是公共权限
        m_B=10;//父类中的保护权限成员 到子类中依然是保护权限
       // m_C=10;//父类中的私有权限成员 子类访问不到
    }
};

void test01()
{
    Son1 s1;
    s1.m_A=100;
    //s1.m_B=100;//到了son1中m_B是保护权限 类外访问不到
}

//保护继承
class Base2
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son2:public Base2
{
public:
    
    void func()
    {
        m_A=10;//父类中的公共权限成员 到子类中依然是保护权限
        m_B=10;//父类中的保护权限成员 到子类中依然是保护权限
       // m_C=10;//父类中的私有权限成员 子类访问不到
    }
};

void test02()
{
    Son2 s1;
    //s1.m_A=1000;//在Son2中 m_A变为保护权限 类外访问不到
    //s1.m_B=1000;//到了son1中m_B是保护权限 不可以访问
}

//私有继承
class Base3
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};


class Son3:public Base3
{
public:
    
    void func()
    {
        m_A=100;//父类中的公共权限成员 到子类中是私有权限
        m_B=100;//父类中的保护权限成员 到子类中是私有权限
       // m_C=100;//父类中的私有权限成员 子类访问不到
    }
};

class GrandSon3:public Son3
{
public:
    void func()
    {
        //m_A=1000;//到了Son3中 m_A变为私有，即使是儿子，也是访问不到
        //m_B=1000;//到了Son3中 m_B变为私有，即使是儿子，也是访问不到
        
    }
};

void test03()
{
    Son2 s1;
    //s1.m_A=1000;//在Son2中 m_A变为保护权限 类外访问不到
    //s1.m_B=1000;//到了son1中m_B是保护权限 不可以访问
}

void test03()
{
    Son3 s1;
    //s1.m_A=1000;//到了Son3中 m_A变为私有，即使是儿子，也是访问不到
    //s1.m_B=1000;//到了Son3中 m_B变为私有，即使是儿子，也是访问不到
        
}

int main()
{
    test01();

    system("pause");
    return 0;
}

继承中的对象模型

开发人员命令提示工具查看对象模型的方法

1、跳转盘符     例：跳转F盘  则打出  F:

2、跳转文件路径 cd 具体路径下

3、查看命名   打出dir

4、 cl /d1 reportSingleClassLayout类名 文件名

#include <iostream>
#include <string>
using namespace std;

//公共继承
class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};


class Son:public Base
{
public:

    int m_D;
};




void test01()
{
    //父类中所有非静态成员属性都会被子类继承下去
    //父类中私有成员属性 是被编译器给隐藏了，因此是访问不到，但确实被继承下去了
  cout<<"size of Son="<<sizeof(Son)<<endl;//16
}



int main()
{
    test01();

    system("pause");
    return 0;
}

继承中构造和析构顺序

子类继承父类后，当创建 子类对象，也会调用父类的构造函数

#include <iostream>
#include <string>
using namespace std;


class Base
{
public:
    Base()
    {
        cout<<"Base构造函数！"<<endl;
    }
    ~Base()
    {
        cout<<"Base析构函数！"<<endl;
    }

};


class Son:public Base
{
public:
    Son()
    {
        cout<<"Son构造函数！"<<endl;
    }
    ~Son()
    {
        cout<<"Son析构函数！"<<endl;
    }

};




void test01()
{
    //Base b;
    //继承中的构造和析构顺序如下：
    //先构造父类，再构造子类，析构的顺序与构造的顺序相反
    Son s;
}



int main()
{
    test01();

    system("pause");
    return 0;
}

继承同名成员处理方式

访问子类同名成员  直接访问即可

访问父类同名成员 需要加作用域

#include <iostream>
#include <string>
using namespace std;


class Base
{
public:
    Base()
    {
        m_A=100;
    }

    void func()
    {
        cout<<"Base -func()调用"<<endl;
    }
     void func(int a)
    {
        cout<<"Base -func(int)调用"<<endl;
    }

    int m_A;

};


class Son:public Base
{
public:
    Son()
    {
        m_A=200;
    }
    void func()
    {
        cout<<"Son -func()调用"<<endl;
    }


    int m_A;
};

//同名成员属性处理
void test01()
{
    Son s;
    cout<<"Son下 m_A= "<<s.m_A<<endl;//200
    //如果通过子类对象 访问到父类中同名成员，需要加作用域
    cout<<"Base下 m_A= "<<s.Base::m_A<<endl;//100

}

//同名成员函数处理
void test02()
{
    Son s;

    s.func();//直接调用 调用是子类中的同名成员

    s.Base::func();//调用是父类中的同名成员

    //如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
    //s.func(100);wrong
    //如果想访问到父类中被隐藏的同名成员函数，需要加作用域
    s.Base::func(100);
}




int main()
{
    //test01();

    test02();

    system("pause");
    return 0;
}

继承同名静态成员处理方式

静态成员和非静态成员出现同名，处理方式一致

访问子类同名成员  直接访问即可

访问父类同名成员 需要加作用域

#include <iostream>
#include <string>
using namespace std;

class Base
{
public:
    static int m_A;
    
    static void func()
    {
        cout<<"Base -static void func()"<<endl;
    }
    
    static void func(int a)
    {
        cout<<"Base -static void func()"<<endl;
    }
};

int Base::m_A = 100;

class Son : public Base
{
public:
    static int m_A;
    
    static void func()
    {
        cout<<"Son -static void func()"<<endl;
    }
};

int Son::m_A = 200;

// 同名静态成员属性
void test01()
{
    //1、通过对象访问
    cout<<"通过对象访问"<<endl;
    Son s;
    cout << "Son 下m_A=" << s.Son::m_A << endl; // 访问 Son 类的静态变量
    cout << "Base 下m_A=" << s.Base::m_A << endl; // 访问 Base 类的静态变量
    
    //2、通过类名访问
    cout<<"通过类名访问"<<endl;
    cout<<"Son 下m_A ="<<Son::m_A<<endl;
    //第一个::代表通过类名各方式访问  第二个::代表访问父类作用域下
    cout<<"Base 下m_A ="<<Son::Base::m_A<<endl;
    
    
}

//同名静态成员函数
void test02()
{
    //1、通过对象访问
    Son s;
    s.func();
    s.Base::func();
    
    //2、通过类名访问
    cout<<"通过类名访问"<<endl;
    Son::func();
    Son::Base::func();
    
    //子类出现和父类同名静态函数，也会隐藏父类中所有同名成员函数
    //如果想访问父类中被隐藏同名成员，需要加作用域
    Son::Base::func(100);
}


int main()
{
    test01();

    system("pause");
    return 0;
}

多继承语法

语法：class 子类：继承方式  父类1，继承方式  父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

#include <iostream>
#include <string>
using namespace std;

class Base1
{
public:
    Base1()
    {
        m_A=100;
    }

    int m_A;
};

class Base2
{
public:
    Base2()
    {
        m_A=200;
    }

    int m_A;
};


//子类 需要继承Base1和Base2
class Son : public Base1,public Base2
{
public:
    Son()
    {
        m_C=300;
        m_D=400;
    }

    int m_C;
    int m_D;

};


void test01()
{
    Son s;

    cout<<"sizeof  Son ="<<sizeof(s)<<endl;
    //当父类中出现同名成员，需要加作用域区分
    cout<<"Base1::m_A= "<<s.Base1::m_A<<endl;
    cout<<"Base2::m_A= "<<s.Base2::m_A<<endl;
    
}


int main()
{
    test01();

    system("pause");
    return 0;
}

菱形继承（钻石继承）

概念：

两个派生类继承同一个基类

又有某个类同时继承两个派生类

#include <iostream>
#include <string>
using namespace std;

//动物类

class Animal
{
public:

    int m_Age;

};

//利用虚继承 解决菱形继承的问题
//继承之前 加上关键字 virtual 变为虚继承
//Animal类称为 虚基类
//羊类
class Sheep:virtual public Animal {};

//驼类
class Tuo:virtual public Animal{};

//羊驼类
class SheepTuo :public Sheep,public Tuo{};


void test01()
{
    SheepTuo st;

    st.Sheep::m_Age=18;
    st.Tuo::m_Age=28;

    //当菱形继承，两个父类拥有相同数据，需要加以作用域区分
    cout<<"st.Sheep::m_Age ="<<st.Sheep::m_Age<<endl;
    cout<<"st.Tuo::m_Age ="<<st.Tuo::m_Age<<endl;
    cout<<"st.m_Age="<<st.m_Age<<endl;

    //这份数据我们知道 只要有一份就可以，菱形继承导致数据有两份，资源浪费

}

int main()
{
    test01();

    system("pause");
    return 0;
}

若有侵权，请联系作者

乘～风
关注
  • 15
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++面向对象 - 继承与派生的应用
Junds0的博客
10-27 3454
声明一个基类 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++ 学习（13）类和对象 - 继承、继承方式、对象模型、构造与析构顺序、继承同名成员、多继承、菱形继承
ling1998的博客
07-26 3077
本章主要学习继承，包含继承基本语法、继承方式（公有继承、保护继承、私有继承）、对象模型（命令 cl /dl reportSingleClassLayoutXXX）、构造函数与析构函数顺序、继承同名成员（非静态成员、静态成员）、多继承、菱形继承（解决菱形问题：虚基类virtual）......
【P127 45】C++ 类和对象-继承快速入门（超详细）
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
05-15 7000
C++ 类和对象-继承一、继承基本语法1.先用普通方式实现页面2.继承方式实现页面二、继承方式三、继承中的对象模型 一、继承基本语法 继承是面向对象三大特性之一 （封装、继承、多态） 有些类与类之间存在特殊的关系，例如下图中: 我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。 这个时候我们就可以考虑利用继承的技术，减少重复代码 以黑马程序员官网为例，可以看到： 网页的头部、左侧、底部内容都是一样的公共信息，只有中的内容不一样 我们要想描述页面内容，可以用继承思想 1.先用
面向对象--继承
简之恨寒的博客
08-08 2373
继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。...
jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
qq_43427314的博客
11-02 5853
jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company PTA题目分析答案不判断null的代码（非标准）判断null的代码（标准） 题目 分析 答案 发现可以不判断输入字符串null也可以编译通过 不判断null的代码（非标准） import java.text.DecimalFormat; import java.util.ArrayList; import java.util.Collections; import java.util.L
lua面向对象-----继承的实现
soldier_d的博客
03-09 3209
前言 在lua里是没有类的概念的，但是可以利用表（table）和元表特性来实现面向对象和继承。lua的表类似于一个对象，每个对象都有自己的方法和属性。当访问一个表中不存在的属性时，系统不会直接返回错误，而是访问该表的元表中的 __index 元方法。 __index 元方法既可以是一个方法，也可以是一张表，当 __index 为表时，从 __index 指示的表中查询不存在的属性，当 __index 为方法时，访问不存在的属性会触发调用此方法。 示例 利用这一特性，继承可以如下来实现： local bas
jmu-Java-03面向对象基础-04-形状-继承 PTA
qq_43427314的博客
10-31 3130
jmu-Java-03面向对象基础-04-形状-继承 PTA题目本题描述：思考分析答案 题目 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 1.定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() 2.Rectangle与Circle类均继承自Shape类。 Rectangle类
类与类的关系---继承
m0_65300193的博客
12-23 1930
类与类的关系有以下几种： A is-a B 继承、实现===>统称泛化 A has-a B 组合、聚合、关联===>统称包含 A use-a B 依赖（need） 继承： 子类、父类 1.子类继承父类，通过关键字“extends”； 2.子类的对象可以调用父类的（public、protected）属性和方法，当作自己的去使用，增强了复用性； 3.子类可以添加自己独有的方法和属性； 4.子类从父类继承来的方法不能满足子类的要求，可以在子类中重写（覆盖）父类的...
jmu-Java-03面向对象基础-04-形状-继承
黑白的黒's Blog
10-01 2770
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性： 不可变静态常量double PI，值为3.14， 抽象方法: public double getPerimeter(),public double getArea() Rectangle与Circle类均继承自Shape类。 Rectangle类(属性： int width,length)、Circle类(属性： int radius
C++面向对象 - 继承、派生和多态
念去去
07-26 5459
公有继承 —— 学生信息类 任务描述 本关任务：采用公有继承设计学生信息类。 相关知识 继承 继承是使代码可以复用的重要手段，也是面向对象程序设计的核心思想之一。简单的说，继承是指一个对象直接使用另一对象的属性和方法。 C++ 中的继承关系就好比现实生活中的父子关系，继承一笔财产比白手起家要容易得多，原始类称为基类，继承类称为派生类，基类是对派生类的抽象，派生类是对基类的具体化。它们是类似于父亲和儿子的关系，所以也分别叫父类和子类。而子类又可以当成父类，被另外的类继承。 继承方式 不同的继承方式决定了基类成
C++类与对象-继承（详细讲解）
03-24
C++类与对象-继承（详细讲解）
php面向对象-继承
02-02
PHP类的继承 什么是继承 ...私有变量和方法不被继承 访问控制 Private的访问权限 protected的访问权限 public的访问权限 重写（override） 重写方法与访问权限 重写时的参数数量 构造函数重写
简述 Python 的类和对象
12-17
Python这门语言是无处不对象，如果你曾浅要了解过Python，你应该听过Python是一种面向对象编程的语言，所以你经常可能会看到面向“对象”编程这类段子，而面向对象编程的语言都会有三大特征：封装、继承、多态。...
Java类和对象之间的差
12-22
java类和对象之间的差别是一个普遍的问题，刚开始学习java当它来到与类和对象接触。来总结一下它们之间的差异。 　先说说class和object差异。事实上，词：object是全部class的父类，全部class类都默认继承object。 ...
C++ 使用matplot++ 处理数据生成svg图表
最新发布
小蝈蝈的博客
05-13 158
python的图表库很丰富，C++依赖于python的 matplotlib的库却有很多功能不足，显得很鸡肋，其他的一些库没有过多的研究，Matplot++编译需要依赖一堆第三方库，可以参考官网，但是github上也提供了编译好的静态库，使用Matplot++同时需要下载安装gnuplot，并将gnuplot的bin加入到环境变量。将include、lib加入到对应的位置，并配置好路径和库连接，这部分不多说了。这里主要说说不依赖于python的纯C++ 的图表库 Matplot++
Linux学习C语言版 LED 灯实验
qq_44219883的博客
05-10 651
大部分情况下都是使用 C 语言去编写的。只是在开始部分用汇编来初始化一下 C 语言环境，比如初始化 DDR、设置堆栈指针 SP 等等，当这些工作都做完以后就可以进入 C 语言环境，也就是运行 C 语言代码，一般都是进入 main 函数。所以我们有两部分文件要做：①、汇编文件汇编文件只是用来完成 C 语言环境搭建。②、C 语言文件C 语言文件就是完成我们的业务层代码的，其实就是我们实际例程要完成的功能。
UE5C++ FString做为参数取值时报错error：C4840
YanisWu的博客
05-11 176
UE5 C++ 的FString类型取值问题。
多线程测试+互斥锁（1）【C++】
weixin_45690131的博客
05-10 232
多线程测试
C++ 面向对象 - 类的继承与派生
07-29
C++中的类继承和派生是面向对象编程中的重要概念。在C++中，可以使用公有继承、保护继承和私有继承来实现类的继承和派生。 公有继承是最常见的一种继承方式，它可以使得基类的公有成员在派生类中仍然是公有的，保护...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

乘～风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值