C++(第五天----多继承、虚继承、虚函数、虚表)

最新推荐文章于 2024-08-04 22:43:03 发布
最新推荐文章于 2024-08-04 22:43:03 发布
阅读量944 收藏 24
点赞数 17
分类专栏： 嵌入式 C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_demon/article/details/140206725
版权

一、继承对象的内存空间

构造函数调用顺序，先调用父类，再调用子类

#include<iostream>

using namespace std;

//基类   父类
class Base{
public: //公有权限   类的外部  类的内部 
        Base(){cout<<"Base()"<<endl;}
        Base(int a):baseA(a)
        {
            cout<<"Base(int a)"<<endl;
        }

        ~Base(){cout<<"~Base()"<<endl;}

        void setData(int a){
            baseA = a;
        }
        void show(){
            cout<<"baseA:"<<baseA<<"\t addr:"<<&baseA<<endl;
        }
protected: //保护权限  类的内部  子类
        
private: //私有权限  类的内部
        int baseA;
};

//子类  派生类
class Child: public Base
{
public: //公有权限   类的外部  类的内部 
        //在参数列表中指定 父类的构造函数
        Child():Base(100)
        {
            cout<<"Child()"<<endl;
        }
        Child(int a,int b):Base(a),childA(b)
        {
            cout<<"Child(int a)"<<endl;
        }

        ~Child(){cout<<"~Child()"<<endl;}

        void show(){
            Base::show();
            cout<<"childA:"<<childA<<"\t addr:"<<&childA<<endl;
        }
protected: //保护权限  类的内部

private: //私有权限  类的内部
        int childA;   
         
};


int main()
{
    Child mya(100,200);

    cout<<"mya size:"<<sizeof(mya)<<"\t addr:"<<&mya<<endl;

    mya.show();
}

打印结果：

gec@ubuntu:/mnt/hgfs/GZ22229/14C++/05/1-code$ ./a.out 
Base(int a)
Child(int a)
mya size:8     addr:0x7ffed6dc6630
baseA:100     addr:0x7ffed6dc6630
childA:200     addr:0x7ffed6dc6634
~Child()
~Base()

在这里插入图片描述
注意：
1、子类调用成员函数的时候会检测该成员函数在子类中是否存在，如果存在就调用自己的， 如果不存在就调用 父类的（前提是父类要有这个函数）
2、如果子类和父类存在同名函数，那么在子类中 父类的函数成员会被隐藏，默认调用的就是子类函数成员。如果要调用父类的函数成员必须添加类名和作用域。

mya.Base::showData();

练习1：
设计一个基类动物类（属性：体重，颜色，年龄 行为：跑，吃，睡），构造方法初始化属性
设计一个猫类继承动物类（属性：体重，颜色，年龄，品种 行为：跑吃睡，抓老鼠，叫）
定义一个猫对象–咖菲猫，调用猫的喊叫行为，抓老鼠行为 ，输出猫的属性

练习2：编写一个输出学生和教师数据的程序，学生数据有编号、姓名、年龄、学号和成绩；教师数据有编号、姓名、年龄、职称和部门。要求声明一个 person 类，并作为学生数据操作类 student 和教师数据操作类 teacher 的基类

#include <iostream>
#include <cstring>
//将命名空间打开
/*
设计一个基类 动物类（属性：体重、颜色、年龄 、性别    行为：吃喝拉撒）
设计一个猫类 继承动物类（属性：体重、颜色、年龄 、性别、    行为：吃喝拉撒、抓老鼠）
定义一个猫对象 ---断尾猫，调用猫的行为*/
using namespace std;
//动物类
class zoon{
public:   //公有权限
    zoon(int weight,int age, const char * color){
        this->weight = weight;
        this->age = age;
        strcpy(this->color,color);
    }
    void show(){
        cout << "weight:" << weight <<endl;
        cout << "age:"   << age <<endl;
        cout << "color:"  << color <<endl;
    }
protected:
    //私有属性
    int weight;    //体重
    int age;         //年龄
    char color[256];  //颜色
};
//猫类
class cat:public zoon
{
public:   //公有权限
    cat(int weight,int age,const char * color,const char *type):zoon(weight,age,color) {
        strcpy(this->type,type);
    }
    void show(){
        cout << "weight:" << weight <<endl;
        cout << "age:"   << age <<endl;
        cout << "color:"  << color <<endl;
        cout << "type:"  << type <<endl;
    }
    void behavior(){
        cout << "behavior" <<endl; 
    }
private:
    //私有
    char type[256];
    // cat Broken_tail(10,6,"white","BrokenTail");
};
int main()
{
    cat mya(10,6,"white","BrokenTail");
    mya.show();
    mya.behavior();  //行为
    
    
    return 0;
}

