C++ 10 类与对象(继承)

已于 2023-03-23 20:54:58 修改
阅读量307 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-03-21 16:57:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peng_258/article/details/129692238
版权

目录

一、继承简介

1.1 普通实现

1.2 继承实现

二、三种继承改变权限

三、继承对象内存

3.1 查询继承对象所占内存

3.2 VS自带开发工具查询

四、继承构造和析构顺序

五、同名成员处理

六、同名静态成员处理

七、多继承语法

八、菱形继承

8.1 菱形继承简介

8.2 菱形继承普通方式 

8.3 菱形继承虚继承

8.3.1 菱形继承虚继承方式

8.3.2 菱形继承虚继承VS查询

一、继承简介

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

② 定义类时，下级别的成员除了拥有上一级的共性，还有自己的特性。这个时候，就可以考虑利用继承技术，减少重复代码。

1.1 普通实现

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

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

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

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

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

    cout << "........................" << endl;
    cout << "Python下载视频页面如下：" << 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;

}

运行结果：

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

1.2 继承实现

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

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

// 子类 也称为 派生类

// 父类 也称为 基类

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

//打印输出类
class BasePage
{
public:
    void header()
    {
        cout << "首页、公开课、登陆、注册...(公共头部)" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    }
    void left()
    {
        cout << "Java、Python、C++....(公共分类列表)" << endl;
    }
};

// 继承的好处：减少重复代码
// 语法：class 子类：继承方式 父类
// 子类 也称为 派生类
// 父类 也称为 基类

//Java页面
class Java:public BasePage   //继承了BasePage，把BasePage里面的内容全部拿到手了
{
public:
    void content()
    {
        cout << "Java学科视频" << endl;
    }
};

//Python页面
class Python :public BasePage   //继承了BasePage，把BasePage里面的内容全部拿到手了
{
public:
    void content()
    {
        cout << "Python学科视频" << endl;
    }
};

//C++页面
class CPP :public BasePage   //继承了BasePage，把BasePage里面的内容全部拿到手了
{
public:
    void content()
    {
        cout << "CPP学科视频" << endl;
    }
};

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

    cout << "........................" << endl;
    cout << "Python下载视频页面如下：" << 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;

}

运行结果：

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

二、三种继承改变权限

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

② 继承方式一共有三种：

  1. 公共继承
  2. 保护继承
  3. 私有继承

③ 不同的继承方式，父类中的变量被继承后，权限相应的得到了改变，如下图所示。

- 父类中的私有属性，子类不管用哪种继承方式都不可以访问

- 如果是公共继承，父类中公共/保护/私有属性，在子类中依然是公共/保护/私有属性

- 如果是保护继承，父类中公共/保护/私有属性，在子类中变为保护属性

- 如果是私有继承，父类中公共/保护/私有属性，在子类中变为私有属性

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

//打印输出类
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;  //保护权限，类内能访问，类外不能访问
}

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

    }
};


void test02()
{
    Son2 s2;
    //s2.m_A = 100;  //保护权限，类内能访问，类外不能访问
    //s2.m_B = 100;  //保护权限，类内能访问，类外不能访问
}

//私有继承
class Son3:private Base1
{
public:
    void func()
    {
        m_A = 10; //父类中的公共权限成员 到子类中变为私有权限
        m_B = 10; //父类中的保护权限成员 到子类中变为私有权限
        //m_C = 10; //父类中的私有权限成员 子类访问不到

    }
};

void test03()
{
    Son3 s3;
    //s3.m_A = 100;  //私有权限，类内能访问，类外不能访问
    //s3.m_B = 100;  //私有权限，类内能访问，类外不能访问
}

int main()
{

    system("pause");

    return 0;

}

三、继承对象内存

3.1 查询继承对象所占内存

父类中所有非静态成员属性都会被子类继承下去
父类中私有成员属性 是被编译器给隐藏了，因此是访问不到，但是确实被继承下去了

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

//继承中的对象模型

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};


//公共继承
class Son:public Base
{
    int m_D; 
};

//利用开发人员命令提示工具查看对象模型
//跳转盘符→F:
//跳转文件路径→cd 具体路径下
//查看命令
//cl /d1 reportSingleClassLayout查看的类名 "文件名"

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

int main()
{
    test01();

    system("pause");

    return 0;

}

运行结果：

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

3.2 VS自带开发工具查询

① 首先打开visio studio的开发人员命令工具，如下图所示。

//利用开发人员命令提示工具查看对象模型
//跳转盘符→F:
//跳转文件路径→cd 具体路径下
//查看命令
//cl /d1 reportSingleClassLayout查看的类名 "文件名"

四、继承构造和析构顺序

