06-C++ 类和对象-多态

最新推荐文章于 2024-06-12 21:23:37 发布
最新推荐文章于 2024-06-12 21:23:37 发布
阅读量1k 收藏 21
点赞数 30
分类专栏： C/C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhb_feng/article/details/135298958
版权

类与对象

多态

1. 简介

一个事物的多种形态，简称多态。

  • 物的多态

    同一个人在不同人面前，角色不同

    如：

    1. 在父母面前
    2. 在对象面前
    3. 在朋友面前
    4. 在同事面前

  • 事的多态

    同一种事情，在不同情况下展现不同

    如：

    1. 吃饭

      • 中国人 筷子 熟食
      • 美国人 刀叉 7分熟
      • 印度人 手 咖喱饭

    2. 睡觉

      • 中国人 床上
      • 日本人 地上

      平躺

      侧卧

      趴着

2. 上行与下行

2.1 上行

子类 转 父类

语法：

父类名 *父类对象指针 = 子类对象指针;
或
父类名& 父类对象名 = 子类对象;

注意：

无风险，无需强转。

2.2 下行

父类 转 子类

语法：

子类名 *子类对象指针 = (子类名 *)父类对象指针;
或
子类名& 子类对象 = (子类名&) 父类对象;

注意：

有风险，需强转。

2.3 示例
#include <iostream>
using namespace std;

class Anim{
public:
    int a;
    Anim(){}
    Anim(int a):a(a){}
};

class Dog:public Anim{
public:
    int d;
    Dog(){}
    Dog(int a, int d):Anim(a),d(d){}
};
class Cat:public Anim{
public:
    int c;
};

int main(int argc, char *argv[])
{
    //上行
    //将子类对象的地址赋值给父类对象的引用或指针
    Dog d1(10, 100);
    Anim& a1 = d1;
    //赋值给指针，记得取地址，不然报错
    Anim* a2 = &d1;
    cout << "d1.d=" << d1.d << endl;    //d1.d=100
    cout << "a1.a=" << a1.a << endl;    //a1.a=10
    //子类转父类后, 父类对象不能使用子类所特有的属性
//    cout << "a1.d=" << a1.d << endl;      //报错

    //下行
    Dog d2 = (Dog &)a1;
    Dog *d3 = (Dog *)a2;
    cout << "d2.d=" << d2.d << endl;    //d2.d=100
    //父类转换子类后,子类可以使用父类的
    cout << "d2.a=" << d2.a << endl;    //d2.a=10
    //下行父转子
    Cat& c1 = (Cat &)a1;
    cout << "c1.a=" << c1.a << endl;    //c1.a=10
    //d1的内存中没有c,所以c1.c 的值为 d1中d的值
    cout << "c1.c=" << c1.c << endl;    //c1.c=100

    return 0;
}

在这里插入图片描述

分析：

  • Dog继承了 Anim，所以d1对象中 有a 也有 d；
  • 父转子，c1也指向 d1（可能会报错，编译器优化可能也不报错）

3. 重写

继承关系中，返回值类型相同，函数名形同，形参列表相同，函数体不同 。

重载

同一作用域下,函数名相同,形参列表不同

重定义

继承关系中,函数名相同即可。一旦重定义后，子类会将父类的函数覆盖掉

4. c++多态分类

多态分为：

  • 物的多态（上行、下行）

  • 事的多态（静态多态，动态多态）

4.1 静态多态(早绑定，静态联编)

概念: 在编译阶段 就确定函数的入口地址
又名: 静态联编，早绑定
如: 函数重载，运算符重载，重定义等

函数在代码区，函数名就是这个函数在代码区的地址，这个地址就是这个函数的地址

4.2 动态多态(晚绑定,动态联编)

概念: 在运行阶段确定程序入口地址
又名: 动态联编，晚绑定
如: 虚函数，重写

5. 引入

要求：设计一个函数，根据传入的对象调用重写的方式。

5.1 示例

需求：

小明开了一个宠物医院,可以给狗看病,可以给猫看病
    可以给猪看病

    张女士带着他家的狗旺财去找小明给狗看病
    李女士带着他家的猫布丁去找小明给猫看病
    王先生带着他家的猪佩奇去找小明给猪看病
    
分析:
    对象
        小明
        张女士
        李女士
        王先生
        旺财
        布丁
        佩奇
    类
        动物类
            属性:
               姓名
               
            狗类
            猫类
            猪类
            人类
                属性:
                    动物
                get与set
                宠物医生类
                    看病

代码：

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