二、多继承

1、格式

class 子类:继承方式  基类1,继承方式  基类2 
{
    变量成员
    函数成员
};

2、例子

#include <iostream>


using namespace std;


//羊类
class Sheep{


public:
    Sheep(){
        cout<<"Sheep()"<<endl;
    }
    Sheep(int a):dataA(a)
    {
        cout<<"Sheep(int a)"<<endl;
    }
    ~Sheep(){
        cout<<"~Sheep()"<<endl;
    }
    void show(){
        cout<<"dataA value:"<<dataA<<"\t addr:"<<&dataA<<endl;
     }
    int dataA;
};


//驼类
class Tuo{


public:
    Tuo(){
        cout<<"Tuo()"<<endl;
    }
    Tuo(int a):dataB(a)
    {
        cout<<"Tuo(int a)"<<endl;
    }
    ~Tuo(){
        cout<<"~Tuo()"<<endl;
    }
    void show(){
        cout<<"dataB value:"<<dataB<<"\t addr:"<<&dataB<<endl;
     }
    int dataB;
};




//羊驼类
//多继承 的时候 基类的构造函数执行的顺序 跟  继承的先后顺序有关
class SheepTuo:public Sheep,public Tuo
{
public:
    //在构造函数的参数列表中 指定 基类的构造函数
    SheepTuo(int a,int b):Tuo(b),Sheep(a)
    {
        cout<<"SheepTuo()"<<endl;
    }
    ~SheepTuo(){
        cout<<"~SheepTuo()"<<endl;
    }
    //在子类中重写 基类的同名函数，那么基类中的同名函数就会自动隐藏
    void show(){
        cout<<"dataA value:"<<dataA<<"\t addr:"<<&dataA<<endl;
        cout<<"dataB value:"<<dataB<<"\t addr:"<<&dataB<<endl;
        cout<<"dataC value:"<<dataC<<"\t addr:"<<&dataC<<endl;
    }
    int dataC;
};




int main()
{
    //派生类对象的实例化
    SheepTuo mya(10,20);

    cout<<"mya size:"<<sizeof(mya)<<"\tmya addr:"<<&mya<<endl;

    mya.show();

    //通过基类的类名显示调用
    //mya.Sheep::show();

    return 0;
}


结果：
mylinux@ubuntu:/mnt/hgfs/13C++编程/04/1-code$ ./a.out 
A()
B()
C()
dataA addr:0x7fffd8f7f420 dataB addr:0x7fffd8f7f424 dataC addr:0x7fffd8f7f428
~C()
~B()
~A()

总结：

  • 多继承的时候，创建子类对象构造函数执行的顺序 羊—》驼----》羊驼 ,跟基类继承的先后顺序有关
  • 在派生类的构造函数初始化列表中指定基类的构造函数
    3、内存结构图
    在这里插入图片描述
    思考：如果多个基类中有同名的函数，那么创建子类的对象，然后进行调用，会发生什么情况？怎么解决

情况：编译错误，语法不通过
解决： 1. 在子类中重新实现函数，父类函数就会自动隐藏
2. 通过父类类名显示调用

三、多继承中的菱状继承（环状继承）

1、概念
多继承中的多级继承的时候，父类的父类出现公共的基类
2、例子
在这里插入图片描述

A--->D   C-->D   B-->A、C

这个继承会使D创建两个对象

#include <iostream>


using namespace std;


//动物类
class Animal{
public:
    Animal(){
        cout<<"Animal()"<<endl;
    }
    Animal(int a):dataD(a)
    {
        cout<<"Animal(int a)"<<endl;
    }
    ~Animal(){
        cout<<"~Animal()"<<endl;
    }


    int dataD;
};




//羊类 --继承于 动物类
class Sheep:public Animal{


public:
    Sheep(){
        cout<<"Sheep()"<<endl;
    }
    Sheep(int a):dataA(a)
    {
        cout<<"Sheep(int a)"<<endl;
    }
    ~Sheep(){
        cout<<"~Sheep()"<<endl;
    }
    void show(){
        cout<<"dataA value:"<<dataA<<"\t addr:"<<&dataA<<endl;
     }
    int dataA;
};


