C++核心笔记（六）---类和对象（继承）

已于 2024-02-19 00:39:36 修改
阅读量1k 收藏 24
点赞数 30
分类专栏： C++ 文章标签： 笔记 c++ 学习 开发语言
于 2024-02-18 23:55:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_46359434/article/details/136143038
版权

1、继承

继承是面向对象三大特性之一

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

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

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

1.1继承的基本语法

语法：

class 子类:继承方式 父类

子类：也称        派生类

父类：也称        基类 

继承的好处：减少重复代码

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

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

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

普通实现页面：

#include <iostream>
using namespace std;

//普通实现页面
class Java//Java页面
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...(公共头部)" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    }
    void left()
    {
        cout << "Java、Python、C++...(公共分类)" << endl;
    }
    void content()
    {
        cout << "Java学科视频" << endl;
    }
};

class Python//Python页面
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...(公共头部)" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    }
    void left()
    {
        cout << "Java、Python、C++...(公共分类)" << endl;
    }
    void content()
    {
        cout << "Python学科视频" << endl;
    }
};

class CPP//C++页面
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...(公共头部)" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    }
    void left()
    {
        cout << "Java、Python、C++...(公共分类)" << endl;
    }
    void content()
    {
        cout << "C++学科视频" << endl;
    }
};

void test01()
{
    Java ja;
    cout << "Java下载视频页面如下：" << endl;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();

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

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

int main()
{
    test01();

    system("pause");
    return 0;
}

继承实现页面：

#include <iostream>
using namespace std;

//继承实现页面
//公共页面
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()
{
    Java ja;
    cout << "Java下载视频页面如下：" << endl;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();

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

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

int main()
{
    test01();

    system("pause");
    return 0;
}

两者输出结果相同：

Java下载视频页面如下：
首页、公开课、登录、注册...(公共头部)
帮助中心、交流合作、站内地图...(公共底部)
Java、Python、C++...(公共分类)
Java学科视频
------------------------
Python下载视频页面如下：
首页、公开课、登录、注册...(公共头部)
帮助中心、交流合作、站内地图...(公共底部)
Java、Python、C++...(公共分类)
Python学科视频
------------------------
C++下载视频页面如下：
首页、公开课、登录、注册...(公共头部)
帮助中心、交流合作、站内地图...(公共底部)
Java、Python、C++...(公共分类)
C++学科视频
请按任意键继续. . .

1.2继承方式

继承的语法：

class 子类:继承方式 父类

继承方式一共有三种：

        公共继承

        保护继承

        私有继承                                                                                                                                  

#include <iostream>
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 = 100;//父类中的公共权限成员 到子类中依然是公共权限
        m_B = 100;//父类中的保护权限成员 到子类中依然是保护权限
        //m_C = 10;//父类中的私有权限成员 子类访问不到
    }
};

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

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

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

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

class GrandSon3 :public Son3
{
public:
    void func()
    {
        //m_A = 100;//它的父类Son3中m_A已经变为私有权限成员 即使是儿子 也访问不到
        //m_B = 100;//它的父类Son3中m_B已经变为私有权限成员 即使是儿子 也访问不到
    }
};

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

void test02()
{
    Son2 s2;
    //s2.m_A = 100;//在Son2中 m_A变为保护权限 类外访问不到
    //s2.m_B = 100;//在Son2中 m_B是保护权限 类外访问不到
}

void test03()
{
    Son3 s3;
    //s3.m_A = 100;//在Son3中 m_A变为私有权限 类外访问不到
    //s3.m_B = 100;//在Son3中 m_B变为私有权限 类外访问不到
}

int main()
{

    system("pause");
    return 0;
}

输出结果: 无输出结果，主要看注释，体会不同继承方式的影响                                                                          

1.3继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？

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

int main()
{
    test01();

    system("pause");
    return 0;
}

输出结果：

size of Son=16
请按任意键继续. . .

 另一种方法查看子类继承的对象模型：

利用开发人员命令提示工具查看对象模型：

1、跳转盘符 C：（看你自己的文件在哪个盘）

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

3、查看命令

4、cl /d1 reportSingleClassLayout类名 文件名

结果如下：

D:\Program Files\Microsoft Visual Studio\2019\Professional>C:

C:\Program Files (x86)\Microsoft Visual Studio\Installer>cd C:\Users\asus\Desktop\C++\example6

C:\Users\asus\Desktop\C++\example6>dir
 驱动器 C 中的卷是 OS
 卷的序列号是 5626-0D41

 C:\Users\asus\Desktop\C++\example6 的目录

2024/02/18  22:29    <DIR>          .
2024/02/15  21:06    <DIR>          ..
2024/02/18  22:12    <DIR>          Debug
2024/02/18  22:12               658 example6.cpp
2024/02/15  19:55             1,436 example6.sln
2024/02/15  19:55             7,195 example6.vcxproj
2024/02/15  19:55               970 example6.vcxproj.filters
2024/02/15  19:55               168 example6.vcxproj.user
               5 个文件         10,427 字节
               3 个目录 15,610,572,800 可用字节

C:\Users\asus\Desktop\C++\example6>cl /d1 reportSingleClassLayoutSon example6.cpp
用于 x86 的 Microsoft (R) C/C++ 优化编译器 19.29.30153 版
版权所有(C) Microsoft Corporation。保留所有权利。

