当前位置： 首页 > article >正文

每日一问：C++ 中重写和重载的区别

article 2024/11/13 23:41:18

每日一问：C++ 中重写和重载的区别

在 C++ 编程中，重载（Overloading）和重写（Overriding）是实现多态的重要手段，但它们在实现机制和应用场景上有着本质区别。重载用于在同一个作用域中定义多个同名函数，但参数不同；重写用于在派生类中重新定义基类的虚函数。本文将通过示例和代码详细讲解重写和重载的区别，帮助读者掌握这两个概念在实际编程中的应用。

摘要

本文详细讨论了 C++ 中的重载和重写的区别，结合代码示例分析了它们的使用场景和实现机制。文章涵盖了函数重载、运算符重载、虚函数重写等内容，并通过表格总结了重载和重写的主要区别。

一、概述

1.1 什么是重载？

重载（Overloading）是指在同一个作用域内定义多个同名函数，但参数列表不同。函数重载是 C++ 中静态多态（编译时多态）的一种实现方式。重载函数在编译时根据参数的类型、数量或顺序进行区分，允许同一函数名具有多种不同的实现。

1.2 什么是重写？

重写（Overriding）是指派生类中重新定义基类中的虚函数。重写实现了动态多态（运行时多态），允许派生类根据自身需要覆盖基类的实现。通过重写，派生类可以在调用时执行不同的函数逻辑，从而实现多态。
在 C++ 中，实现多态的手段可以分为两种：静态多态和动态多态。静态多态是在编译时确定的，而动态多态则是在运行时决定的，这两个概念是 C++ 中实现多态的核心。

1.3 静态多态

静态多态（Static Polymorphism）是通过函数重载和运算符重载实现的。在静态多态中，函数的选择是在编译时完成的。编译器根据函数的参数类型、数量和顺序来确定调用哪个重载函数。静态多态不会影响程序的运行速度，因为所有的决定都是在编译时完成的。

示例代码：函数重载实现静态多态

#include <iostream>
using namespace std;

class Math {
public:
    // 重载 add 函数，实现静态多态
    int add(int a, int b) {
        return a + b;
    }

    // 重载 add 函数，接收不同数量的参数
    double add(double a, double b) {
        return a + b;
    }

    // 重载 add 函数，接受三个参数
    int add(int a, int b, int c) {
        return a + b + c;
    }
};

int main() {
    Math math;  // 创建 Math 对象
    cout << "Add integers: " << math.add(5, 3) << endl;  // 调用第一个重载的 add
    cout << "Add doubles: " << math.add(2.5, 3.5) << endl;  // 调用第二个重载的 add
    cout << "Add three integers: " << math.add(1, 2, 3) << endl;  // 调用第三个重载的 add
    return 0;
}

解释：在上述代码中，Math 类的 add 函数通过重载实现了静态多态。编译器根据传递给 add 函数的参数类型和数量，选择相应的重载函数进行调用。这种多态在编译时就已经确定了函数调用的具体实现。

1.4 动态多态

动态多态（Dynamic Polymorphism）是通过虚函数（Virtual Function）和重写（Overriding）来实现的。在动态多态中，函数的选择是在运行时完成的，通常使用基类指针或引用来调用派生类的重写函数。动态多态的主要特征是通过运行时决定调用的函数版本，从而实现更灵活的程序行为。

示例代码：重写实现动态多态

#include <iostream>
using namespace std;

// 基类 Shape 定义虚函数 draw
class Shape {
public:
    virtual void draw() {  // 定义虚函数
        cout << "Drawing Shape" << endl;
    }
};

// 派生类 Circle 重写基类的 draw 函数
class Circle : public Shape {
public:
    void draw() override {  // 重写虚函数
        cout << "Drawing Circle" << endl;
    }
};

// 派生类 Square 重写基类的 draw 函数
class Square : public Shape {
public:
    void draw() override {  // 重写虚函数
        cout << "Drawing Square" << endl;
    }
};

int main() {
    Shape* shape1 = new Circle();  // 创建 Circle 对象
    Shape* shape2 = new Square();  // 创建 Square 对象

    shape1->draw();  // 调用 Circle 的 draw
    shape2->draw();  // 调用 Square 的 draw

    delete shape1;  // 释放内存
    delete shape2;  // 释放内存
    return 0;
}

