用 CRTP + 可变参数模板模拟动态多态性

Question

我需要用相当大的类替换代码中的动态多态性，但我遇到了 CRTP + 可变参数模板设计的问题。

为了说明，我在下面提供了一个玩具问题。

有一个动态多态的类，使用如下接口：

int main() { 
  Loop loop;
  Add add ;
  loop.set(add);
  loop.run();
  Sub sub ;
  loop.set(sub); 
}

当然，Sub 和 Add 派生自基类 Operation 和 op(double & v) 是一个虚方法。

由于其他原因我需要保留这个接口，同时通过静态多态来改变动态，这是我到目前为止的解决方案：

template <typename T> class Operation { 
public: 
  double d=1.;
  void op(double & d) { static_cast<T*>(this)->op(d);}
};
class Add final: public Operation<Add> { 
public: void op(double & v) { v += d; }
};
class Sub final: public Operation<Sub> {
public: void op(double & v) { v -= d; }
};

对于Loop 类：

template <typename... Types>
class MetaLoop {
public:
  double d = 0 ;
  template <typename T> void set(T & t) { 
  std_cxx17::get<std::vector<T*> >(data).push_back(&t) ; 
  }
  template <typename T> void run() { 
    for (auto j = 0; j<2E9 ; ++j)
      std_cxx17::get<std::vector<T*> >(data).back()->op(d);
    std::cout << d << std::endl; 
  }
private:
  std::tuple<std::vector<Types*>... > data ;
};
typedef MetaLoop<Add,Sub> Loop ;

std_cxx17::get<T*>(data) 是对按类型选择元组中元素的方法的调用，类似于this post

然而，这个解决方案几乎需要我想要的接口，除了需要向run() 提供模板参数，即run<Add> 和run<Sub> 以及需要注册 Add 和 Sub 到 MetaLoop 在 typedef MetaLoop<Add,Sub> Loop

我想知道是否可以在不使用宏的情况下：

1. 自动将Operation<T> 类注册到MetaLoop（即自动调用typedef Metaloop<...operations...>）
2. 避免将模板类提供给run 方法。 （即致电run() 而不是run<Add>()）
3. 从库中获取此方法：是否有库（例如 Boost）可以静态提供这种多态性？

请记住，我知道我可以使用其他几种架构，但我必须使用许多其他限制。这只是一个用来举例说明的玩具问题。

提前致谢！

编辑 1：

问题 2 已回答！见这里：http://coliru.stacked-crooked.com/a/e68ea7faabba3e40

向https://www.reddit.com/user/17b29a致敬

Answer 1

您可以类型擦除您的类型，如下例所示：

#include <iostream>
#include <vector>
#include <utility>

template<typename T>
struct Operation {
    void op(double &d) { static_cast<T*>(this)->op(d) ; }
    double d{1};
};

struct Add: Operation<Add> {
    void op(double &v) { v += d; }
};

struct Sub: Operation<Sub> {
    void op(double &v) { v -= d; }
};

class Loop {
    using Fn = void(*)(double &, void *);

    template<typename T>
    static void op(double &d, void *op) {
        static_cast<T*>(op)->op(d);
    }

public:
    template<typename T>
    void set(T &t) {
        data.emplace_back(&op<T>, &t);
    }

    void run() {
         auto &p = data.back();
         for(auto j = 0; j < 10; ++j) {
             p.first(d, p.second);
         }

         std::cout << d << std::endl;
    }

private:
    std::vector<std::pair<Fn, void*>> data;
    double d = 0;
};

int main() {
    Loop loop;
    Add add;
    loop.set(add);
    loop.run();
    Sub sub;
    loop.set(sub);
    // ...
}

另请注意，在这种情况下，CRTP 习惯用法是无用的，您可以删除模板类 Operation。
简单定义Add和Sub如下：

struct Add {
    void op(double &v) { v += d; }
    double d{1};
};

struct Sub {
    void op(double &v) { v -= d; }
    double d{1};
};

如果您想区分 Add 和 Sub 并提供不同的算法，您可以使用特化。
举个例子：

class Loop {
    using Fn = void(*)(double &, void *);

    template<typename T>
    static void op(double &d, void *op);

public:
    template<typename T>
    void set(T &t) {
        data.emplace_back(&op<T>, &t);
    }

    void run() {
        auto &p = data.back();
        for(auto j = 0; j < 10; ++j) {
            p.first(d, p.second);
        }

        std::cout << d << std::endl;
    }

private:
    std::vector<std::pair<Fn, void*>> data;
    double d = 0;
};

template<>
void Loop::op<Add>(double &d, void *op) {
    Add *add = static_cast<Add*>(op);
    // do whatever you want with add
    add->op(d);
}

template<>
void Loop::op<Sub>(double &d, void *op) {
    Sub *sub = static_cast<Sub*>(op);
    // do whatever you want with sub
    sub->op(d);
}

请注意，该解决方案符合问题中列出的所有要求，并且适用于 OP 作为示例提供的 main。