class Anim{
private:
    char name[50];
public:
    Anim(){}
    Anim(char *name)
    {
        strcpy(this->name,name);
    }
    char* getName()
    {
        return name;
    }
    void setName(char *name)
    {
        strcpy(this->name,name);
    }
    void call()
    {
        cout << "动物叫" << endl;
    }
};
class Dog:public Anim
{
public:
    Dog(){}
    Dog(char *name):Anim(name){}
    //重写父类call方法
    void call()
    {
        cout << this->getName() << ":汪汪汪" << endl;
    }
};
class Cat:public Anim
{
public:
    Cat(){}
    Cat(char *name):Anim(name){}
    //重写父类call方法
    void call()
    {
        cout << this->getName() << ":喵喵喵" << endl;
    }
};
class Pig:public Anim
{
public:
    Pig(){}
    Pig(char *name):Anim(name){}
    //重写父类call方法
    void call()
    {
        cout << this->getName() << ":哼哼哼" << endl;
    }
};
class Person:public Anim
{
private:
    Anim* anim;
public:
    Person(){
        anim = NULL;
    }
    Person(char *name):Anim(name){}
    Person(char *name,Anim *anim):Anim(name),anim(anim){}
    ~Person()
    {
        if(anim != NULL)
        {
            delete anim;
            anim = NULL;
        }
    }
    void setAnim(Anim* anim){
        this->anim = anim;
    }
    Anim* getAnim()
    {
        return anim;
    }
    //重写父类call方法
    void call()
    {
        cout << this->getName() << ":哇哇哇" << endl;
    }
};
class AnimDoctor:public Person{
public:
    AnimDoctor(){}
    AnimDoctor(char *name):Person(name)
    {

    }
    AnimDoctor(char *name,Anim* anim):Person(name,anim)
    {

    }
    void cb(Anim* anim)
    {
        cout << this->getName() << "给" << anim->getName() << "看病" << endl;
        
        anim->call();
    }
};
int main(int argc, char *argv[])
{
    Dog * dog = new Dog("旺财");
    Cat * cat = new Cat("布丁");
    Pig * pig = new Pig("佩奇");

    Person *p1 = new Person("张女士",dog);
    Person *p2 = new Person("李女士",cat);
    Person *p3 = new Person("王先生",pig);

    AnimDoctor * doctor = new AnimDoctor("小明");

    doctor->cb(p1->getAnim());
    return 0;
}

//小明给旺财看病
//动物叫
//小明给布丁看病
//动物叫
//小明给佩奇看病
//动物叫
5.2 问题

父类有个函数 void call(){}，要求是子类继承并重写 父类 该方法，每个子类 动物在看病时，都会叫 “狗：汪汪汪，猫：喵喵喵…” ;

但是，此时现状是，每次打印出来的都是 父类 void call(){} 函数中 的 “动物叫”（子传父 上行之后调用的依旧是父类的call函数），而我们需要的是 子传父之后，调用的是每个子类特有的方法。

所以需要引入 虚函数。

6. 虚函数

概念：virtual 修饰的成员函数，就是虚函数

语法：

virtual 返回值类型 函数名(形参列表)
{
	函数体
}

注意：

  • 子类在继承父类时，会生成 虚函数指针

对比如下：以上边动物看病为例

  • 不是虚函数

在这里插入图片描述

在这里插入图片描述

  • 虚函数：下面第2幅图可以看出，子类继承了父类的 name 和 虚函数指针 vfptr ，此时指针指向的是 子类自己的 函数 Dog::call。

在这里插入图片描述

在这里插入图片描述

特点：

当 子类转换为父类 后：

  • 使用该父类调用 使用virtual修饰的函数，调用的是子类重写后的函数

  • 使用该父类调用普通函数，调用的是父类的该函数

