C++中的多态

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量883 收藏 17
点赞数 23
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53795212/article/details/137638095
版权

1. 多态的基本概念

多态是C++面向对象的三大特性之一

多态分为两类：

  • 静态多态：函数重载 和 运算符重载 属于静态多态，即复用函数名
  • 动态多态：派生类 和 虚函数 实现运行时多态

静态多态和动态多态的区别：

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址
  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

案例：

#include<iostream>
using namespace std;

//多态

//动物类
class Animal
{
public:
    //定义为虚函数，在程序执行时才绑定函数地址
    virtual void speak()
    {
        cout << "动物在说话" << endl;
    }
};

//猫类
class Cat : public Animal
{
public:
    //重写父类的虚函数（speak 函数），函数返回值类型、函数名、参数列表要完全相同
    void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

//狗类
class Dog : public Animal
{
public:
    //重写父类的虚函数（speak 函数），函数返回值类型、函数名、参数列表要完全相同
    void speak()
    {
        cout << "小狗在说话" << endl;
    }
};

//地址早绑定，在编译阶段就确定了函数的地址
//如果想让猫说话，函数地址不能提前绑定，要在程序执行时绑定函数地址
void doSpeak(Animal &animal)  //Animal &animal = cat;
{
    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat);

    Dog dog;
    doSpeak(dog);
}

int main()
{
    test01();

    return 0;
}


输出：
---------------------------------------------------------------------------------
小猫在说话
小狗在说话

总结

实现动态多态要满足的条件：

  • 有继承关系
  • 父类中的函数指定为虚函数
  • 子类重写父类的虚函数

多态使用条件：

  • 在类外函数中，形参指定为父类的指针或引用，调用函数时指向子类对象

区分重写和重载：

  • 重写：函数返回值类型 函数名 参数列表 完全一致
  • 重载：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

2. 多态原理

定义父类内函数为虚函数时，会创建一个虚函数指针vfptr，指向一个虚函数表vftable，在表中保存虚函数的函数入口地址&Animal :: speak，此时若子类继承该父类，子类中也会复制一份同样的虚函数指针和虚函数表，如下图所示：

当子类重写父类的虚函数时，子类虚函数表中的内容会被替换成子类的虚函数地址&Cat :: speak，如下图所示：

示例：

#include<iostream>
using namespace std;

//多态

//动物类
class Animal1
{
public:
    //定义为虚函数，在程序执行时才绑定函数地址
    void speak()
    {
        cout << "动物1在说话" << endl;
    }
};

class Animal2
{
public:
    //定义为虚函数，在程序执行时才绑定函数地址
    virtual void speak()
    {
        cout << "动物2在说话" << endl;
    }
};


void test01()
{
    cout << "size of Animal1: " << sizeof(Animal1) << endl;
    cout << "size of Animal2: " << sizeof(Animal2) << endl;
}

int main()
{
    test01();

    return 0;
}


输出：
---------------------------------------------------------------------------------
size of Animal1: 1
size of Animal2: 8

3. 多态案例一：计算器类

案例描述：

分别用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

多态优点：

  • 代码组织结构清晰
  • 可读性强
  • 利用前期和后期的扩展以及维护

示例：

#include<iostream>
using namespace std;

//分别利用普通写法和多态技术实现一个计算器类

//普通写法
//如果想扩展新的功能，需要修改源码
//在真实场景中，提倡：开闭原则
class Calculator
{
public:

    int getResult(string oper)
    {
        if (oper == "+")
        {
            return m_num1 + m_num2;
        }
        else if (oper == "-")
        {
            return m_num1 - m_num2;
        }
        else if (oper == "*")
        {
            return m_num1 * m_num2;
        }
        else if (oper == "/")
        {
            if (m_num2 == 0)
            {
                cout << "Error: Division by zero." << endl;
                return 0; // 在实际应用中，这里可能需要更复杂的错误处理
            }
            return m_num1 / m_num2;
        }

        // 如果操作符不匹配，抛出异常
        cout << "Error: Invalid operation." << endl;
        return 0;
    }

