可以 C++策略类可用于指定构造函数是否存在？

发布于 2024-08-22 23:38:59 字数 485 浏览 9 评论 0原文

假设我有：

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

有没有办法让 Magic 成为模板，并定义模板类 st

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

st MagicFoo & MagicAll 有 Foo* 构造函数；魔法棒& MagicAll 有 Bar* 构造函数； MagicNone 既不是 Foo* 也不是 Bar* 构造函数？

基本上我希望构造函数根据策略类存在或不存在。

原文

Suppose I have:

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

Is there a way to make Magic a template, and define template classes s.t.

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

s.t. MagicFoo & MagicAll have the Foo* constructor; MagicBar & MagicAll has the Bar* constructor; and MagicNone nas neither the Foo* nor the Bar* constructor?

Basically I want constructors to exist or not exist based on policy classes.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

谈情不如逗狗 2024-08-29 23:38:59

您可以编写接受任何内容的构造函数，然后委托给策略提供的任何内容：

// "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;
};

现在，一旦您转发参数，编译器将找出策略之间的最佳匹配：

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);

You can write a constructor accepting anything, and then delegate to whatever the policies provide:

// "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;
};

Now, once you forward the argument, the compiler will figure out the best match among the policies:

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);

回复收藏 0 原文

糖果控 2024-08-29 23:38:59

这看起来像是子类的应用程序，而不是策略类的应用程序。 MagicFoo 和 MagicBar 似乎想成为 Magic 的子类，它本身可能有一个 protected 构造函数。

回复收藏 0 原文

不寐倦长更 2024-08-29 23:38:59

您可以为所有策略提供模板定义，并为 MagicNone 提供专门化。一个例子是：

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;
}

You can have a template definition for all policies and a specialization for MagicNone. An example will be:

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;
}

回复收藏 0 原文

~没有更多了~