使用 MPL 创建所有模板排列

Question

我有以下模板化类结构

struct TraitA{};
struct TraitB{};

template<typename trait>
struct FunctionalityA{};

template<typename trait>
struct FunctionalityB{};

template<typename Func>
struct FuncUserA{};

template<typename Func>
struct FuncUserB{};

template<typename fuser>
struct Host{};

Host 类现在可以具有以下类型。

typedef Host<FuncUserA<FunctionalityA<TraitA> > > Host1_t;
typedef Host<FuncUserA<FunctionalityA<TraitB> > > Host2_t;
typedef Host<FuncUserA<FunctionalityB<TraitA> > > Host3_t;
typedef Host<FuncUserA<FunctionalityB<TraitB> > > Host4_t;
typedef Host<FuncUserB<FunctionalityA<TraitA> > > Host5_t;
typedef Host<FuncUserB<FunctionalityA<TraitB> > > Host6_t;
typedef Host<FuncUserB<FunctionalityB<TraitA> > > Host7_t;
typedef Host<FuncUserB<FunctionalityB<TraitB> > > Host8_t;

有没有办法用 boost::mpl 创建类型列表？目前我什至不知道从哪里开始。 我的目标是拥有这样的功能：

template<class T>
T* getHost()
{
  typedef boost::mpl::find<HostVector, T>::type MplIter;
  return new MplIter;
}

Is this possible with boost::mpl?

Answer 1

好的，这是一些实现。它是相当特别的，显然可以将其抽象为一系列 lambda 函数序列，但我更喜欢保持这个直截了当。评论和测试在里面：

#include <iostream>

////////////////////////////////////////////////////////////////////////////////
// Base types to permute around - added soem display for tests purpose
////////////////////////////////////////////////////////////////////////////////
struct TraitA { TraitA() { std::cout << "TA"; } };
struct TraitB { TraitB() { std::cout << "TB"; } };

template<typename Trait>
struct FunctionalityA
{
  FunctionalityA() { std::cout << "FunctionalityA<"; Trait(); std::cout << ">";}
};

template<typename Trait>
struct FunctionalityB
{
  FunctionalityB() { std::cout << "FunctionalityB<"; Trait(); std::cout << ">";}
};

template<typename Func>
struct FuncUserA
{
  FuncUserA() { std::cout << "FuncUserA<"; Func(); std::cout << ">";}
};

template<typename Func>
struct FuncUserB
{
  FuncUserB() { std::cout << "FuncUserB<"; Func(); std::cout << ">";}
};

template<typename Fuser> struct Host
{
  Host() { std::cout << "Host<"; Fuser(); std::cout << ">\n";}
};

////////////////////////////////////////////////////////////////////////////////
// Step 1 : Make static list of potential options
//
// These lists has to be updated as new Trait, FuncUser and Functionality are
// made.
////////////////////////////////////////////////////////////////////////////////
#include <boost/mpl/vector.hpp>
#include <boost/mpl/placeholders.hpp>

typedef boost::mpl::vector< TraitA, TraitB >              traits_list;
typedef boost::mpl::vector< FunctionalityA<boost::mpl::_>
                          , FunctionalityB<boost::mpl::_>
                          >                                functionalities_list;

typedef boost::mpl::vector< FuncUserA<boost::mpl::_>
                          , FuncUserB<boost::mpl::_>
                          >                                fusers_list;

////////////////////////////////////////////////////////////////////////////////
// Step 1 : Build the types
//
// We want every combination of Trait and Functionality. This is basically a
// cartesian product of traits_list and functionalities_list which is done
// usign nested fold
////////////////////////////////////////////////////////////////////////////////
#include <boost/mpl/fold.hpp>
#include <boost/mpl/copy.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/back_inserter.hpp>

template<typename Fusers, typename Functionalities, typename Traits>
struct build_combo
{
  //////////////////////////////////////////////////////////////////////////////
  // Inner fold loop iterating over the traits
  //////////////////////////////////////////////////////////////////////////////
  template<typename FuserFunc>
  struct traits_loop
  {
    template<typename T>
    struct fuse : boost::mpl::apply<FuserFunc,T> {};

    typedef typename
    boost::mpl::fold< Traits
                    , boost::mpl::vector<>
                    , boost::mpl::push_back < boost::mpl::_1
                                            , fuse<boost::mpl::_2>
                                            >
                    >::type type;
  };

  //////////////////////////////////////////////////////////////////////////////
  // Inner fold loop iterating over the functionnality/traits
  //////////////////////////////////////////////////////////////////////////////
  template<typename Fuser>
  struct func_traits_loop
  {
    template<typename T>
    struct fuse : boost::mpl::apply<Fuser,T> {};

    typedef typename
    boost::mpl::fold< Functionalities
                    , boost::mpl::vector<>
                    , boost::mpl::copy< traits_loop< fuse<boost::mpl::_2> >
                                      , boost::mpl::back_inserter<boost::mpl::_1>
                                      >
                    >::type type;
  };

  //////////////////////////////////////////////////////////////////////////////
  // fold loop iterating over the Fuser x {Functionality,Traits}
  // For each Fuser, copy its vector of applications to the others
  //////////////////////////////////////////////////////////////////////////////
  typedef typename
  boost::mpl::fold< Fusers
                  , boost::mpl::vector<>
                  , boost::mpl::copy< func_traits_loop<boost::mpl::_2>
                                    , boost::mpl::back_inserter<boost::mpl::_1>
                                    >
                  >::type type;
};

////////////////////////////////////////////////////////////////////////////////
// Now the get_host meta-function
////////////////////////////////////////////////////////////////////////////////
#include <boost/mpl/at.hpp>