    int m_num1;  //操作数1
    int m_num2;  //操作数2
};


void test01()
{
    //创建计算器对象
    Calculator c;

    c.m_num1 = 10;
    c.m_num2 = 10;

    cout << c.m_num1 << " + " << c.m_num2 << " = " << c.getResult("+") << endl;
    cout << c.m_num1 << " - " << c.m_num2 << " = " << c.getResult("-") << endl;
    cout << c.m_num1 << " * " << c.m_num2 << " = " << c.getResult("*") << endl;
    cout << c.m_num1 << " / " << c.m_num2 << " = " << c.getResult("/") << endl;
}


//利用多态实现计算器
// 多态优点：
// ● 代码组织结构清晰
// ● 可读性强
// ● 利用前期和后期的扩展以及维护

//实现计算器类抽象
class AbstractCalculator
{
public:

    virtual int getResult()
    {
        return 0;
    }

    int m_num1;  //操作数1
    int m_num2;  //操作数2
};

//加法计算器类
class AddCalculator : public AbstractCalculator
{
public:

    int getResult()
    {
        return m_num1 + m_num2;
    }
};

//减法计算器类
class SubCalculator : public AbstractCalculator
{
public:

    int getResult()
    {
        return m_num1 - m_num2;
    }
};

//乘法计算器类
class MulCalculator : public AbstractCalculator
{
public:

    int getResult()
    {
        return m_num1 * m_num2;
    }
};

//除法计算器类
class DivCalculator : public AbstractCalculator
{
public:

    int getResult()
    {
        if (m_num2 == 0)
        {
            cout << "Error: Division by zero." << endl;
            return 0; // 在实际应用中，这里可能需要更复杂的错误处理
        }
        return m_num1 / m_num2;
    }
};

void test02()
{
    //多态使用要满足：父类指针或者引用指向子类对象

    //加法运算
    AbstractCalculator * abc = new AddCalculator;
    abc->m_num1 = 100;
    abc->m_num2 = 100; 

    cout << abc->m_num1 << " + " << abc->m_num2 << " = " << abc->getResult() << endl;
    //用完后，手动销毁堆区数据
    delete abc;

    //减法运算
    abc = new SubCalculator;
    abc->m_num1 = 100;
    abc->m_num2 = 100; 

    cout << abc->m_num1 << " - " << abc->m_num2 << " = " << abc->getResult() << endl;
    //用完后，手动销毁堆区数据
    delete abc;

    //乘法运算
    abc = new MulCalculator;
    abc->m_num1 = 100;
    abc->m_num2 = 100; 

    cout << abc->m_num1 << " * " << abc->m_num2 << " = " << abc->getResult() << endl;
    //用完后，手动销毁堆区数据
    delete abc;

    //除法运算
    abc = new DivCalculator;
    abc->m_num1 = 100;
    abc->m_num2 = 100; 

    cout << abc->m_num1 << " / " << abc->m_num2 << " = " << abc->getResult() << endl;
    //用完后，手动销毁堆区数据
    delete abc;
}


int main()
{
    test01();
    cout << "-------------------------" << endl;
    test02();

    return 0;
}


输出：
--------------------------------------------------------------------------------
10 + 10 = 20
10 - 10 = 0
10 * 10 = 100
10 / 10 = 1
-------------------------
100 + 100 = 200
100 - 100 = 0
100 * 100 = 10000
100 / 100 = 1

4. 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型 函数名 (参数列表) = 0;

当类中有了纯虚函数，这个类也被称作抽象类

抽象类的特点：

  • 无法实例化对象，只能找个儿子去继承
  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

示例：

#include<iostream>
using namespace std;

//纯虚函数和抽象类
class Base
{
public:

    //类中只要有一个纯虚函数，那么这个类就是抽象类
    //抽象类的特点：
    // ● 无法实例化对象，只能找个儿子去继承
    // ● 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
    virtual void func() = 0;
    
};