6.1 上边示例修改
#include <iostream>
using namespace std;
#include <cstring>
class Anim{
private:
    char name[50];
public:
    Anim(){}
    Anim(char *name)
    {
        strcpy(this->name,name);
    }
    char* getName()
    {
        return name;
    }
    void setName(char *name)
    {
        strcpy(this->name,name);
    }
    virtual void call()
    {
        cout << "动物叫" << endl;
    }
};
class Dog:public Anim
{
public:
    Dog(){}
    Dog(char *name):Anim(name){}
    virtual void call()
    {
        cout << this->getName() << ":汪汪汪" << endl;
    }
};
class Cat:public Anim
{
public:
    Cat(){}
    Cat(char *name):Anim(name){}
    void call()
    {
        cout << this->getName() << ":喵喵喵" << endl;
    }
};
class Pig:public Anim
{
public:
    Pig(){}
    Pig(char *name):Anim(name){}
    void call()
    {
        cout << this->getName() << ":哼哼哼" << endl;
    }
};
class Person:public Anim
{
private:
    Anim* anim;
public:
    Person(){
        anim = NULL;
    }
    Person(char *name):Anim(name){}
    Person(char *name,Anim *anim):Anim(name),anim(anim){}
    ~Person()
    {
        if(anim != NULL)
        {
            delete anim;
            anim = NULL;
        }
    }
    void setAnim(Anim* anim){
        this->anim = anim;
    }
    Anim* getAnim()
    {
        return anim;
    }
    void call()
    {
        cout << this->getName() << ":哇哇哇" << endl;
    }
};
class AnimDoctor:public Person{
public:
    AnimDoctor(){}
    AnimDoctor(char *name):Person(name)
    {

    }
    AnimDoctor(char *name,Anim* anim):Person(name,anim)
    {

    }
    void cb(Anim* anim)
    {
        cout << this->getName() << "给" << anim->getName() << "看病" << endl;
        anim->call();
    }
};
int main(int argc, char *argv[])
{
    Dog * dog = new Dog("旺财");
    Cat * cat = new Cat("布丁");
    Pig * pig = new Pig("佩奇");

    Person *p1 = new Person("张女士",dog);
    Person *p2 = new Person("李女士",cat);
    Person *p3 = new Person("王先生",pig);

    AnimDoctor * doctor = new AnimDoctor("小明");

    doctor->cb(p1->getAnim());
    doctor->cb(p2->getAnim());
    doctor->cb(p3->getAnim());
    /*
        当子类转换为父类后
        使用该父类调用使用virtual修饰的函数,调用的是子类重写后的函数
        使用该父类调用普通函数,调用的是父类的该函数
    */
    // 虚函数所在的类,依据可以直接创建对象
    Anim a;
    return 0;
}
//小明给旺财看病
//旺财:汪汪汪
//小明给布丁看病
//布丁:喵喵喵
//小明给佩奇看病
//佩奇:哼哼哼
6.2 动态绑定的条件(重要)
有继承，子类重写父类的虚函数，父类指针或引用指向子类空间(上行)。父类指针或引用才能调用子类重写的虚函数。

错误演示:
    B b;
    //此时会调用父类的拷贝构造,会产生一个新的父类对象,该 父类对象a 与 子类对象b 是两个独立空间
    //所以此时使用a对象调用test01依据会执行父类的test01函数
    A a = b; //拷贝构造
    a.test01();
6.3 动态绑定原理(机制)(重要)
  • 父类有虚函数，产生的 虚函数指针 指向 虚函数表，表中记录的是 父类的虚函数地址。
  • 如果子类继承 父类，那么子类会继承父类的虚函数指针以及虚函数表。
  • 如果子类 重写父类的虚函数，会将将虚函数表纪录的入口地址修改成子类重写的函数入口地址。
  • 这时 父类指针指向子类空间，父类指针调用虚函数就 间接 调用子类重写的虚函数。

7. 纯虚函数

概念：父类的虚函数没有函数体

语法：

virtual 返回值类型 函数名(形参列表) = 0;

注意：

  • 纯虚函数所在的类不能 直接 创建对象，这种类被称为抽象类
  • 子类继承与抽象类，要么重写父类提供的所有纯虚函数，要么自己也是抽象类

示例：

#include <iostream>
#include <cstring>
using namespace std;
//纯虚函数所在的类称为抽象类
/*特点:
 *  1,抽象类不能直接创建对象
 *  2,子类继承与抽象类,要么重写所有纯虚函数,要么自己也是抽象类
 */
class Anim{
private:
    char name[50];
public:
    Anim(){}
    Anim(char *name)
    {
        strcpy(this->name,name);
    }
    char* getName()
    {
        return name;
    }
    void setName(char *name)
    {
        strcpy(this->name,name);
    }
    //纯虚函数
    virtual void call() = 0;
    virtual void sleep() = 0;
};
class Dog:public Anim{
public:
    Dog(){}
    Dog(char *name):Anim(name){}
    void call(){
        cout << "汪汪汪" << endl;
    }
};
class Cat:public Anim{
public:
    Cat(){}
    Cat(char *name):Anim(name){}
    void call(){
        cout << "喵喵喵" << endl;
    }
    void sleep(){
        cout << "在猫窝睡" << endl;
    }
};
int main(int argc, char *argv[])
{
    //有纯虚函数所在的类为抽象类,抽象类不能直接创建对象
    //Anim anim
    //子类继承与抽象类,要么重写所有纯虚函数,要么自己也是抽象类
    //Dog类只重写了call纯虚函数,但是没有重写sleep纯虚函数
    //所以Dog类也是抽象类,所以不能直接创建对象
    //Dog dog;
    //Cat类重写了Anim类所有的纯虚函数,所以Cat类不是抽象类
    Cat cat;

    Anim& anim = cat;
    cout << "Hello World!" << endl;
    return 0;
}