template<int N>
struct get_host
{
  typedef build_combo < fusers_list
                      , functionalities_list
                      , traits_list
                      >::type                     types;
  typedef typename boost::mpl::at_c<types,N>::type hosted;
  typedef Host<hosted> type;
};

////////////////////////////////////////////////////////////////////////////////
// Some tests
////////////////////////////////////////////////////////////////////////////////

int main()
{
  get_host<1>::type x1;
  get_host<2>::type x2;
  get_host<3>::type x3;
  get_host<4>::type x4;
  get_host<5>::type x5;
  get_host<6>::type x6;
  get_host<7>::type x7;
}

预期的输出应该是：

Host<FuncUserA<FunctionalityA<TB>>>
Host<FuncUserA<FunctionalityB<TA>>>
Host<FuncUserA<FunctionalityB<TB>>>
Host<FuncUserB<FunctionalityA<TA>>>
Host<FuncUserB<FunctionalityA<TB>>>
Host<FuncUserB<FunctionalityB<TA>>>
Host<FuncUserB<FunctionalityB<TB>>>

Answer 2

简介

我的答案试图成为 C++11 用户的首选答案。

Joel Falcou 的答案非常适合旧标准，但 C++11 的
参数包通常会使 boost 类型序列变得过时。此外，我认为在这种情况下，小猪支持模板比使用 boost::lambda 更好。
实际上，我的解决方案根本不使用任何包含内容，除了我将从此处获取的笛卡尔积模板，因为它不在标准中图书馆。

使用当前最新的功能（从 C++11 开始）允许编写具有以下功能的解决方案：

1. 更好地扩展。
2. 更短
3. 更具可读性，因为解决方案分离了关注点。

不同的模板解释：

expand_pack 执行其参数。这允许使用省略号重复运行时代码。示例：expand_pack(new T{}...)。 谁知道这个成语的名字？

wrap_template_as_type 搭载了一个模板，因此可以在需要类型的地方使用它。也许这个习惯用法被称为模板重新绑定或后期模板绑定。
我不知道，所以我在这里发布了这个问题。示例：wrap_template_as_type

和相反的 wrapper::unwrapp

type_list 没有数据、响铃和 Wissels 的元组。

template_list 一个模板，它接受模板列表并返回一个 type_list，其中原始模板支持在包装器中。

make_host_type 将 A, B, C, D 转换为 A>>

all_hosts 获取 Host 类型的元组，并为输入元组中的每个元素添加一个 Host。

完整示例

请注意，#include http://... 必须替换为链接内容

请注意，MSVC 不理解 PRETTY_FUNCTION，而是理解 FUNCDNAME我认为

#include <iostream>
#include <typeinfo>
#include https://stackoverflow.com/a/19611856/2712726
template<typename... Ts> void expand_pack (Ts... t) {}

template <template<typename...> class T>
struct wrapp_template_as_type {
    template <typename... Us> using unwrapp =  T <Us...>;
};

template<typename... T> struct type_list {};

template <template<typename...> class... Ts>
struct template_list {
    using type = type_list< wrapp_template_as_type<Ts>... >;
};

struct TraitA{}; struct TraitB{}; struct TraitC{}; struct TraitD{}; struct TraitE{}; struct TraitF{};
template<typename Trait>    struct  WhateverA{};
template<typename Trait>    struct  WhateverB{};
template<typename Whatever> struct  FunctionalityA{};
template<typename Whatever> struct  FunctionalityB{};
template<typename Whatever> struct  FunctionalityC{};
template<typename Whatever> struct  FunctionalityD{};
template<typename Func>     struct  FuncUserA{};
template<typename Func>     struct  FuncUserB{};
template<typename Func>     struct  FuncUserC{};
template<typename FuncUser> struct  Host { Host() {std::cout << __PRETTY_FUNCTION__ << std::endl;}};

template<typename T> struct make_host_type;

template<template<typename...> class List, typename T, typename... Ts>
struct make_host_type < List<T, Ts...> > {
    using type = typename T::template unwrapp < typename make_host_type< List<Ts...> >::type >;
};

template<template<typename...> class List, typename T>
struct make_host_type < List<T> > {
    using type = T;
};

template <typename T> struct all_hosts;

template <template<typename...> class Hosts, typename... Ts>
struct all_hosts <Hosts<Ts...> > {
    static void create () {
        expand_pack (new typename make_host_type<Ts>::type{}...);
    }
};

int main () {
    using a =          type_list     < TraitA, TraitB, TraitC, TraitD, TraitE, TraitF >;
    using b = typename template_list < WhateverA, WhateverB>::type;
    using c = typename template_list < FunctionalityA, FunctionalityB, FunctionalityC, FunctionalityD >::type;
    using d = typename template_list < FuncUserA, FuncUserB, FuncUserC >::type;
    using e = typename template_list < Host >::type;
    using p = typename product<type_list, e, d, c, b, a>::type; // create a type_list of all possible Host types.
    all_hosts<p>::create(); // calls constructor for each Host type
}

输出是：（如果您使用 MSVC，请将 PRETTY_FUNCTION 替换为其他内容）

Host<FuncUser>::Host() [with FuncUser = FuncUserC<FunctionalityD<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserB<FunctionalityD<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserA<FunctionalityD<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserC<FunctionalityC<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserB<FunctionalityC<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserA<FunctionalityC<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserC<FunctionalityB<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserB<FunctionalityB<WhateverB<TraitF> > >]
...
Host<FuncUser>::Host() [with FuncUser = FuncUserA<FunctionalityA<WhateverA<TraitA> > >]