c++ - 继承类函数比基类需要更多的输入

Question

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

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

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

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

举个例子

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

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; }

  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;

  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 = xModels[i]->Function(xValue);
  std::cout << result << std::endl;
  ;

  return 0;
}

如果我输入 0.5结果是 3.14159 .如果我输入 1.5结果是 1 .如果我输入 3.5我希望答案是 (3.5 + 1.0 + 2.0) * -1.0 = -6.5 .但是，我得到 0因为函数Model::Function叫做。这非常有意义，因为我只提供 1 个输入。如果我提供 3 个输入，我会得到预期的编译器错误“函数不接受 3 个参数”。

我开始使用 decltype和运行时类型识别，但这让我觉得我做错了。让继承的类成员函数比基类接受更多输入的正确方法是什么？

更新

我修改了基类以重载Function(float, float, float)然后使用 typeid.hash_code()以确定我是否需要像这样使用 1 或 3 输入函数。

#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;
}

这在我需要时获得 3 输入版本的意义上是有效的，但感觉有更好的方法来做到这一点。

Answer 1

What is the proper way to have an inherited class member function take more inputs than the base class?

不能使用不同的签名重新定义虚函数，派生类必须根据基类的规范实现所有虚函数。如果你不能确保这一点，你的设计就有问题，你想修改它。

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