class Son : public Base
{
public:
    void func()
    {
        cout << "Son类的func函数调用" << endl;
    }
};

void test01()
{
    // Base b;  //抽象类在栈区不能实例化对象
    // new Base;  //抽象类在堆区不能实例化对象

    // Son s;  //子类必须重写父类中的纯虚函数，否则无法实例化对象
    // s.func();

    //使用new关键字创建了一个Son类型的对象，并将其地址赋给了一个指向Base类型的指针base。
    Base * base = new Son;
    base->func();
    delete base;

    // Base & base = s;
    // base.func();
}

int main()
{
    test01();

    return 0;
}


输出：
---------------------------------------------------------------------------------
Son类的func函数调用

5. 多态案例二：制作饮品

案例描述：

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

示例：

#include<iostream>
using namespace std;

//多态案例二：制作饮品
class AbstractDrinking
{
public:

    //煮水
    virtual void Boil() = 0;

    //冲泡
    virtual void Brew() = 0;

    //倒入杯中
    virtual void PourInCup() = 0;

    //加入辅料
    virtual void AddCondiments() = 0;

    //制作饮品
    void MakeDrink()
    {
        Boil();
        Brew();
        PourInCup();
        AddCondiments();
    }
};

//制作咖啡
class Coffee : public AbstractDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout << "煮农夫山泉" << endl;
    }

    //冲泡
    virtual void Brew()
    {
        cout << "冲泡雀巢咖啡" << endl;
    }

    //倒入杯中
    virtual void PourInCup()
    {
        cout << "倒入水晶杯中" << endl;
    }

    //加入辅料
    virtual void AddCondiments()
    {
        cout << "加入糖和牛奶" << endl;
    }
};

//制作茶叶
class Tea : public AbstractDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout << "煮百岁山" << endl;
    }

    //冲泡
    virtual void Brew()
    {
        cout << "冲泡茶叶" << endl;
    }

    //倒入杯中
    virtual void PourInCup()
    {
        cout << "倒入陶瓷杯中" << endl;
    }

    //加入辅料
    virtual void AddCondiments()
    {
        cout << "加入枸杞" << endl;
    }
};

//制作函数
void doWork(AbstractDrinking *abs)
{
    abs->MakeDrink();
    delete abs;
}

void test01()
{
    //制作咖啡
    doWork(new Coffee);

    cout << "--------------------------" << endl;

    //制作茶叶
    doWork(new Tea);
}

int main()
{
    test01();
    
    return 0;
}


输出：
--------------------------------------------------------------------------------
煮农夫山泉
冲泡雀巢咖啡
倒入水晶杯中
加入糖和牛奶
--------------------------
煮百岁山
冲泡茶叶
倒入陶瓷杯中
加入枸杞

6. 虚析构和纯虚析构

多态使用时，父类的指针或引用会指向子类对象，但无法访问子类的析构函数。如果子类的析构函数中有属性开辟到堆区，那么父类指针在释放堆内存时，无法释放子类析构函数中的堆内存。

解决方式：将父类中的析构函数改为虚析构或纯虚析构

虚析构和纯虚析构的共性：

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

虚析构和纯虚析构的区别：

  • 如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：virtual ~类名()

纯虚析构语法：virtual ~类名() = 0;

示例：

#include<iostream>
using namespace std;

//虚析构和纯虚析构
class Animal
{
public:

    Animal()
    {
        cout << "Animal 构造函数调用" << endl;
    }

    //利用虚析构，可以解决父类指针释放子类对象时，子类析构函数没有被调用的问题
    // virtual ~Animal()
    // {
    //     cout << "Animal 虚析构函数调用" << endl;
    // }

    //纯虚析构也可以解决这个问题，但需要有声明和实现
    //纯虚析构的声明，有了纯虚析构后，这个类也属于抽象类，不能实例化对象
    virtual ~Animal() = 0;

    //纯虚函数
    virtual void speak() = 0;
};

//纯虚析构的实现
Animal::~Animal()
{
    cout << "Animal 纯虚析构函数调用" << endl;
}