解释：在这个示例中，Shape 是基类，Circle 和 Square 是派生类，它们分别重写了基类的 draw() 函数。在主函数中，通过基类指针调用派生类的重写函数，演示了动态多态的实现。

1.5 静态多态与动态多态的对比

特性静态多态（Static Polymorphism）动态多态（Dynamic Polymorphism）
实现手段函数重载、运算符重载虚函数、重写
绑定时间编译时绑定运行时绑定
效率高，编译时已决定函数调用相对较低，需在运行时决定调用函数
灵活性低，需在编译时确定高，支持运行时的多态行为
应用场景重载相同功能的不同实现，如数学运算符接口设计、需要根据对象类型调用不同实现时

二、重载的实现与应用

2.1 重载的实现方式

  • 函数重载：通过在同一类或作用域内定义多个参数不同的同名函数实现重载。
  • 运算符重载：允许重新定义或扩展内置运算符的功能，使其用于用户定义类型。

2.2 函数重载示例

以下代码展示了函数重载的实现方式：

#include <iostream>
using namespace std;

class Calculator {
public:
    // 重载 add 函数，接收两个整数
    int add(int a, int b) {
        return a + b;
    }

    // 重载 add 函数，接收三个整数
    int add(int a, int b, int c) {
        return a + b + c;
    }

    // 重载 add 函数，接收两个浮点数
    double add(double a, double b) {
        return a + b;
    }
};

int main() {
    Calculator calc;  // 创建 Calculator 对象
    cout << "Add two integers: " << calc.add(3, 5) << endl;  // 调用两个参数的 add 函数
    cout << "Add three integers: " << calc.add(1, 2, 3) << endl;  // 调用三个参数的 add 函数
    cout << "Add two doubles: " << calc.add(2.5, 3.8) << endl;  // 调用两个浮点数参数的 add 函数
    return 0;
}

解释：在这个示例中，Calculator 类中的 add 函数被重载了三次，每次参数的类型或数量不同。根据调用时传递的参数，编译器选择匹配的函数。

2.3 运算符重载示例

#include <iostream>
using namespace std;

class Complex {
private:
    double real;  // 实部
    double imag;  // 虚部

public:
    // 构造函数
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // 重载 + 运算符
    Complex operator+(const Complex& other) {
        return Complex(real + other.real, imag + other.imag);
    }

    // 打印复数
    void print() {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);  // 创建 Complex 对象 c1
    Complex c2(1.0, 2.0);  // 创建 Complex 对象 c2
    Complex c3 = c1 + c2;  // 使用重载的 + 运算符进行复数相加
    c3.print();  // 打印结果
    return 0;
}

解释：在这个示例中，+ 运算符被重载用于 Complex 类型的相加，实现了自定义数据类型的运算符扩展。

三、重写的实现与应用

3.1 重写的实现方式

  • 重写要求基类中的函数必须是虚函数。
  • 派生类中重写的函数必须与基类中的虚函数签名一致。

3.2 重写的应用场景

重写用于在派生类中修改基类的行为，是实现动态多态的核心。通过重写，派生类能够根据实际需要改变基类的默认行为。

3.3 虚函数重写示例

以下代码展示了重写的实现方式：

#include <iostream>
using namespace std;

// 定义基类 Animal
class Animal {
public:
    virtual void makeSound() {  // 定义虚函数 makeSound
        cout << "Animal sound" << endl;
    }
};

// 定义派生类 Dog，重写基类的 makeSound 函数
class Dog : public Animal {
public:
    void makeSound() override {  // 重写虚函数
        cout << "Bark" << endl;
    }
};

// 定义派生类 Cat，重写基类的 makeSound 函数
class Cat : public Animal {
public:
    void makeSound() override {  // 重写虚函数
        cout << "Meow" << endl;
    }
};

int main() {
    Animal* a1 = new Dog();  // 创建 Dog 对象并赋值给基类指针
    Animal* a2 = new Cat();  // 创建 Cat 对象并赋值给基类指针

    a1->makeSound();  // 调用 Dog 的 makeSound 函数
    a2->makeSound();  // 调用 Cat 的 makeSound 函数

    delete a1;  // 释放对象内存
    delete a2;  // 释放对象内存
    return 0;
}

