4

我想知道是否可以使用可变模板模板参数组合策略类，以便每个策略都可能有自己的模板包。似乎您只能在所有策略中共享一个模板包，但我希望情况并非如此。

以下似乎是可能的：

template <
    class T,
    template <class, typename...>   class Policy1,
    template <class, typename...>   class Policy2,
    template <class, typename...>   class Policy3,
    typename... Args    
>
struct PolicyClass 
    : public Policy1     <ObjT, Args...>
    , public Policy2     <ObjT, Args...>
    , public Policy3     <ObjT, Args...>    {}

我希望每个政策都可以有自己的包，所以我可以做这样的事情（？）：

template <class T>
struct implementedPolicy1 {};
template <class T>
struct implementedPolicy2 {};
template <class T, class A>
struct implementedPolicy3 {};

PolicyClass <ObjT, 
             implementedPolicy1,
             implementedPolicy2,
             implementedPolicy3<AType>
            >

每个策略都使用相同的对象类型，但第三个有一些进一步的模板。我知道上面的代码不正确 - 只是想说明我想要做什么。

谢谢

4

3 回答 3

3

我从来都不喜欢模板模板参数，这是我会避免使用它们的另一个例子：

template <typename T, typename... Policies>
struct PolicyClass: Policies... {};

将仅适用于任意策略：

using PC = PolicyClass<int,
                       LifetimePolicy<LP::Extended>,
                       DurabilityPolicy<3600, DP::Seconds>
                       StoragePolicy<int, SP::InMemory>>;
于 2014-02-21T16:44:09.220 回答
1

请注意，您可能有类似的东西：

template <class T,
          template <class> class Policy1,
          template <class> class Policy2,
          template <class> class Policy3>
struct PolicyClass : public Policy1<ObjT>,
                     public Policy2<ObjT>,
                     public Policy3<ObjT>
{};

template <class T> struct implementedPolicy1 {};
template <class T> struct implementedPolicy2 {};
template <class T, class A> struct implementedPolicy3 {};

// Adapt the policy interface
template <class T>
using myImplementedPolicy3 = implementedPolicy3<T, AType>; // Assuming AType exist

PolicyClass <ObjT, implementedPolicy1, implementedPolicy2, myImplementedPolicy3> policies;
于 2014-02-21T16:22:55.287 回答
1

您需要能够在包之间进行分隔。

// helper template.  Using `std::tuple<>` instead is another option.
template<class...>struct type_list {};

// base, note no body:
template <
    class T,
    template <class, typename...>   class Policy0,
    template <class, typename...>   class Policy1,
    template <class, typename...>   class Policy2,
    typename... Packs
>
struct PolicyClass;

// specialization:
template <
    class T,
    template <class, typename...>   class Policy0,
    template <class, typename...>   class Policy1,
    template <class, typename...>   class Policy2,
    typename... A0s,
    typename... A1s,
    typename... A2s
>
struct PolicyClass<
  T, Policy1, Policy2, Policy3,
  type_list<A0s...>, type_list<A1s...>, type_list<A2s...>
>
: Policy0<T, A0s...>, Policy1<T, A1s...>, Policy2<T, A2s...> {}

我将每个策略的额外参数打包到一个type_list.

从理论上讲，您可以做一些更有趣的事情，例如将特定的“标签”类型作为分隔符，但最终会变成很多体操。

PolicyClass< int, bob, eve, alice, type_list<>, type_list<double>, type_list<char, char, char> > foo;

将创建

PolicyClass: bob<int>, alice<int, double>, eve<int, char, char, char>

大致。

于 2014-02-21T16:27:12.373 回答