如何实现运行时多态：根据输入类型自动调用基/派生类add函数？

需求与问题 #

需求 #

• Base类的add函数处理整数输入，计算求和结果并输出对应数值及in base class（示例输入2 3时输出5及标识）
• Derived类公有继承Base类，其add函数处理浮点数输入，计算求和结果并输出对应数值及in derived class（示例输入3.5 2.5时输出6.0及标识）
• 期望通过运行时多态实现：程序自动根据用户输入的数值类型，调用对应类的处理函数

现有问题 #

当前代码中，无论输入整数还是浮点数，都会调用Derived类的add函数。原因是代码里基类指针始终指向Derived对象，运行时多态的触发依据是对象的实际类型，而非输入内容——输入的整数会被隐式转换为浮点数适配Derived的add函数，导致逻辑不符合预期。

现有代码 #

#include <iostream>
using namespace std;

class Base {
public:
    virtual void add() {
        int a, b, c;
        cin >> a >> b;
        c = a + b;
        cout << c << endl;
        cout << "base" << endl;
    }
};

class Derived : public Base {
public:
    void add() {
        float a, b, c;
        cin >> a >> b;
        c = a + b;
        cout << c << endl;
        cout << "derived" << endl;
    }
};

int main() {
    Base* ptr;
    Derived d;
    ptr = &d;
    ptr->add();
    return 0;
}

补充说明 #

原需求的设计存在不合理性：C++的运行时多态是基于对象的动态类型，而非输入数据的类型。原需求混淆了这两个概念，直接用继承多态无法实现“根据输入类型自动选择方法”的逻辑，必须先判断输入类型，再配合多态完成调用。

解决方案 #

核心思路 #

1. 先读取输入的原始字符串，通过检查小数点、科学计数法标识e/E判断是否为浮点数
2. 根据判断结果，创建对应类型的处理器对象（整数处理器/浮点数处理器）
3. 通过基类指针调用对应处理器的处理方法，实现运行时多态

修正后代码 #

#include <iostream>
#include <string>

using namespace std;

// 抽象基类，定义统一的处理接口
class NumProcessor {
public:
    virtual void process(const string& num1, const string& num2) = 0;
    virtual ~NumProcessor() = default; // 虚析构函数，避免内存泄漏
};

// 整数处理器，继承自抽象基类
class IntProcessor : public NumProcessor {
public:
    void process(const string& num1, const string& num2) override {
        int a = stoi(num1);
        int b = stoi(num2);
        cout << a + b << endl;
        cout << "in base class" << endl;
    }
};

// 浮点数处理器，继承自抽象基类
class FloatProcessor : public NumProcessor {
public:
    void process(const string& num1, const string& num2) override {
        float a = stof(num1);
        float b = stof(num2);
        cout << a + b << endl;
        cout << "in derived class" << endl;
    }
};

int main() {
    string num1, num2;
    cin >> num1 >> num2;

    // 判断输入是否为浮点数
    bool isFloat = false;
    if ((num1.find('.') != string::npos || num2.find('.') != string::npos) ||
        (num1.find('e') != string::npos || num2.find('e') != string::npos) ||
        (num1.find('E') != string::npos || num2.find('E') != string::npos)) {
        isFloat = true;
    }

    NumProcessor* processor = nullptr;
    // 根据输入类型创建对应处理器
    if (isFloat) {
        processor = new FloatProcessor();
    } else {
        processor = new IntProcessor();
    }

    // 调用对应处理方法
    processor->process(num1, num2);

    delete processor; // 释放内存
    return 0;
}

关键说明 #

• 原代码的本质错误：运行时多态的触发依赖于指针指向的对象类型，而非输入数据。之前的代码中指针始终指向Derived对象，必然调用其add函数。
• 输入类型判断：通过字符串检查小数点和科学计数法标识，能准确区分整数和浮点数输入，避免隐式转换的干扰。
• 抽象基类设计：通过定义统一的process接口，让不同处理器类实现各自的逻辑，既符合多态的设计思想，又解决了原需求的矛盾。

内容的提问来源于stack exchange，提问作者Tanishq Kohli