example6.cpp

class Son       size(16):
        +---
 0      | +--- (base class Base)
 0      | | m_A
 4      | | m_B
 8      | | m_C
        | +---
12      | m_D
        +---
D:\Program Files\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.29.30133\include\ostream(301): warning C4530: 使用了 C++ 异常处理程序，但未启用展开语义。请指定 /EHsc
D:\Program Files\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.29.30133\include\ostream(294): note: 在编译 类 模板 成员函数“std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(unsigned int)”时
example6.cpp(30): note: 查看对正在编译的函数 模板 实例化“std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(unsigned int)”的引用
example6.cpp(30): note: 查看对正在编译的 类 模板 实例化“std::basic_ostream<char,std::char_traits<char>>”的引用
Microsoft (R) Incremental Linker Version 14.29.30153.0
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:example6.exe
example6.obj

C:\Users\asus\Desktop\C++\example6>

1.4继承中构造和析构顺序

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

问题：父类和子类的构造函数和析构顺序是谁先谁后？

继承中的构造和析构顺序如下：

先构造父类，再构造子类，析构的顺序与构造的顺序相反

#include <iostream>
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()
{
    //继承中的构造和析构顺序如下：
    //先构造父类，再构造子类，析构的顺序与构造的顺序相反
    Son s;
}

int main()
{
    test01();

    system("pause");
    return 0;
}

输出结果：

Base构造函数！
Son构造函数！
Son析构函数！
Base析构函数！
请按任意键继续. . .

1.5继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

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

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

解释：如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数，如果想访问到父类中被隐藏的同名成员函数，需要加作用域

#include <iostream>
using namespace std;

//继承中同名成员处理
class Base
{
public:
    Base()
    {
        m_A = 100;
    }

    void func()
    {
        cout << "Base_func()调用" << endl;
    }
    void func(int a)
    {
        cout << "Base_func(int a)调用" << 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;
    //如果通过子类对象  访问到父类中同名成员，需要加作用域
    cout << "Base m_A =" << s.Base::m_A << endl;
}

//同名成员函数处理
void test02()
{
    Son s;
    s.func();//直接调用  调用是子类中同名成员
    //如果通过子类对象  访问到父类中同名成员，需要加作用域
    s.Base::func();
    //如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
    //如果想访问到父类中被隐藏的同名成员函数，需要加作用域
    s.Base::func(10);
}

int main()
{
    //test01();
    test02();

    system("pause");
    return 0;
}

test01输出结果：

Son m_A =200
Base m_A =100
请按任意键继续. . .

 test02输出结果：

Son_func()调用
Base_func()调用
Base_func(int a)调用
请按任意键继续. . .

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

问题：继承中同名的静态成员在子类对象上如何进行访问?

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

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

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

#include <iostream>
using namespace std;

//继承中的同名静态成员处理方式
class Base
{
public:
    
    static int m_A;

    static void func()
    {
        cout << "Base_static_func()调用" << endl;
    }
    static void func(int a)
    {
        cout << "Base_static_func(int a)调用" << endl;
    }
};
int Base::m_A = 100;//类外初始化

class Son :public Base
{
public:
    
    static int m_A;
    static void func()
    {
        cout << "Son_static_func()调用" << endl;
    }
};
int Son::m_A = 200;//类外初始化

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

    //2、通过类名访问
    cout << "通过类名访问：" << endl;
    cout << "Son m_A =" << Son::m_A << endl;
    //两种方式
    cout << "Base m_A =" << Base::m_A << endl;
    //第一个::代表通过类名方式访问  第二个::代表访问父类作用域
    cout << "Base m_A =" << Son::Base::m_A << endl;
}

//同名静态成员函数处理
void test02()
{
    //1、通过对象访问
    Son s;
    s.func();//直接调用  调用是子类中同名成员
    //如果通过子类对象  访问到父类中同名成员，需要加作用域
    s.Base::func();

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

int main()
{
    //test01();
    test02();

    system("pause");
    return 0;
}

 test01输出结果：

通过对象访问：
Son m_A =200
Base m_A =100
通过类名访问：
Son m_A =200
Base m_A =100
Base m_A =100
请按任意键继续. . .

 test02输出结果：

Son_static_func()调用
Base_static_func()调用
Son_static_func()调用
Base_static_func()调用
Base_static_func(int a)调用
请按任意键继续. . .

1.7多继承语法

C++允许一个类继承多个类

语法：

class 子类 :继承方式 父类1,继承方式 父类2 ...

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

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

#include <iostream>
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 子类 : 继承方式 父类1, 继承方式 父类2 ...
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 << "size of 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;
}

输出结果：

size of Son =16
Base1 m_A =100
Base2 m_A =200
请按任意键继续. . .

1.8菱形继承

菱形继承概念:
两个派生类继承同一个基类，又有某个类同时继承者两个派生类，这种继承被称为菱形继承，或者钻石继承。
典型的菱形继承案例:

菱形继承问题：

1、羊继承了动物的数据,驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

2、草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

利用虚继承，解决菱形继承的问题

继承之前加上关键字 virtual变成虚继承

#include <iostream>
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;
}

输出结果： 

st.Sheep::m_Age =28
st.Tuo::m_Age =28
st.m_Age =28
请按任意键继续. . .
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值