如何使用面向对象来通用地表示参数？

Question

在 C++ 中，我必须实现多种算法，它们代表计算同一事物的不同方法。

我考虑过使用一个接口来表示不同的算法。

class AlgorithmInterface
{
  public:
    virtual double ComputeSomething(void* parameter) = 0;
}

class AlgorithmImplementation1: public AlgorithmInterface
{
  public:
    virtual double ComputeSomething(void* parameter) { /* implementation */}
}

class AlgorithmImplementation2: public AlgorithmInterface
{
  public:
    virtual double ComputeSomething(void* parameter) { /* implementation */}
}

然而，每个参数的参数（上一个示例中的 void* ）都不同，我如何通用地表示它们？

我使用 void* 作为示例，只是因为我不知道如何表示它。请告诉我应该如何执行此操作：我应该为参数创建等效继承并强制转换它们吗？ （这对我来说似乎很难看）

Answer 1

您可以在构造函数中传递参数。
另外，将虚拟成员设置为私有并使该对象成为函子：

class AlgorithmInterface
{
  public:
     double operator()() {return this->ComputeSomething();}
  private:
    virtual double ComputeSomething() = 0;
}

class AlgorithmImplementation1: public AlgorithmInterface
{
    virtual double ComputeSomething() { /* implementation */}
    public:
        AlgorithmImplementation1(Parameter 1);
}

class AlgorithmImplementation2: public AlgorithmInterface
{
    virtual double ComputeSomething() { /* implementation */}
    public:
        AlgorithmImplementation2(Item a1,Item a2);
}

int main()
{
    AlgorithmImplementation2   job(Item(12), Iterm(13));

    double result = job(); // execute;
}

Answer 2

（根据我对你的问题的理解）如果计算保持不变，只是参数类型不同，那么你可以使用 模板..

Answer 3

另一种可能性是将“参数流”传递给算法。算法可以引用 ParameterStream。

然后，派生算法将从流中相应地提取适当类型（数量）的参数。该流实现参数的类型安全提取（反序列化），并且还可以实现（如果需要）版本控制。

恕我直言，这种可能性的优点是，即使将来不同的算法需要不同数量的参数，您也可以保持接口不变。

因此，基本上，您将发送一个包含所需参数的序列化形式的参数，并在算法实现中根据需要对它们进行反序列化/验证。

正如前面的海报所提到的，如果在编译时事情很清楚，模板也可以是一个选项。

Answer 4

要么使用经典的 OO（运行时）多态性，在这种情况下，参数需要是基类指针/引用，派生类对象可以传递到该基类指针/引用，要么切换到模板和编译时多态性，如 STL执行此操作，并将算法和参数作为模板参数的实例传递。

使用模板，您的代码可能如下所示：

class AlgorithmImplementation1
{
  public:
    virtual double ComputeSomething(Param1* parameter) const
    { /* implementation */}
}

class AlgorithmImplementation1
{
  public:
    virtual double ComputeSomething(Param2* parameter) const
    { /* implementation */}
}

template< typename Algorithm >
void use_algorithm(const Algorithm& algorithm)
{
  // ...
  // get_parameter() _must_ return whatever the algorithm takes
  double d = algorithm( get_parameter() );
  // ...
}

Param1 get_parameter();

void f()
{
  use_algorithm( AlgorithmImplementation1() );
}

Answer 5

您真的需要继承权吗？如果这样做，那么将函数模板化将不是一个选项（即您不能拥有虚拟函数模板 - 至少在当前标准中），并且 Martin 的解决方案有效。如果您不需要继承，那么下面的内容就足够了，

class AlgorithmImplementation1
{
  public:
    template <typename ParamType>
      double ComputeSomething(ParamType const& parameter) { /* implementation */}
}

class AlgorithmImplementation2
{
  public:
    template <typename ParamType>
      double ComputeSomething(ParamType const& parameter) { /* implementation */}
}

这当然取决于您计划如何使用 parameter，您最好使用重载（例如， treat int code> 与 string 不同），如果您的 parameter 具有一致的接口，那么函数模板就足够了。