//驼类
class Tuo:public Animal{


public:
    Tuo(){
        cout<<"Tuo()"<<endl;
    }
    Tuo(int a):dataB(a)
    {
        cout<<"Tuo(int a)"<<endl;
    }
    ~Tuo(){
        cout<<"~Tuo()"<<endl;
    }
    void show(){
        cout<<"dataB value:"<<dataB<<"\t addr:"<<&dataB<<endl;
     }
    int dataB;
};




//羊驼类
//多继承 的时候 基类的构造函数执行的顺序 跟  继承的先后顺序有关
class SheepTuo:public Sheep,public Tuo
{
public:
    //在构造函数的参数列表中 指定 基类的构造函数
    SheepTuo(int a,int b):Tuo(b),Sheep(a)
    {
        cout<<"SheepTuo()"<<endl;
    }
    ~SheepTuo(){
        cout<<"~SheepTuo()"<<endl;
    }
    //在子类中重写 基类的同名函数，那么基类中的同名函数就会自动隐藏
    void show(){
        cout<<"dataA value:"<<dataA<<"\t addr:"<<&dataA<<endl;
        cout<<"dataB value:"<<dataB<<"\t addr:"<<&dataB<<endl;
        cout<<"dataC value:"<<dataC<<"\t addr:"<<&dataC<<endl;
       // cout<<"dataD value:"<<dataC<<"\t addr:"<<&dataD<<endl;
    }
    int dataC;
};




int main()
{
    //派生类对象的实例化
    SheepTuo mya(10,20);


    cout<<"mya size:"<<sizeof(mya)<<"\tmya addr:"<<&mya<<endl;


    mya.show();
    //发生二义性问题
    //mya.Animal::dataD = 100;
    //通过基类的类名显示调用
    //mya.Sheep::show();


    return 0;
}

分析：
使用qtcreator的断点调试可看到：
在这里插入图片描述
在这里插入图片描述
内存图如下：
在这里插入图片描述
通过分析可得， 创建B myb 对象的时候，构造函数顺序为 D---->A----->D—>C---->B

思考：如果myb访问D类中的成员，会发生什么情况？？

答案： 会发生歧义，编译错误
在这里插入图片描述
如何解决：使用虚拟继承

四、虚拟继承（虚基类）

1、概念
为了解决从不同途径继承来的同名的数据成员在内存中有不同的拷贝造成数据不一致问题， 将共同基类设置为虚基类。这时从不同的路径继承过来的同名数据成员在内存中就只有一个 拷贝，同一个函数名也只有一个映射。这样不仅就解决了二义性问题，也节省了内存，避免了数据不一致的问题
2、格式

class  子类名称:virtual  父类名
{
};

3、例子

#include <iostream>

using namespace std;

//动物类
class Animal{
public:
    Animal(){
        cout<<"Animal()"<<endl;
    }
    Animal(int a):dataD(a)
    {
        cout<<"Animal(int a)"<<endl;
    }
    ~Animal(){
        cout<<"~Animal()"<<endl;
    }

    int dataD;
};

//羊类 --继承于 动物类  --虚基类  Animal
class Sheep:virtual public Animal{

public:
    Sheep(){
        cout<<"Sheep()"<<endl;
    }
    Sheep(int a):dataA(a)
    {
        cout<<"Sheep(int a)"<<endl;
    }
    ~Sheep(){
        cout<<"~Sheep()"<<endl;
    }
    void show(){
        cout<<"dataA value:"<<dataA<<"\t addr:"<<&dataA<<endl;
     }
    int dataA;
};

//驼类
class Tuo:virtual public Animal{

public:
    Tuo(){
        cout<<"Tuo()"<<endl;
    }
    Tuo(int a):dataB(a)
    {
        cout<<"Tuo(int a)"<<endl;
    }
    ~Tuo(){
        cout<<"~Tuo()"<<endl;
    }
    void show(){
        cout<<"dataB value:"<<dataB<<"\t addr:"<<&dataB<<endl;
     }
    int dataB;
};

//羊驼类
//多继承 的时候 基类的构造函数执行的顺序 跟  继承的先后顺序有关
class SheepTuo:public Sheep,public Tuo
{
public:
    //在构造函数的参数列表中 指定 基类的构造函数
    SheepTuo(int a,int b):Tuo(b),Sheep(a)
    {
        cout<<"SheepTuo()"<<endl;
    }
    ~SheepTuo(){
        cout<<"~SheepTuo()"<<endl;
    }
    //在子类中重写 基类的同名函数，那么基类中的同名函数就会自动隐藏
    void show(){
        cout<<"dataA value:"<<dataA<<"\t addr:"<<&dataA<<endl;
        cout<<"dataB value:"<<dataB<<"\t addr:"<<&dataB<<endl;
        cout<<"dataC value:"<<dataC<<"\t addr:"<<&dataC<<endl;
        cout<<"dataD value:"<<dataC<<"\t addr:"<<&dataD<<endl;
    }
    int dataC;
};

