有没有比这更有效的构造/模式 C++ 的方法？

Question

基本思想是我有一个“家庭”类，它们都做同样的事情，但方式略有不同。这个“家族”用于“高性能”循环，因此速度至关重要。此外，具体的家庭由配置文件指定...

问题是这里的 main 函数中有大量的代码重复。有没有更好的方法来构建这个，所以我不必写HP<objx> test 和test.loop(bobloblaw) 三遍？ （实际上，这段代码比 2 行多得多……）

class obj1 {
public:
    double f(double x) const { return 1.; }
};

class obj2 {
public:
    double f(double x) const { return x; }
};

class obj3 {
public:
    double f(double x) const { return x*x; }
};

template <class O>
class HP {
private:
    O obj;

public:

    double loop(const vector<double>& x) {
        double s = 0.;
        for (auto i : x) s += obj.f(i);

    return s;
    }
};

int main() {
    string config = "bob";
    double result = 0;
    vector<double> bobloblaw;

    /* Read configuration file to determine which object to use. */
    if (config == "obj1") {
        HP<obj1> test;
        result = test.loop(bobloblaw);
    } else if (config == "obj2") {
        HP<obj2> test;
        result = test.loop(bobloblaw);
    } else if (config == "obj3") {
        HP<obj3> test;
        result = test.loop(bobloblaw);
    }

    return result;
}

Answer 1

以下内容未经测试，但应该可以：

class obj1
{
public:
  double f(double x) const { return 1.; }
};

class obj2
{
public:
  double f(double x) const { return x; }
};

class obj3
{
public:
  double f(double x) const { return x*x; }
};

class HPbase
{
public:
  virtual double loop(const vector<double>&) = 0;
};

template <class O> class HP:
  public HPbase
{
public:
  double loop(const vector<double>& x)
  {
    double s = 0.;
    for (auto i : x)
      s += obj.f(i);
    return s;
  }
private:
  O obj;
};

std::unordered_map<std::string, std::unique_ptr<HPbase>> decode{
  {"obj1"}, new HP<obj1>()},
  {"obj2"}, new HP<obj2>()},
  {"obj3"}, new HP<obj3>()} };

int main()
{
  string config = "bob";
  double result = 0;
  vector<double> bobloblaw;

  /* Read configuration file to determine which object to use. */
  result = decode[config].loop(bobloblaw);
}

请注意，唯一添加的是 HP<> 的基类和替换代码的 if/else 逻辑的映射。

Answer 2

难道你不能让这 3 个类都是具有相同父类的子类吗？ main 仍然需要使用正确的子类分配给 test，但 test 本身将被声明为公共超类。

这里的缺点是可能会对性能造成（可能很小）影响，因为编译器在为 test.loop 生成代码时不知道将使用哪个版本，因此必须在运行时决定。

解决此问题的另一种方法是将通用代码编写为宏，因此只编写一次，但扩展为 3 个不同的副本，编译器可以根据测试的变体对每个副本进行优化正在使用。可能会使调试变得很麻烦，但如果您的重点是性能和减少源的冗余（而不是对象的冗余），那可能是一个很好的权衡。