C++ 面向对象关键语法详解：override、虚函数、转发调用和数组引用传参-策略模式

int A(参数...) override {    return 某个对象.A(参数...);}

一.目标

本文将用一个简单的“数学运算器”例子，从零解释以下 C++ 语法特性：

• virtual 虚函数

• override 重写关键字

• 函数体内部的“转发调用”

• 数组引用作为函数参数

适合初学者和希望加深理解的 C++ 编程者

二.背景：做一个“多种运算器”系统

我们希望定义一个统一的接口来支持不同的数学运算（加法、乘法等），用户只需调用统一的 calculate() 函数，不必关心底层具体做了什么。

第1步：定义接口类（抽象基类）

class Calculator {
public:
    virtual int calculate(int a, int b, int (&results)[2]) = 0;
};

解释：

• Calculator 是一个抽象类（或称接口类）；

• calculate() 是一个纯虚函数（= 0）；

• 它接收两个整数 a 和 b，并通过一个 长度为 2 的整型数组引用 results[2] 返回计算结果。

我们会让不同的“运算器”继承这个类，做不同的实现。

第2步：实现子类（加法器）

class Adder {
public:
    int calculate(int a, int b, int (&results)[2]) {
        results[0] = a + b;   // 存入和
        results[1] = a - b;   // 存入差，顺便展示多结果
        return 0;
    }
};

这个类实现了自己的 calculate()，返回值为 0 表示成功，计算和差分别存入 results[0] 和 results[1]。

第3步：写一个代理类（封装 Adder 实现）

现在我们写一个类，它继承自接口类 Calculator，但内部不直接做运算，而是把工作交给成员对象 Adder 完成。

class AdderWrapper : public Calculator {
    Adder adder; // 组合成员

public:
    int calculate(int a, int b, int (&results)[2]) override {
        return adder.calculate(a, b, results);
    }
};

这段代码的含义是："我作为一个符合接口的类，但我把实际工作交给了我的内部成员对象去做。

第4步：示例

#include <iostream>

void runCalculation(Calculator* calc) {
    int results[2];
    calc->calculate(10, 5, results);
    std::cout << "和: " << results[0] << ", 差: " << results[1] << std::endl;
}

int main() {
    AdderWrapper wrapper;
    runCalculation(&wrapper);
    return 0;
}

 运行结果：

和: 15, 差: 5

三.为什么用这种结构？

• ✅ 模块化：逻辑封装在 Adder 内部，AdderWrapper 只负责接口对接；

• ✅ 解耦合：可以轻松替换其他实现（如 Multiplier），而不改接口；

• ✅ 可扩展：未来加新功能，只需添加新类即可；

• ✅ 符合面向对象设计原则（依赖倒置、单一职责等）；

四.完整示例代码

#include <iostream>

// 1. 定义接口类（抽象基类）
class Calculator {
public:
    // 纯虚函数，要求子类必须实现
    virtual int calculate(int a, int b, int (&results)[2]) = 0;
};

// 2. 实现一个功能类：Adder（加法器）
class Adder {
public:
    int calculate(int a, int b, int (&results)[2]) {
        results[0] = a + b;   // 存储加法结果
        results[1] = a - b;   // 存储减法结果（为了示例展示多个结果）
        return 0;             // 返回状态码：0 表示成功
    }
};

// 3. 实现一个包装类：继承接口 + 转发调用
class AdderWrapper : public Calculator {
    Adder adder;  // 内部成员对象

public:
    // 使用 override 关键字表示重写接口类的虚函数
    int calculate(int a, int b, int (&results)[2]) override {
        return adder.calculate(a, b, results);  // 转发调用给内部的 adder 对象
    }
};

// 4. 使用者函数：统一调用接口类指针
void runCalculation(Calculator* calc) {
    int results[2];
    calc->calculate(10, 5, results);  // 调用接口函数
    std::cout << "和: " << results[0] << ", 差: " << results[1] << std::endl;
}

// 5. 程序入口
int main() {
    AdderWrapper wrapper;
    runCalculation(&wrapper);  // 输出: 和: 15, 差: 5
    return 0;
}

--------------------------------------------------------------------------------------------------------------------------------

const & 说明它是只读引用，传入不会在函数里被修改。