① 继承中，先调用父类构造函数，再调用子类构造函数，析构顺序与构造顺序相反，先调用子类析构函数，再调用父类析构函数。

Son s;  

1、拿到父类所有属性

2、创建父类对象

3、调用父类对象构造函数、析构函数

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

//继承中的构造和析构顺序

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;

}

运行结果：

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

五、同名成员处理

① 子类对象可以直接访问到子类中同名成员。

② 子类对象加作用域可以访问到父类同名成员。

③ 当子类与父类拥有同名的成员函数，子类会隐藏父类中所有同名成员函数(有参、无参)，加作用域才可以访问到父类中同名函数。

s.func(100);  //子类会隐藏父类中所有同名成员函数(有参、无参)

s.Base::func(100); //加作用域才可以访问到父类中同名函数

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


//继承中同名成员处理

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

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

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(100);
}

//同名成员函数处理
int main()
{
    test01();
    test02();
    
    system("pause");

    return 0;

}

运行结果：

Son 下 m_A=200
Base 下 m_A=100
Son - func()调用
Base - func()调用
Base - func(int a)调用
请按任意键继续. . .

六、同名静态成员处理

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

  1. 访问子类同名成员，直接访问
  2. 访问父类同名成员，需要加作用域

② 加上static关键字后，成员发生变化，成员变成静态成员。

③ 静态成员变量特点：

  1. 所有对象都共享同一份数据。
  2. 编译阶段就分配内存。
  3. 类内声明，类外初始化。

④ 静态成员函数特点：

  1. 只能访问静态成员变量，不能访问非静态成员变量。
  2. 所有对象都共享同一份函数实例。
#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 void func()" << endl;
    }
};

int Son::m_A = 200;

//同名静态成员属性
void test01()
{
    //1、通过对象访问
    Son s;
    cout << "Son 下 m_A = " << s.m_A << endl;
    cout << "Base 下 m_A = " << s.Base::m_A << endl;

    //2、通过类名访问
    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、通过类名访问
    Son::func();
    Son::Base::func();

    //子类出现和父类同名静态成员函数，也会隐藏掉父类中所有同名成员函数
    //如何想访问父类中被隐藏同名成员，需要加作用域
    Son::Base::func(100);
}

//同名成员函数处理
int main()
{
    test01();
    test02();
    
    system("pause");

    return 0;

}

运行结果：

Son 下 m_A = 200
Base 下 m_A = 100
Son 下 m_A = 200
Base 下 m_A= 100
Son - static void func()
Base - static func()
Son - static void func()
Base - static func()
Base - static func(int a)
请按任意键继续. . .

七、多继承语法

① 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 << "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;

}

运行结果：

sizeof(Son):16
Base1::m_A = 100
Base2::m_A = 200
请按任意键继续. . .

八、菱形继承

8.1 菱形继承简介

① 菱形继承概念：

  1. 两个派生类继承同一个基类
  2. 又有某个类同时继承两个派生类
  3. 这种继承被称为菱形继承

② 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时就会产生二义性（加作用域来解决）。

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

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

④ 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义。

⑤ 利用虚继承可以解决菱形继承问题。

8.2 菱形继承普通方式 

#include <iostream>
using namespace std;

//动物类
class Animal
{
public:
    int m_Age;
};

//羊类
class Sheep:public Animal{};

//驼类
class Tuo: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;

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

int main()
{
    test01();

    system("pause");

    return 0;
}

运行结果：

st.Sheep::m_Age=18
st.Tuo::m_Age=28
请按任意键继续. . .

8.3 菱形继承虚继承

8.3.1 菱形继承虚继承方式

#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
请按任意键继续. . .

8.3.2 菱形继承虚继承VS查询

① Sheep类和Tuo类继承的都是vbptr，vbptr为虚基类继承指针。

  1. v - virtual
  2. b - base
  3. ptr = pointer

② 菱形继承并不是继承两份数据，而是继承两份指针，这两个指针会分别指向虚基类表，虚基类表中会记录偏移量，加上这个偏移量，会指向这个唯一的数据。