class Cat : public Animal
{
public:

    Cat(string name)
    {
        cout << "Cat 构造函数调用" << endl;
        m_name = new string(name);
    }

    void speak()
    {
        cout << *m_name << " 猫在说话" << endl;
    }

    ~Cat()
    {
        if (m_name != NULL)
        {
            cout << "Cat 析构函数调用" << endl;
            delete m_name;
            m_name = NULL;
        }
    }

    string *m_name;
};

void test01()
{
    Animal *animal = new Cat("Tom");
    animal->speak();
    //父类指针在析构时，不会调用子类中的析构函数，导致子类如果有堆区属性，会发生内存泄漏
    delete animal;
}

int main()
{
    test01();

    return 0;
}


输出：
---------------------------------------------------------------------------------
Animal 构造函数调用
Cat 构造函数调用
Tom 猫在说话
Cat 析构函数调用
Animal 纯虚析构函数调用

总结：

  1. 虚析构和纯虚析构时父类中的概念，且不能同时存在
  2. 虚析构和纯虚析构的作用相同，就是用来解决通过父类指针释放子类对象的问题
  3. 如果子类中没有堆区数据，可以不写虚析构和纯虚析构
  4. 拥有纯虚析构函数的类也属于抽象类

7. new关键字进阶

7.1. new关键字的用法

在C++中，new关键字用于动态分配内存。它可以用来创建单个对象或对象数组，并返回指向新分配的内存的指针。new后面可以跟多种类型的说明符，用以指定需要分配的内存类型。这里是一些常见的用法：

  1. 基本数据类型：可以使用new来分配基本数据类型（如int、float、char等）的内存。
int* pInt = new int;
float* pFloat = new float;
  1. 类类型：可以分配自定义类或结构体的实例。
MyClass* pObj = new MyClass;
  1. 数组：可以分配一个指定大小的数组。数组元素可以是基本数据类型或对象。
int* pArray = new int[10]; // 分配有10个整数的数组
MyClass* pObjects = new MyClass[5]; // 分配包含5个MyClass对象的数组
  1. 带括号的构造函数参数：可以在使用new创建类实例时传递构造函数参数。
MyClass* pObj = new MyClass(arg1, arg2);
  1. 带初始值的基本数据类型：可以为基本数据类型指定初始值。
int* pInt = new int(42);
  1. 带初始化列表的数组：C++11开始，可以为数组元素提供一个初始化列表。
int* pArray = new int[4]{1, 2, 3, 4};
  1. 带圆括号或花括号的初始化：C++11允许使用圆括号或花括号初始化对象，包括基本数据类型和类类型。
int* pInt = new int{42};
MyClass* pObj = new MyClass{arg1, arg2};
  1. 放置new（placement new）：这是一种高级用法，允许在已分配的内存（指定位置）上构造对象。这不分配内存，但调用构造函数来初始化内存。
void* pMemory = malloc(sizeof(MyClass));
MyClass* pObj = new(pMemory) MyClass;

new的这些用法提供了灵活的动态内存分配机制。使用new分配的内存通常需要使用delete（对于单个对象）或delete[]（对于对象数组）来释放，以避免内存泄露。

7.2. 大厂面试：放置new（Placement new）

放置new是C++中的一个高级功能，它允许在已经分配的内存上构造对象，而不是由new表达式分配新内存。这种用法特别适用于需要在特定位置构造对象或需要细粒度控制内存分配的场合。我们来逐步解析这个过程：

7.2.1. 步骤 1: 分配内存

首先，你需要有一块已经分配好的内存。这块内存可以来自多种来源，比如使用malloc从堆上分配、来自一个大的内存池、或者是一个已经存在的、足够大的对象。

void* pMemory = malloc(sizeof(MyClass)); // 使用malloc分配足够存储MyClass对象的内存

这里，我们使用malloc为MyClass类型的对象分配了足够的内存。注意，malloc返回的是一个void*类型的指针，表示这块内存是未类型化的。

