Can C ++ Policy-Klassen verwendet werden, um das Vorhandensein / Nichtvorhandensein von Konstrukteuren angeben?

Question

Angenommen, ich habe:

struct Magic {
  Magic(Foo* foo);
  Magic(Bar* bar);
};

Gibt es eine Möglichkeit Magie eine Vorlage zu machen, und definieren Template-Klassen s.t.

typedef Magic<FooPolicy, ...> MagicFoo;
typedef Magic<BarPolicy, ...> MagicBar;
typedef Magic<..., ...> MagicNone;
typedef Magic<FooPolicy, BarPolicy> MagicAll;

s.t. MagicFoo & MagiCall haben die Foo * Konstruktor; MagicBar & MagiCall hat die Bar * Konstruktor; und MagicNone nas weder die Foo * noch die Bar * Konstruktor?

Grundsätzlich möchte ich Konstrukteure oder nicht, basierend auf Policy-Klassen existieren existieren.

Answer 1

Sie können einen Konstruktor schreiben etwas zu akzeptieren, und dann zu übertragen, was auch immer die Richtlinien bieten:

// "Tag" and "No" are used to make the class/function unique 
// (makes the using declarations work with GCC). 
template<int Tag>
struct No { void init(No); };

template<typename P1 = No<0>, typename P2 = No<1>, typename P3 = No<2> >
struct Magic : P1, P2, P3 {
  template<typename T>
  Magic(T t) {
    init(t);
  }

private:
  using P1::init;
  using P2::init;
  using P3::init;
};

Nun, wenn Sie das Argument weiterleiten, wird der Compiler die beste Übereinstimmung zwischen den Richtlinien herauszufinden:

struct IntPolicy { void init(int) { std::cout << "called int!"; } };
struct FloatPolicy { void init(float) { std::cout << "called float!"; } };
Magic<IntPolicy, FloatPolicy> m(0), n(0.0f);

Answer 2

Das sieht aus wie eine Anwendung für Unterklassen, nicht Policy-Klassen. MagicFoo und MagicBar zu sein scheinen Subklassen von Magic zu wollen, die selbst einen protected Konstruktor haben könnte.

Answer 3

Sie können für alle Richtlinien eine Template-Definition und eine Spezialisierung für MagicNone. Ein Beispiel wird sein:

template<class T> 
 struct Magic {
  Magic(T *o) {}
};

struct None {};

// specialize for MagicNone
template<> struct Magic<None> {
  Magic() {} // default ctor
};

int main()
{
  int a = 32;
  Magic<int> mi(&a);
  Magic<None> m;
}