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

このソリューションは、しかし、私はtypedef MetaLoop<Add,Sub> Loop

にほとんど私はrun()にテンプレート引数を提供する必要性を除きたいインタフェース、すなわちrun<Add>とrun<Sub>とMetaLoopからレジスタAddとSubへの必要性を考え必要ですそれが、マクロを使用せずに、可能であるかどうかを知りたい：

1. が自動的MetaLoopにOperation<T>クラスを登録します（つまり、自動的にtypedef Metaloop<...operations...>と呼びます）
2. runメソッドにテンプレートクラスを指定しないでください。 （run<Add>()の代わりにrun()を呼び出してください）
3. このメソッドをライブラリから取得します。この種の多型性を静的に提供できるライブラリ（Boostなど）はありませんか？

私が使用できるいくつかの他のアーキテクチャがあることを認識していますが、他にも多くの制約があります。これは単なるおもちゃの問題です。

ありがとうございます！

EDIT 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で動作していること：例として
。