7.2.2. 步骤 2: 使用放置new构造对象

一旦有了这块内存，你就可以使用放置new在这块特定的内存上构造一个对象。语法上，放置new看起来像是传递一个额外的参数给new操作符：

MyClass* pObj = new(pMemory) MyClass;

在这个表达式中，pMemory是我们提供给放置new的内存地址。MyClass是我们想要构造的对象类型。这个操作不会分配新的内存，而是在pMemory指向的位置上调用MyClass的构造函数来初始化对象。

7.2.3. 细节解释

放置new的工作原理是重载new操作符。C++标准库提供了这样的重载版本：

void* operator new(size_t, void* p) noexcept;

这个版本的new接受一个size_t大小（通常是由编译器自动提供，对应于对象的大小）和一个指向已分配内存的指针。这个重载仅仅返回传入的指针，实际上不进行任何内存分配。

7.2.4. 使用场景
  • 内存池：当你有一大块预分配的内存，并希望在其中高效地分配和回收小块内存时，放置new非常有用。
  • 缓存对齐：某些硬件或特定的性能优化要求对象按照特定的边界对齐。通过放置new，你可以确保对象在满足这些要求的地址上构造。
  • 异常安全：在已分配内存中构造对象可以避免在内存分配失败时处理复杂的异常逻辑。
7.2.5. 注意事项
  • 使用放置new需要确保分配的内存足够大且正确对齐，以存放指定类型的对象。
  • 由于malloc和new有不同的内存释放机制（free vs. delete），使用放置new在malloc分配的内存上构造对象时，需要手动调用对象的析构函数，然后使用free释放内存。

例如，销毁在上述例子中创建的对象：

pObj->~MyClass(); // 显式调用析构函数
free(pMemory); // 释放内存

放置new提供了一种灵活的方式来在特定的内存位置上构造对象，但它也要求开发者对内存管理有深入的理解，以避免错误使用。

8. 多态案例三：电脑组装

案例描述：

  1. 电脑主要组成部件为CPU（用于计算），显卡（用于显示），内存条（用于存储）
  2. 将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如：Inter厂商、Lenovo厂商
  3. 创建电脑类提供让电脑工作的函数，并且调用每个零件工作接口
  4. 测试时组装三台不同的电脑进行工作

示例：

#include<iostream>
using namespace std;

//多态案例三：电脑组装

//1、抽象出配件类

//1.1 CPU抽象类
class CPU
{
public:

    virtual void calculate() = 0;
};

//1.2 显卡抽象类
class VideoCard
{
public:

    virtual void display() = 0;
};

//1.3 内存条抽象类
class Memory
{
public:

    virtual void storage() = 0;
};

//2、电脑类
class Computer
{
public:

    Computer(CPU *cpu, VideoCard *vc, Memory *mem)
    {
        m_cpu = cpu;
        m_videoCard = vc;
        m_memory = mem;
    }

    void doWork()
    {
        m_cpu->calculate();
        m_videoCard->display();
        m_memory->storage();
    }

    //提供析构函数，释放电脑零件占用的内存
    ~Computer()
    {
        if (m_cpu != NULL)
        {
            delete m_cpu;
            m_cpu = NULL;
        }

        if (m_videoCard != NULL)
        {
            delete m_videoCard;
            m_videoCard = NULL;
        }

        if (m_memory != NULL)
        {
            delete m_memory;
            m_memory = NULL;
        }
    }

private:

    CPU *m_cpu;  //CPU的零件指针
    VideoCard *m_videoCard;  //显卡的零件指针
    Memory *m_memory;  //内存条的零件指针
};

//3、具体零件厂商类

//3.1 Intel CPU
class InterCpu : public CPU
{
public:

    void calculate()
    {
        cout << "Intel CPU 计算" << endl;
    }
};

//3.2 Lenovo CPU
class LenovoCpu : public CPU
{
public:

    void calculate()
    {
        cout << "Lenovo CPU 计算" << endl;
    }
};

