1

我已经使用 CRTP 实施了一项策略。该策略要求Base该类具有一个名为 foo 的函数：

template<typename Base>
struct Policy<Base> {
  // ...
  Base* b(){ return static_cast<Base*>(this); }
  void do(){ b()->foo(); }
};

我有一个Widget使用我的策略的类。Widget实现foo，一切都很好：

struct Widget : Policy<Widget> {
  // ...
  void foo();
};

问题：我还有一个名为的类型，它在名为OldWidget的函数中实现了的功能：foooldFoo

struct OldWidget : Policy<OldWidget> {
  // ...
  void oldFoo();
};

我不想修改 OldWidget（除了使用策略扩展它）。我不想使用AdaptedOldWidget：

struct AdaptedOldWidget : OldWidget, Policy<AdaptedOldWidget> {
  void foo(){ oldFoo(); }
};

最好的办法是将我现有的policy_traits课程扩展到以下内容：

template<typename T>
struct policy_traits {};

template<>
struct policy_traits<Widget> {
  // typedefs...
  member_function_name = foo;
};

template<>
struct policy_traits<OldWidget> {
  // typedefs
  member_function_name = oldFoo;
};

这样我就可以像这样实施政策：

template<typename Base>
struct Policy<Base> {
  // ...
  Base* b() { return static_cast<Base*>(this); }
  void do(){ b()->policy_traits<Base>::member_function_name(); }
};

有没有在 C++ 中实现这样的东西？

建议的解决方案：我可以执行以下操作：

template<typename Base>
struct Policy<Base> : Policy_Member_Traits<Base> {
  // ...
  Base* b(){ return static_cast<Base*>(this); }
  void do(){ foo_wrapper(); }
};

template<typename T> struct Policy_Member_Traits { };
template<> struct Policy_Member_Traits<Widget> { 
  void foo_wrapper(){ static_cast<T*>(this)->foo(); }
};
template<> struct Policy_Member_Traits<OldWidget> { 
  void foo_wrapper(){ static_cast<T*>(this)->oldFoo(); }
};

必须希望有一种更好更简单的方法来实现这一目标。

4

2 回答 2

3

首先：所有函数的签名必须相同。然后你可以在你的内部设置一个带有成员函数地址的静态成员policy_traits，这样你以后就可以Policy使用它（从你的模板）调用所需的函数。

typedef void (*void_memfn_type)();

template<>
struct policy_traits<Widget> {
  static void_memfn_type const member_function_name = &Widget::foo;
};

template<>
struct policy_traits<OldWidget> {
  static void_memfn_type const member_function_name = &OldWidget::oldFoo;
};

然后：

template<typename Base>
struct Policy<Base> {
  // ...
  Base* b() { return static_cast<Base*>(this); }
  void do(){ b()->policy_traits<Base>::(*member_function_name)(); }
};
于 2013-01-22T09:01:56.753 回答
2

这是一个如何选择性专业化的示例。首先，一些示例类：

#include <iostream>

struct Foo
{
    void foo() const { std::cout << "Foo::foo\n"; }
    void bar() const { std::cout << "Foo::foo\n"; }
};

struct Biz
{
    void old_foo() const { std::cout << "Fiz::old_foo\n"; }
    void bar() const { std::cout << "Fiz::foo\n"; }
};

struct Fiz
{
    void foo() const { std::cout << "Biz::foo\n"; }
    void old_bar() const { std::cout << "Biz::old_foo\n"; }
};

现在的特征：

template <typename T> struct Dispatch
{
    static void foo(T const & x) { x.foo(); }
    static void bar(T const & x) { x.bar(); }
};

template <> void Dispatch<Biz>::foo(Biz const & x) { x.old_foo(); }
template <> void Dispatch<Fiz>::bar(Fiz const & x) { x.old_bar(); }

这是一个使用示例：

template <typename T> void dispatch(T const & x)
{
    Dispatch<T>::foo(x);
    Dispatch<T>::bar(x);
}

int main()
{
    Foo f;
    Biz b;
    Fiz c;

    dispatch(f);
    dispatch(b);
    dispatch(c);
}
于 2013-01-22T09:19:07.783 回答