C++ 继承的类函数比基类接受更多的输入

我有一些函数需要应用于3个不同变量x，y，z上的不同域。通常每个函数只接受一个变量作为输入。例如：

float myFunction(float val) { return val * 3.14159; }

这些函数可以是简单的常数乘法、插值、导数等。我想要一个向量，它包含在不同域上定义的函数。例如，所有x函数都在std:：vector x函数、std:：vector Y函数等中

现在我需要增加一个函数的能力，将所有三个变量作为输入，但我想把它们保持在向量中

这里有一个例子

包括 包括 包括 包括 类模型{ 公众： Modelfloat b1=0.0，float b2=std:：数值限制：：无穷大 ：lowerBoundb1，upperBoundb2{} 虚拟浮点函数float inp{return 0.0；} float GetUpperBound常量{return upperBound；} float GetLowerBound常量{return lowerBound；} 受保护的： 浮动下限，上限； }; ConstantModel类：公共模型{ 公众： ConstantModelfloat b1=0.0， 浮点b2=标准：：数值限制：：无穷大， 浮动f=0.0 ：Modelb1、b2、factorf{} float函数float inp{return factor；} 私人： 浮动因子； }; 类LinearModel：公共模型{ 私人： 浮动区间系数1，区间系数2； 浮动期限； 公众： 线性模型浮点b1=0.0，浮点b2=std:：数值限制：：无穷大， 浮动f1=0.0，浮动f2=0.0 ：B1型、b2型、内部因素1f1、内部因素2f2{ interperm=interfactor1-interfactor1/上限-下限； } 浮点函数浮点inp{ 返回interfactor1+inp-下限*interterm； } }; 类多输入：公共模型{ 私人： 浮动因子； 公众： 多输入浮点b1=0.0， 浮点b2=标准：：数值限制：：无穷大， 浮动f1=0.0 ：Modelb1，b2，factorf1{} 浮点函数浮点inpX，浮点inpY，浮点inpZ{ 返回因子*inpX+inpY+inpZ； } }; int main{ //实际上，我有Xmodel、Ymodel和Zmodel std：：向量x模型； xModels.emplace_backnew ConstantModel 0.0、1.0、3.14159； xModels.emplace_back新线性模型1.0、2.0、1.0、2.0； xModels.emplace\u back新的多输入3.0,4.0，-1.0； 浮点数； 浮动YValue 1.0，ZValue 2.0； 标准：cin>>xValue； //查找要使用的适用函数 标准：尺寸i=0； 而xModels[i]->GetUpperBoundFunctionxValue； 标准：：cout 让继承的类成员函数接受比基类更多的输入的正确方法是什么

无法使用其他签名重新定义虚拟函数，派生类必须根据基类的规范实现所有虚拟函数。如果无法确保这一点，则说明您的设计存在问题，您希望对其进行修改

---

派生类可以在原始继承函数的基础上定义一个新的、不相关的函数。如果签名不同，则两个函数可能具有相同的名称，从而导致函数重载。

通常我们称此重载函数。由于它们具有相同的名称，因此对于编译器来说，它们仍然是不同的函数。请注意：可能对您有用，请您查看我的更新和评论好吗？我认为您的设计有问题是对的。@Matt新设计也有问题。每当您需要使用typeid选择正确的功能时，很有可能您做错了。至少您可以有一个像needsThreeA这样的虚拟功能rguments您可能应该为它发明一个有意义的名称。我认为我得到了一个可接受的解决方案。我更改了函数，将const std:：array&，std:：size\t>作为输入。这允许它们都具有相同的签名。需要某个值的函数通过size\t获得该值，而需要这三个值的函数忽略它。谢谢他看起来很帅。

#include <limits>
#include <vector>
#include <memory>
#include <iostream>
#include <typeinfo>

class Model {
public:
    Model(float b1 = 0.0, float b2 = std::numeric_limits<float>::infinity()) :
        lowerBound(b1), upperBound(b2) {}
    virtual float Function(float inp) { return 0.0; }
    virtual float Function(float i1, float i2, float i3) { return 0.0; }
    float GetUpperBound() const { return upperBound; }
    float GetLowerBound() const { return lowerBound; }

protected:
    float lowerBound, upperBound;
};

class ConstantModel : public Model {
public:
    ConstantModel(float b1 = 0.0, float b2 = std::numeric_limits<float>::infinity(), float f = 0.0) :
        Model(b1, b2), factor(f) {}
        float Function(float inp) { return factor; }

private:
    float factor;
};

class LinearModel : public Model {

private:
    float interpFactor1, interpFactor2;
    float interpTerm;

public:
    LinearModel(float b1 = 0.0, float b2 = std::numeric_limits<float>::infinity(), float f1 = 0.0, float f2 = 0.0) :
        Model(b1, b2), interpFactor1(f1), interpFactor2(f2) {
        interpTerm = (interpFactor1 - interpFactor1) / (upperBound - lowerBound);
    }
    float Function(float inp) { return interpFactor1 + (inp - lowerBound) * interpTerm; }
};

class MultipleInputs : public Model {

private:
    float factor;

public:
    MultipleInputs(float b1 = 0.0, float b2 = std::numeric_limits<float>::infinity(), float f1 = 0.0) :
        Model(b1, b2), factor(f1) {}
    float Function(float inpX, float inpY, float inpZ) { return factor * (inpX + inpY + inpZ); }
};

int main() {

    // In practice I have xModels, yModels, zModels
    std::vector<std::unique_ptr<Model> > xModels;
    std::vector<std::size_t> tags;
    tags.emplace_back(typeid(Model).hash_code());
    tags.emplace_back(typeid(ConstantModel).hash_code());
    tags.emplace_back(typeid(LinearModel).hash_code());
    tags.emplace_back(typeid(MultipleInputs).hash_code());

    for (auto i : tags) {
        std::cout << i << std::endl;
    }

    xModels.emplace_back(new ConstantModel(0.0, 1.0, 3.14159));
    xModels.emplace_back(new LinearModel(1.0, 2.0, 1.0, 2.0));
    xModels.emplace_back(new MultipleInputs(3.0, 4.0, -1.0));

    float xValue;
    float yValue(1.0), zValue(2.0);
    std::cin >> xValue;

    // Find the applicable function to use
    std::size_t i = 0;
    while (xModels[i]->GetUpperBound() < xValue) {
        ++i;
    }
    float result;
    if (typeid(*xModels[i]).hash_code() == tags[3]) {
        result = xModels[i]->Function(xValue, yValue, zValue);
    }
    else {
        float result = xModels[i]->Function(xValue);
    }
    std::cout << result << std::endl;;

    return 0;
}