3

总体思路：一对班，一个创造工人的经理。每个都接受一组自定义行为的策略。每个策略都有一个影响管理器的部分（进行一些设置）和一个影响工作者的部分（添加需要调用和从宿主工作者类中的函数调用的特定工作函数 - 目前通过 CRTP 完成）

工人中使用的策略将始终反映管理器中的策略。即将manager<foo,bar>创建类型的工人worker<foo_worker,bar_worker>。因此，我想将工作人员策略的类型存储在管理器策略中，以便最终用户不必同时指定两者。

以下代码实现了演示问题的我的代码的简化版本。查看经理类评论。目前（为了编译示例）经理使工人成为硬编码类型。

问题：我如何在类 foo 中记录模板类 foo_worker 的类型，以便管理者可以根据自己的模板参数确定/查找正确的工人类？

typedef foo_worker work_policy;inside ofclass foo不起作用，因为 foo_worker 不是类模板。我尝试了各种包装类以及类型名和模板的组合，但没有运气。我还尝试将 foo_worker 作为 foo 中的嵌套类。

如果我可以避免它，我宁愿不需要 C++11，但如果它从根本上简化了这个问题，我愿意考虑它。

有没有另一种方法来构建这样的系统来避免这个问题？

提前感谢=）

#include <iostream>

// Example policy1 "foo"
template <typename worker_type> 
class foo_worker {
public:
    void policy_work() {
        std::cout << "foo_worker specific work" << std::endl;
        static_cast<worker_type*>(this)->work_finish();
    }
};

class foo {
public:
    foo() {
        std::cout << "foo setup" << std::endl;
    }
};

// Example policy2 "bar"
template <typename worker_type> 
class bar_worker {
public:
    void policy_work() {
        std::cout << "bar_worker specific work" << std::endl;
        static_cast<worker_type*>(this)->work_finish();
    }
};

class bar {
public:
    bar() {
        std::cout << "bar setup" << std::endl;
    }
};

// worker class
template <template <class> class policy1,template <class> class policy2>
class worker 
  : public policy1< worker<policy1,policy2> >,
    public policy2< worker<policy1,policy2> >
{
public:
    typedef policy1< worker<policy1,policy2> > policy1_type;
    typedef policy2< worker<policy1,policy2> > policy2_type;

    void work() {
        std::cout << "start work" << std::endl;
        static_cast<policy1_type*>(this)->policy_work();
        static_cast<policy2_type*>(this)->policy_work();
    }
    void work_finish() {
        std::cout << "finish work" << std::endl;
    }
};

// manager class
template <typename policy1,typename policy2>
class manager : public policy1, public policy2 {
public:
    // this line hard codes workers to the foo_worker and bar_worker policy. 
    // I want to be able to look up which policies to send the worker based 
    // on the policies that was given to the manager.
    typedef worker<bar_worker,foo_worker> worker_type; 

    // Would like to be able to do something like this instead:
    //typedef worker<policy1::work_policy,policy2::work_policy> worker_type;

    manager() : policy1(),policy2() {
        std::cout << "manager setup" << std::endl;
    }

    worker_type* create() {
        return new worker_type();
    }
};

int main() {
    manager<foo,bar> m;
    manager<foo,bar>::worker_type* w = m.create();

    w->work();

    return 0;
}
4

1 回答 1

0

也许您可以使用类型特征之类的东西来解决问题？我希望我没看错，所以，你怎么看类似的东西：

template<typename PolicyType>
struct worker_type
{
};

template<>
struct worker_type<foo>
{
    typedef foo_worker type;
};

// .... etc ...

//...

template<typename p1, typename p2>
class manager : public p1, public p2
{
    public:
        typedef worker< typename worker_type<p1>::type,
                        typename worker_type<p2>::type > worker_type;
// ...
于 2011-11-22T13:18:57.207 回答