//3.3 Intel 显卡
class InterVideoCard : public VideoCard
{
public:

    void display()
    {
        cout << "Intel 显卡开始显示" << endl;
    }
};

//3.4 Lenovo 显卡
class LenovoVideoCard : public VideoCard
{
public:

    void display()
    {
        cout << "Lenovo 显卡开始显示" << endl;
    }
};

//3.5 Intel 内存条
class InterMemory : public Memory
{
public:

    void storage()
    {
        cout << "Intel 内存条开始存储" << endl;
    }
};

//3.6 Lenovo 内存条
class LenovoMemory : public Memory
{
public:

    void storage()
    {
        cout << "Lenovo 内存条开始存储" << endl;
    }
};

//4、测试（组装电脑）
void test()
{
    //1、第一台电脑组装
    //1.1 第一台电脑的零件
    CPU *inter_cpu = new InterCpu;
    VideoCard *inter_card = new InterVideoCard;
    Memory *Inter_mem = new InterMemory;

    //1.2 创建电脑
    Computer *computer1 = new Computer(inter_cpu, inter_card, Inter_mem);

    //1.3 电脑工作
    cout << "第一台电脑开始工作：" << endl;
    computer1->doWork();

    //1.4 释放内存
    delete computer1;

    cout << "------------------------------------------------" << endl;
    cout << "第二台电脑开始工作：" << endl;

    //2、第二台电脑组装
    Computer *computer2 = new Computer(new LenovoCpu, new LenovoVideoCard, new LenovoMemory);
    computer2->doWork();
    delete computer2;

    cout << "------------------------------------------------" << endl;
    cout << "第三台电脑开始工作：" << endl;

    //2、第三台电脑组装
    Computer *computer3 = new Computer(new InterCpu, new LenovoVideoCard, new InterMemory);
    computer3->doWork();
    delete computer3;

}

 
int main()
{
    test();

    return 0;
}