int main()
{
    //派生类对象的实例化
    SheepTuo mya(10,20);

    cout<<"mya size:"<<sizeof(mya)<<"\tmya addr:"<<&mya<<endl;

    mya.show();
    //发生二义性问题
    //mya.Animal::dataD = 100;
    //通过基类的类名显示调用
    //mya.Sheep::show();

    return 0;
}

现象：

A:virtual public D
C:virtual public D

在这里插入图片描述
分析：
在这里插入图片描述
总结：

  • 在多继承情况下，虚基类关键字的作用范围和继承方式关键字相同，只对紧跟其后的基类起作用。
  • 虚拟继承在创建对象的时候在子类对象中会有一个虚基类表指针，该虚基类表指针存储 虚基类 对象空间的最开始位置。
  • 类对象空间的大小 由 非静态成员数据+虚基类指针+字节对齐 组成。

五、虚函数、虚函数表

1、格式

virtual 函数返回类型 函数名（参数表） {函数体};

当一个类中有一个或多个虚拟函数，那么这个类在编译的时候就会创建一个虚函数表（简称虚表） 。虚表就是一个存放虚函数指针的表格，而这个表格的首地址存放在对象的地址开始位置。
2、例子

#include <iostream>


using namespace std;


class Data{
public:
    Data(){cout<<"Data()"<<endl;}
    ~Data(){cout<<"~Data()"<<endl;}


private:
    //在普通的函数前面加一个 关键字virtual ---虚函数
     virtual void setA(int val){
        cout<<"setA"<<endl;
        //dataA = val;
    }
     virtual void setB(int val){
        cout<<"setB"<<endl;
        //dataB = val;
    }
    virtual void setC(int val){
        cout<<"setC"<<endl;
        dataC = val;
    }
    int dataA;
    int dataB;
    int dataC;


private:


};




int main()
{
    Data mya;


    cout<<"mya size:"<<sizeof(mya)<<"mya addr:"<<&mya<<endl;


    //如何在类的外部 去调用类中的私有函数成员
    //可以将 私有函数成员 声明为 虚函数 ，通过虚表指针 去调用
    //mya.setA(10);
   // mya.setB(20);
   // mya.setC(30);

    //unsigned long 在window平台 是 4个字节  unsigned long long 是 8个字节
    //unsigned long 在linux平台  是 8个字节
    //求出虚表的地址
    unsigned long long *vptr =  (unsigned long long *)(*(unsigned long long*)&mya);
    cout<<"vptr:"<<vptr<<endl;


    cout<<"vptr+1:"<<vptr+1<<endl;

    return 0;
}

通过断点调试 可以看到在这里插入图片描述

3、注意：
1）、如果一个类中包含（一个或者多个）虚函数，那么这个类的对象中会包含一个虚表指针vptr
2）、虚表指针保存在对象内存空间的最前面
3）、虚表中存储的是 类中 虚函数的地址
4）、对象调用类中的虚函数，会查询虚表指针再去执行函数

4、虚表与虚表指针，虚基类表与虚基类表指针的区别
https://blog.csdn.net/qq_42719751/article/details/104656429

六、通过虚表指针调用虚函数

1、虚函数
在类的成员函数声明前面添加virtual，这个函数就被声明为虚函数， 那么这个类的对象中包含一个指向虚表的指针
2、虚表
存储虚函数地址
3、通过虚函数指针调用虚函数
在这里插入图片描述

#include <iostream>


using namespace std;


class Data{
public:
    Data(){}
    ~Data(){}




private:
    int a;


    //virtual关键字还可以用来修饰函数  ，称之为 虚函数
    virtual int test01(){
        cout<<__FUNCTION__<<endl;
    }
    virtual int test02(){
        cout<<__FUNCTION__<<endl;
    }
    int test03(){
        cout<<__FUNCTION__<<endl;
    }
};