8. 虚析构造

8.1 问题引入
#include <iostream>

using namespace std;
class Anim{
public:
    Anim()
    {
        cout << "父类构造函数" << endl;
    }
    
    ~Anim(){
         cout << "父类析构函数" << endl;
    }
};

class Dog:public Anim{
public:
    Dog()
    {
        cout << "子类构造函数" << endl;
    }
    ~Dog()
    {
        cout << "子类析构函数" << endl;
    }
};
int main(int argc, char *argv[])
{
    Dog *dog = new Dog();
    Anim *anim = dog;
    delete anim;
    return 0;
}
//父类构造函数
//子类构造函数
//父类析构函数

问题：没有调用 子类析构函数

8.2 解决方案

将父类的析构函数 设置成 虚析构

虚析构函数是为了解决：基类的指针指向派生类对象，并用基类的指针删除派生类对象。

语法：

virtual ~析构函数()
{

}

示例：

#include <iostream>

using namespace std;
class Anim{
public:
    Anim()
    {
        cout << "父类构造函数" << endl;
    }
    //虚析构
    virtual ~Anim(){
         cout << "父类析构函数" << endl;
    }
};

class Dog:public Anim{
public:
    Dog()
    {
        cout << "子类构造函数" << endl;
    }
    ~Dog()
    {
        cout << "子类析构函数" << endl;
    }
};
int main(int argc, char *argv[])
{
    Dog *dog = new Dog();
    Anim *anim = dog;
    delete anim;
    return 0;
}
//父类构造函数
//子类构造函数
//子类析构函数
//父类析构函数

9. 纯虚析构(了解)

效果等同于 虚析构

语法：

virtual 析构函数名() = 0;

注意：需要在类外实现析构函数

示例：

#include <iostream>

using namespace std;
//class Anim{
//public:
//    Anim()
//    {
//        cout << "父类构造函数" << endl;
//    }
//    //虚析构
//    virtual ~Anim(){
//         cout << "父类析构函数" << endl;
//    }
//};
class Anim{
public:
    Anim()
    {
        cout << "父类构造函数" << endl;
    }
    //纯虚析构
    //类中定义
    virtual ~Anim() = 0;
};
//类外实现
Anim::~Anim()
{
    cout << "父类析构函数" << endl;
}
class Dog:public Anim{
public:
    Dog()
    {
        cout << "子类构造函数" << endl;
    }
    ~Dog()
    {
        cout << "子类析构函数" << endl;
    }
};
int main(int argc, char *argv[])
{
    Dog *dog = new Dog();
    Anim *anim = dog;
    delete anim;
    return 0;
}

virtual 析构函数名() = 0;

注意：需要在类外实现析构函数

示例：

#include <iostream>