解释：在这个示例中，Dog 和 Cat 类重写了 Animal 类中的虚函数 makeSound()，从而实现了各自的行为。当使用基类指针调用时，根据对象类型自动调用对应的重写方法，实现了动态多态。

3.4 动态绑定信令图

主程序 基类指针 Dog 对象 Cat 对象 调用 makeSound() (a1) 执行 Dog::makeSound() 输出 "Bark" 调用 makeSound() (a2) 执行 Cat::makeSound() 输出 "Meow" 主程序 基类指针 Dog 对象 Cat 对象

解释：信令图展示了动态绑定的过程，基类指针调用虚函数时，根据实际对象类型绑定到对应的派生类方法，展示了重写的动态多态特性。

四、重载与重写的区别

4.1 表格对比重载与重写

特性重载（Overloading）重写（Overriding）
定义位置同一类或作用域内基类与派生类之间
参数要求参数类型、数量或顺序必须不同参数列表必须完全相同
实现方式静态多态，编译时根据参数选择函数动态多态，运行时根据对象类型选择函数
关键字无需使用特殊关键字必须基类中的函数是虚函数
应用场景提供相同操作的多种实现修改或扩展基类行为

4.2 重载与重写的应用总结

  • 重载适用于在同一类中定义多个同名函数，实现同一操作的不同版本。例如，函数重载和运算符重载广泛用于库函数的多种实现。
  • 重写用于在派生类中修改基类的行为，常用于设计多态接口和实现动态类型的操作。

五、总结

静态多态和动态多态是 C++ 实现多态的两大核心，它们分别通过重载和重写的方式在编译时和运行时实现多态性。静态多态提供了性能优势，而动态多态则赋予了代码更大的灵活性和可扩展性。

C++ 中的重载和重写是实现多态的重要手段，但它们在机制和应用场景上有着显著区别。重载主要用于编译时的多态，允许在同一类中定义多个同名函数，而重写则用于运行时的多态，通过虚函数机制让派生类根据实际需求覆盖基类的实现。理解和正确使用这两者，可以极大提高代码的灵活性、可读性和可维护性。

✨ 我是专业牛，一个渴望成为大牛🏆的985硕士🎓，热衷于分享知识📚，帮助他人解决问题💡，为大家提供科研、竞赛等方面的建议和指导🎯。无论是科研项目🛠️、竞赛🏅，还是图像🖼️、通信📡、计算机💻领域的论文辅导📑，我都以诚信为本🛡️，质量为先！🤝

如果你觉得这篇文章对你有所帮助，别忘了点赞👍、收藏📌和关注🔔！你的支持是我继续分享知识的动力🚀！✨ 如果你有任何问题或需要帮助，随时留言📬或私信📲，我都会乐意解答！😊


http://www.kler.cn/a/304169.html

相关文章：

  • 以往运维岗本人面试真题分享
  • 字节跳动核心技术：TT推荐系统从0-1落地应用
  • 【贪心算法】No.1---贪心算法（1)
  • 通用项目工程的过程视图概览
  • 简单的签到程序 python笔记
  • Django 详细入门介绍
  • vue3 5个常用的API
  • SpringBoot开发——整合Spring Data MongoDB
  • [数据集][目标检测]车油口挡板开关闭合检测数据集VOC+YOLO格式138张2类别
  • 凸优化学习（2）——梯度类方法求解(gradient descent)
  • 构建有温度的用户关系：开源 AI 智能名片、链动 2+1 模式与 S2B2C 商城小程序的作用
  • 华为SMU02B1管理模块WEB登录与账户密码信息
  • HTB-Archetype(winPEAS枚举工具，mssql xp_cmdshell)
  • Linux - make/Makefile工具的基础使用
  • Java的发展史与前景
  • 贪吃蛇项目实现（C语言）——附源码
  • JavaScript知识点3
  • JMeter脚本开发
  • 人工智能领域的性能指的是什么
  • Unity3D类似于桌面精灵的功能实现
  • JDK 17 微服务启动JVM参数调优实战
  • 自学前端靠谱吗？
  • onRequestPermissionsResult详解
  • 多账号注册脚本不会被平台监控吗
  • 写论文还在卡壳？教你用ChatGPT轻松搞定过渡段落！
  • Google大数据架构技术栈