int main()
{
    Data d1;


    //d1.test01();
    //d1.test02();


    cout<<"size:"<<sizeof(Data)<<endl;


    //通过得到虚表中的函数的地址去调用函数
    //如果该函数是私有权限下的函数，能够突破类中权限的限制
    //1)先获取虚表的地址
    //*(unsigned long long*)&d1;  地址常量 0x100ff1a
    unsigned long long*vptr = (unsigned long long*)*(unsigned long long*)&d1;


    cout<<"vptr:"<<vptr<<endl;


    //求test01函数的地址
    //*vptr 等价于vptr[0]  --得到test01函数的地址--但是该地址是一个常量，必须转换成函数类型的地址
    typedef  int (*PFunc_t)(void);
//    PFunc_t test01_p = (PFunc_t)vptr[0];
//    test01_p();
    ((PFunc_t)vptr[0])();

//    PFunc_t test02_p = (PFunc_t)vptr[1];
//    test02_p();

    return 0;
}

4、总结

  • 同一个类的不同实例共用同一份虚函数表, 它们都通过一个所谓的虚函数表指针__vfptr指向该虚函数表.
  • 虚表存储在进程的数据段.rodata中，虚函数存储在代码段中的.text段中
  • 当类中有虚函数的时候，编译器在编译的时候就会为该类创建一张虚表，而且只存在一份。定义类对象时, 编译器自动将类对象的__vfptr指向这个虚函数表。
  • 通过虚函数表能够突破虚函数访问权限的控制。比如我们可以将虚函数定义为private类型，这样在类外面就不能通过对象调用private类型的函数了。但是在类的虚函数表中，不论其访问类型是public还是private的，其所有虚函数都会存放其中。