输出：
-------------------------------------------------------------------------------
第一台电脑开始工作：
Intel CPU 计算
Intel 显卡开始显示
Intel 内存条开始存储
------------------------------------------------
第二台电脑开始工作：
Lenovo CPU 计算
Lenovo 显卡开始显示
Lenovo 内存条开始存储
------------------------------------------------
第三台电脑开始工作：
Intel CPU 计算
Lenovo 显卡开始显示
Intel 内存条开始存储
大模型算法和部署
关注
  • 23
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
c++中多态的理解
仗劍走天涯
11-18 924
多态的定义：同一种操作作用于不同的对象，有不同的解释，产生不同的结果。 c++中的多态分为两类： 1.编译时的多态：类中非虚成员的参数和返回值，确定不同的操作。 2.运行时的多态：到程序的运行的时候，才根据实际情况决定实现何种操作。派生类继承并覆写基类的虚函数成员。 以下是运行时多态的一个简单示例： #include "stdafx.h" #include <iostream&g...
从汇编看c++中多态的应用
12-26
在c++中，当一个类含有虚函数的时候，类就具有了多态性。构造函数的一项重要功能就是初始化vptr指针，这是保证多态性的关键步骤。构造函数初始化vptr指针下面是c++源码: 代码如下:class X {private: int i;public:...
C++中多态使用详细讲解
weixin_45805339的博客
12-01 1129
多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。多态就是同一个行为具有多个不同表现形式或形态的能力，指的就是行为的多态。比如动物的爬行行为,小狗老虎,兔子它们各自的爬行方式是不同的，再比如草本植物都有自己的药物功能，他们所对应的药物功能不一样。
C++：多态 详解
zhang_si_hang的博客
08-05 2万+
多态的概念：通俗来说，就是多种形态，。举个例子：比如，当买票时，是全价买票；买票时，是半价买票；买票时是优先买票。再举个栗子：最近为了，支付宝年底经常会做诱人的的活动。那么大家想想为什么有人扫的红包又大又新鲜8块、10块...，而有人扫的红包都是1毛，5毛....。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如你没有经常支付宝支付等等，那么你需要被鼓励使用支付宝，那么就你扫码金额=；.................................
C++ 多态 超详细讲解
热门推荐
qq_53558968的博客
05-18 5万+
文章目录多态概念引入1、C++中多态的实现1.1 多态的构成条件1.2 虚函数1.3虚函数的重写1.4 C++11 override && final1.5 重载，覆盖(重写)，重定义（隐藏）2、抽象类2.1 抽象类的概念2.2 接口继承和实现继承3、 多态的原理3.1 虚函数表3.2多态的原理3.3动态绑定与静态绑定4 、继承中的虚函数表4.1 单继承中的虚函数表4.2 多继承中的虚函数表other 一些有意思的题目 多态概念引入 多态字面意思就是多种形态。 我们先来想一想在日常生活中
【C++】多态
QiHai的博客
11-04 1447
本篇我会揭开C++中多态这一层神秘的面纱，理解C++中多态的实现，底层逻辑。做到比较熟悉的掌握C++面向对象的相关知识。
C++之多态详解
be_a_struggler的博客
11-15 2006
C++多态，多态的概念，多态的定义及实现，虚函数，虚函数的重写，抽象类，多态的原理，单继承和多继承关系中的虚函数表 多态常见的面试题
12 C++的多态
精致的灰的博客
11-20 2万+
文章目录一、多态的概念1.1. 多态的构成条件二、虚函数2.1. 虚函数的重写2.2. 虚函数重写的例外协变：父类与子类虚函数返回值类型不同析构函数的重写(基类与派生类析构函数的名字不同)三、C++11 override和final3.1. final：修饰虚函数，表示该虚函数不能再被重写3.2. override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错四、重载、覆盖(重写)、隐藏(重定义)的对比五、抽象类5.1. 抽象类有什么用六、多态的应用场景举例七、多态的实现原理7.1. 虚函
C++中多态的概念和意义
木子皿--啥都不会的菜鸟
02-12 880
文章目录1 C++中多态的概念和意义1.1 函数重写回顾1.2 多态的概念1.3 多态的意义1.4 静态联编和动态联编 1 C++中多态的概念和意义 1.1 函数重写回顾 对于函数重写： 父类被重写的函数依然会继承给子类。 子类中重写的函数将覆盖父类中的函数。 通过作用域分辨符（::）可以访问到父类中的函数。 1.2 多态的概念 面向对象中期望的行为： 根据实际的对象类型判断如何调用重写函...
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
C++之多态(内容不错)
01-20
什么是多态？ 顾名思义就是同一个事物在不同场景下的多种形态。   下面会具体的详细的介绍。 静态多态 我们以前说过的函数重载就是一个简单的静态多态 int Add(int left, int right) { return left + right; } ...
c++多态总结
08-30
c++多态总结，vptr总结，多态原理探究
从汇编看c++中的多态
12-22
在c++中，当一个类含有虚函数的时候，类具有了多态性。构造函数的一项重要功能是初始化vptr指针，这是保证多态性的关键步骤。 　构造函数初始化vptr指针 　下面是c++源码： class X { private:  int i; ...
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 274
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 908
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
clang frontEnd插件 常见Traverse函数、Visit函数 例子
_
05-17 69
clang插件
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 262
C语言如何在链表中的指定位置插⼊结点？
PyQt5 中的 List View
xy_optics的博客
05-16 823
有时候，标准模型可能无法满足特定的需求，这时可以自定义数据模型。自定义模型需要继承自 QAbstractItemModel 类，并实现一些关键的方法，如 data()、rowCount()、columnCount() 等，以便 List View 能够正确地显示数据。# 自定义数据模型类return 1# 使用自定义模型。
c++中多态实现原理
08-30
在 C 中，多态可以通过函数指针和结构体来实现。具体的实现原理如下： 1. 定义基类（父类）结构体：首先需要定义一个包含成员函数指针的结构体，代表基类。这些成员函数指针指向不同派生类中具体的函数实现。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值