using namespace std;
//class Anim{
//public:
//    Anim()
//    {
//        cout << "父类构造函数" << endl;
//    }
//    //虚析构
//    virtual ~Anim(){
//         cout << "父类析构函数" << endl;
//    }
//};
class Anim{
public:
    Anim()
    {
        cout << "父类构造函数" << endl;
    }
    //纯虚析构
    //类中定义
    virtual ~Anim() = 0;
};
//类外实现
Anim::~Anim()
{
    cout << "父类析构函数" << endl;
}
class Dog:public Anim{
public:
    Dog()
    {
        cout << "子类构造函数" << endl;
    }
    ~Dog()
    {
        cout << "子类析构函数" << endl;
    }
};
int main(int argc, char *argv[])
{
    Dog *dog = new Dog();
    Anim *anim = dog;
    delete anim;
    return 0;
}
小玖工作坊
关注
  • 30
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++面向对象之多态的实现和应用详解
12-31
本文主要给大家介绍的是关于C++面向对象之多态的实现和应用的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。 多态 大家应该都听过C++三大特性之一多态，那么什么多态呢？多态有什么用...
Dev-C++编译程序器
07-31
C++既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。 C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计...
大学专业试卷-C++试卷B.doc
11-29
Public成员可以被所有对象访问，Private成员只能被类的成员函数访问，Protected成员可以被类的成员函数和派生类的成员函数访问。 4. 析构函数是类的特殊成员函数，用于释放对象占用的资源。它与构造函数的区别是：...
C++对象布局及多态实现之动态和强制转换
01-19
从这部分开始我们除了利用内存的信息打印来进行探索外，更多的... 执行如下代码，它包括了对象的普通成员函数调用，类的静态成员函数调用、通过指针调用普通成员函数： C010 obj; PRINT_OBJ_ADR(obj) ob
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1010
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 146
BCSP-X 11题 C++代码详解
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 754
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 325
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 292
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
【C++】 基础复习 ｜ 数据类型，输入，输出流 scanf printf
专注于人工智能的算法与应用
06-11 828
是 C 语言中两个非常重要的标准输入输出函数，它们分别用于从标准输入（通常是键盘）读取数据和向标准输出（通常是屏幕）打印数据。在这种情况下如果想控制输出，即满足一定格式输出，比如保留几位小数什么的，就要用manipulator了。需要变量的地址 ，即前面需要加一个&。函数用于从标准输入读取数据，并根据格式字符串解析这些数据。存储内存地址的变量。用户定义的复合数据类型，用于将不同类型的数据组合在一起。称做流式输入输出，
C语言：详解gcc驱动程序完成编译、汇编、链接的过程
前进，才知道自己的渺小
06-06 1572
gcc是一个命令，严格意义上说，它只是一个驱动程序，而不是一个编译器。gcc负责调用GNU工具链中的预处理器、编译器、汇编器、链接器等工具，通过传递不同的选项给gcc命令，可以让其只完成某些步骤，比如下面的命令，用于只对源文件进行预处理。
c++【入门】买文具2
LYK_0910的博客
06-11 135
花花去文具店买了1支笔和1块橡皮，已知笔x元/支，橡皮y元/块，花花付给了老板n元，请问老板应该找给花花多少钱？三个整数x、y、n，分别代表了笔的单价、橡皮的单价和花花付给老板的钱（已知花花付给老板的钱n>=x+y）。一个整数，代表老板应该找给花花的钱。内存限制 : 128 MB。时间限制 : 1 秒。
深度搜索算法3（c++）
mmz1207的博客
06-08 387
农夫约翰总是想要一个农场的地图，所以他拍摄了一张N行M列的卫星照片。一部分的照片看起来像这样： 他认为每个联通块都是一个谷仓或一头奶牛。农夫约翰认为一个联通块是谷仓，当且仅当它是一个完整的矩形，否则该联通块是一头奶牛。在下面的照片中，有三个谷仓（大小分别为2x1,2x5和1x1）和两头奶牛。计算他的卫星照片中谷仓和奶牛的数量。行2..N + 1：行i + 1表示照片的行i包含M个字 符（且不含空格）。行1：两个空格分隔的整数：N和M。行1：照片中的谷仓数量。行2：照片中的奶牛数量。
C语言，struct 结构体、union共用体的使用
sinat_30943509的博客
06-12 518
/状态字节，根据数据定义几个标志，标志位依据联合体内部结构体进行变量定义。//目的，节省内存空间，省去特定字节。
C++回溯算法
Yigeputongren的博客
06-11 100
【代码】C++回溯算法。
ARM 汇编 C语言 for循环
最新发布
haojie
06-12 645
在使用 Keil 编译基于 STM32F103 的 C 语言程序时，生成的汇编代码会有一些不同。使用 Keil 编译器（如 ARMCC 或 ARMCLANG）编译上述代码，生成的汇编代码可能类似于以下内容。注意，这只是一个近似的手写示例，实际生成的代码可能会有所不同。使用 Keil 编译器时，可以通过查看生成的 .lst 或 .asm 文件来查看编译后的汇编代码。实际生成的汇编代码可能会根据具体的编译器优化选项和编写的 C 代码有所不同。同时可以看下这篇文章。
C++ Easyx案例实战：Cookie Maker工作室1.0V
快乐星空Maker的博客
06-09 723
有彩蛋！
C++ opengl 纹理映射
sss_brs的博客
06-12 108
老样子，改出来的，问GPT。
C++:SLT容器--＞queue
坚持不懈的大白的博客
06-11 228
C++:SLT容器-->queue
c++类的多态类对象大小
08-06
C++中的多态类对象的大小取决于其成员变量和虚函数的数量和类型。一个多态类对象的大小由以下几个因素决定： 1. 成员变量：多态类对象中包含的成员变量所占用的空间大小会影响对象的总大小。每个成员变量都占用一定...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值