demon % ！
关注
  • 17
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++】c++单继承、多继承、菱形继承内存布局（虚函数表结构）
SuLiJuan66的专栏
10-04 1万+
c++单继承、多继承、菱形继承内存布局（虚函数表结构）
C++继承、多态与虚表
dielu7895的博客
08-11 162
继承 继承的一般形式 子类继承父类，是全盘继承，将父类所有的东西都继承给子类，除了父类的生死，就是父类的构造和析构是不能继承的。 继承的访问权限从两方面看： 1.对象：对象只能直接访问类中公有方法和成员。 2.继承的子类 私有继承就终止了父类再往下继承的能力 c++默认继承为私有继承 像以下程序 class D :public B1 ,public B2,public B3 公有继...
C++继承 虚函数表
zhuimengfuyun的专栏
11-14 630
C++ 虚函数表解析   陈皓 http://blog.csdn.net/haoel     前言   C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，R
C++继承(继承性）---抽象类 虚表
weixin_43886592的博客
11-01 861
一、抽象类 纯虚函数：在虚函数的后面写上 = 0 ，且不实现这个函数，则这个函数为纯虚函数。 抽象类：包含纯虚函数的类叫做抽象类（也叫接口类）。 1.抽象类不能实例化出对象，派生类继承后也不能实例化出对象。 2.只有重写纯虚函数，派生类才能实例化出对象。 3. 纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。 class Base //抽象类 { public: virtual...
c++ 继承关系中的虚函数表
yuanshenqiang的博客
02-22 3269
1. 子类继承父类的虚函数表的方式是复制一份。存在虚函数的类，都有自己的虚函数表，不与其他类共用。 2. 只要祖先类的某个函数被声明位virtual, 则在后代中无论是否显式地添加virtual，该函数一直都是虚的。 3. 如果子类重写了某个虚函数，则该类的虚函数表对应位置上的虚函数地址会被覆盖。如果完全不重写，则子类的虚函数表里面的内容和父类虚函数表内容保持一致。 4. 虚函数表类似于类的静态成员，被该类的所有实例共享。只不过该表是只读的，不存在线程安全问题。 5. 实例对象在起始4字节处，会存放
C++中单继承与多重继承下的虚函数表
独行Freedom的博客
01-19 5395
转自：http://www.cnblogs.com/Z465360621/articles/4561344.html 虚函数表，以及虚函数指针： 1）每个有虚函数的类都有自己的虚函数表，每个包含虚函数的类对象都有虚函数表指针。 2）对于多重继承，如果多个基类都有虚函数，则继承类中包含多个基类虚函数表，子类的虚函数地址放在声明的第一个基类虚函数表后面。 3）计算类对象的内存大小的时候，需要计
C++ 虚继承实现原理（虚基类表指针与虚基类表）
热门推荐
longlovefilm的博客
06-03 3万+
虚继承和虚函数是完全无相关的两个概念。虚继承是解决C++多重继承问题的一种手段，从不同途径继承来的同一基类，会在子类中存在多份拷贝。这将存在两个问题：其一，浪费存储空间；第二，存在二义性问题，通常可以将派生类对象的地址赋值给基类对象，实现的具体方式是，将基类指针指向继承类（继承类有基类的拷贝）中的基类对象的地址，但是多重继承可能存在一个基类的多份拷贝，这就出现了二义性。虚继承可以解决多种继承前面提...
一篇文章带你学懂C++虚函数表的继承问题
Jacksqh的博客
04-08 4998
虚函数表-继承 单继承 结论：当父类定义了虚函数时，在子类进行继承的时候会将父类的虚函数表也给继承下来所以那一些虚函数在子类中也是virtual类型的，如果要对父类中的虚函数进行重写时或添加虚函数，顺序是：（图表说明为图一) ①先将父类的虚函数列表复制过来（补充一点 ②重写虚函数时是把从父类继承过来的虚函数表中对应的虚函数进行相应的替换。 ③如果子类自己要添加自己的虚函数，则是把添加的虚函数加到从......
浅谈c++虚函数 虚继承的虚表剖析
菜鸟成长记
11-13 1147
c++中 虚表的剖析
C++ STL copy_backward, move_backward 用法
08-04 179
此处需要解释一下：从后向前并不是逆序，它的意思是: 源容器和目标容器都从尾部开始，然后向前迭代，执行拷贝/移动操作。反向（从后向前的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 392
在我们生活中，经常会遇到TopK问题。建小堆解决
C++ STL copy, move 用法
08-04 170
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
OD C卷 - 中庸行者
最新发布
weixin_45228198的博客
08-04 179
DFS
3.C_Demo_最大公约数、最小公倍数
Fresh_man111的博客
08-03 289
假设两个数字a和b，求两个数字相除的余数c=a%b，如果余数为0，则b为最大公约数。如果b不为零，a=b,b=c,继续循环计算。两个数的最小公倍数数等于两个数的乘积除以两个数的最大公约数。即：x，y的最小公倍数 min(公倍数)=x*y÷max(公约数)参数a，b：传入的两个数值，两个数都不能为0。参数a，b：传入的两个数值，不能全为0。返回值：0代表错误，正常返回最大公约数。返回值：0代表错误，正常返回最小公倍数。功能：求a，b最大公约数。功能：求a，b最小公倍数。
【C语言篇】C语言数据类型和变量
2301_79849925的博客
07-27 806
C语⾔提供了丰富的数据类型来描述⽣活中的各种数据。 - 使⽤整型类型来描述整数 - 使⽤字符类型来描述字符 - 使⽤浮点型类型来描述⼩数 所谓“类型”，就是相似的数据所拥有的共同特征，编译器只有知道了数据的类型，才知道怎么操作数据。下⾯盘点⼀下C语⾔提供的各种数据类型，本文主要探讨内置数据类型。
C语言基础题：硬币问题（C语言版）
我就知道你会来，我们一起进步吧！
08-04 326
对于样例数据 1，最佳方案是 15 =5+5 +5，使用到3 枚硬币。对于样例数据 2，最佳方案是 12 = 11 + 1，使用到 2 枚硬币。对于 100% 的数据，保证n
深入理解 C 语言中的联合体
2302_81410974的博客
08-03 1293
联合体（union）是 C 语言中的一种特殊数据结构，允许在同一内存位置存储不同类型的数据。它与结构体（struct）类似，但存在显著的差异。理解联合体的定义、基本用法、优势、存储细节及其高级用法，有助于在实际编程中有效地使用这一数据结构。
【C++】构造函数的深入学习
weixin_60546365的博客
07-30 493
所有对象共享同一份数据 -- 你改了别人用的就是改过的数据。类中声明，类外初始化 -- 必须要有一个初始值否则没法用。所有对象共享同一个函数，类外访问不到私有静态函数。静态成员函数只能访问静态成员变量。静态成员变量访问权限：在Private作用域下访问，出了这个类不可以访问。分配内存 -- 生成了exe程序，还没有双击运行之前已经分配在全局区中。语法：构造函数（）：属性1（值1），属性2（值2）...{ }先构造A再构造B，先析构B再析构A（先进后出LIFO）C++提供初始化列表语法用来初始化属性。
C++面向对象程序设计：第6章-第12章 虚函数示例解析
"陈维兴《C++面向对象程序设计》的第6章至第12章源码，涉及C++中的面向对象特性，包括虚函数的使用和继承等概念。" 在C++编程语言中，面向对象编程是其核心特性之一，而虚函数是实现多态性（Polymorphism）的关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值