Darren214
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cpp中protected保护派生和private私有派生在实际效果上是否“等效”
ljkkk_cu的博客
01-24 240
cpp中protected保护派生和private私有派生在实际效果上是否“等效”
C++类与对象-继承（详细讲解）
03-24
C++类与对象-继承（详细讲解）
java与C++的继承
qingchenqx的博客
05-21 321
c++和java都是面向对象的语言，具有封装、继承、多态三大特性。
java类单继承 C++可以多继承
LTC_1234的博客
03-08 703
文章目录java类单继承在C++支持多继承 java类单继承 java类单继承: Java的三大特性，继承、封装、多态。Java中不支持多继承，子类只能有一个父类或者没有父类。所谓继承，简单理解可以从字面意思去认识学习，就是"子"可以继承"父"所拥有的属性及方法。传承接收后就是自己的属性或方法 通过下面的例子来说明java类多继承带来的问题 class A { void method(...
c 纯虚函数和java接口_C++虚函数与JAVA中抽象函数比较 接口与抽象类比较
weixin_39736650的博客
02-13 196
C++虚函数与JAVA中抽象函数比较1：java中没有虚函数的概念，但是有抽象函数的概念，用abstract关键字表示，java中抽象函数必须在抽象类中，而且抽象 函数不能有函数体，抽象类不能被实例化，只能由其子类实现抽象函数，如果某个抽象类的子类仍是抽象类，那么该子类不需要实现其父类的抽象函数。2：C++中的有虚函数的概念，用virtual 关键字来表示，每个类都会有一个虚函数表，该虚函数表首先...
(C++)类与对象
weixin_53812805的博客
05-22 1万+
一、类与对象的思想 面向对象的特点：封装、继承、多态 面向对象编程的特点： （1）易维护：可读性高，即使改变了需求，由于继承的存在，只需要对局部模块进行修改，维护起来非常方便，维护的成本也比较低。 （2）质量高：可以重用以前项目中已经被测试过的类，使系统满足业务需求从而具有更高的质量 （3）效率高：在软件开发时，根据设计的需求要对现实世界的事物进行抽象，从而产生了类 （4）易扩展：由于继承、封装、多态的特性，可设计出高内聚、低耦合的系统结构，使系统更加灵活、更容易扩展，而且成本也比较低。 1、
【C++】类和对象-继承
debug...
07-18 1029
C++三大特性之继承
C++类的继承
潜心钻研技术
02-07 2035
继承的概念和定义 概念 我们知道C++是一个面向对象的语言，继承是面向对象程序设计使代码可以复用的最重要的手段，使在逻辑上是继承关系的对象在用类来描述对象语言层面实现了代码复用，这样产生的新的类叫做派生类 例如用学生系统来举例 图中的学生管理系统建立了四个类用来描述 人、学生、老师、助教，但是我们发现学生、助教、老师这三个类都有人这个类的属性，在这个属性上才会多出来一些不同的特征，例如学生可能会有学号、班级…，于是学生从人继承部分属性就是类中的继承，人这个类叫做 父类 或者 基类 ，学生这个类别叫做 子类
C++类的继承与函数模板
热门推荐
qq_73627657的博客
04-17 15万+
class 子类名:继承方式 父类名private:public:protected:无论子类以什么方式继承父类，父类的private成员在子类中均不可见(子类不可访问)。不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。如果在上述代码示例中，学生类(子类)以protected继承的方式继承人类(父类)，那么代码运行将出现bug。
c++：继承（超详解）
qq_62718027的博客
07-22 7万+
目录一：什么是继承二：继承的格式继承的总结：二：子类和父类（基类和派生类）1.子类和父类的相互赋值：2.同名的成员变量3.同名成员函数三：子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四：单继承和多继承单继承： 多继承：菱形继承解决方法一：解决方法二：单继承和多继承的总结：定义：继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）
面向对象——继承（c++）
weixin_48560325的博客
07-26 2313
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础，上进行扩展，增加功能。这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构。体现了由简单到复杂的认识过程。百度百科（继承）通过继承(inheritance)的机制可对类(class)分层，提供类型/子类型的关系。C++通过类派生(classderivation)的机制来支持继承。被继承的类称为基类(baseclass)或超类(superclass)，新产生的类为。......
C++ 类的继承与派生实例详解
01-01
继承性是面向对象程序设计最重要的特性之一，使软件有了可重用性，C++提供的类的继承机制。 继承与派生的概念 一个新类从已有的类那里获得已有的特性，这种现象称为类的继承。同样也可以说成已有的类派生出来了新的...
C++类中的继承实例详解
08-30
C++ 类中的继承是面向对象编程（Object-Oriented Programming，OOP）的一种重要机制，允许开发者创建出具有继承关系的类。继承机制可以实现代码的重用和简化代码的编写。 在 C++ 中，继承是通过使用继承关键字...
C++程序_类的继承与派生_
10-01
在C++编程语言中，类的继承与派生是面向对象编程的重要概念，它们使得代码重用和构建复杂的软件结构变得更加高效。在这个“C++程序_类的继承与派生”主题中，我们将深入探讨这两个核心特性。 首先，类是C++中的基本...
c++面向对象实现继承car
07-17
c++面向对象实现继承car
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1120
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++笔试强训7
m0_74189279的博客
07-21 967
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
最新发布
zeyeqianli的博客
07-22 315
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 251
C++笔记3：基类指针delete子类对象的内存泄漏问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值