Question

我想使用类模板参数列表中的类型信息。

使用快速解决方法的工作示例：

struct NoParam {};
template< typename A = NoParam,
          typename B = NoParam,
          typename C = NoParam,
          typename D = NoParam,
          typename E = NoParam,
          typename F = NoParam >
struct TypeList
{
  typedef A T1;
  typedef B T2;
  typedef C T3;
  typedef D T4;
  typedef E T5;
  typedef F T6;
};

template<typename... Types>
class Application
{
   Application()
   {
      // the actual code will store the created instances in a tuple or map..
      std::make_unique< TypeList<Types...>::T1 > ();
      std::make_unique< TypeList<Types...>::T2 > ();
      std::make_unique< TypeList<Types...>::T3 > ();
      std::make_unique< TypeList<Types...>::T4 > ();
      std::make_unique< TypeList<Types...>::T5 > ();
      std::make_unique< TypeList<Types...>::T6 > ();
   }
}

有没有通用的方法......

迭代类型并获取类型信息（用于创建实例）
在示例中仅限于6种类型的硬编码

Answer 1

不要重新发明轮子，你可以使用std::tuple和std::tuple_element_t：

template<typename... T>
using TypeList = std::tuple<T...>;

template<int I, typename T>
using Type = std::tuple_element_t<I, T>;

template<typename... Types>
class Application {
    Application() {
        std::make_unique<Type<0, TypeList<Types...>>> ();
        std::make_unique<Type<1, TypeList<Types...>>> ();
        // and so on...
    }
}

现在对类型的迭代很简单。
它遵循一个最小的工作示例，向您展示如何做到这一点：

#include <tuple>
#include <functional>
#include <memory>

template<typename... T>
using TypeList = std::tuple<T...>;

template<int I, typename T>
using Type = std::tuple_element_t<I, T>;

template<typename... Types>
class Application {
    using MyTypeList = TypeList<Types...>;

    template<std::size_t... I>
    void iterate(std::index_sequence<I...>) {
        // demonstration purposes, here I'm simply creating an object of the i-th type
        int _[] = { 0, (Type<I, MyTypeList>{}, 0)... };
        (void)_;
    }

public:
    void iterate() {
        iterate(std::make_index_sequence<sizeof...(Types)>{});
    }

    Application() {
        std::make_unique<Type<0, MyTypeList>> ();
        std::make_unique<Type<1, MyTypeList>> ();
        // and so on...  
    }
};

int main() {  
    Application<int, float> app;
    app.iterate();
}

请注意，自{+ C ++ 14>以来std::index_sequence和std::make_index_sequence可用。无论如何，如果你受限于C ++ 11，你可以在网上找到几个要使用的实现否则，您还可以使用几个递归的_sfinae'd_functions迭代这些类型，以检查是否已达到sizeof...(Types)。

Answer 2

您可以使用类似

之类的内容来避免使用结构typeList索引可变参数类型

struct noTypeInList
 { };

template <std::size_t, typename ...>
struct typeSel;

template <typename T0, typename ... Ts>
struct typeSel<0U, T0, Ts...>
 { using type = T0; };

template <std::size_t N, typename T0, typename ... Ts>
struct typeSel<N, T0, Ts...>
 { using type = typename typeSel<N-1U, Ts...>::type; };

template <std::size_t N>
struct typeSel<N>
 { using type = noTypeInList; };

所以

std::make_unique< TypeList<Types...>::T1 > ();

成为

std::make_unique< typeSel<0, Types...>::type > ();

以下是完整的C ++ 11示例，以防您需要std::tuple std:unique_ptr

#include <tuple>
#include <memory>

struct noTypeInList
 { };

template <std::size_t, typename ...>
struct typeSel;

template <typename T0, typename ... Ts>
struct typeSel<0U, T0, Ts...>
 { using type = T0; };

template <std::size_t N, typename T0, typename ... Ts>
struct typeSel<N, T0, Ts...>
 { using type = typename typeSel<N-1U, Ts...>::type; };

template <std::size_t N>
struct typeSel<N>
 { using type = noTypeInList; };

template <std::size_t ...>
struct range
 { };

template <std::size_t N, std::size_t ... Next>
struct rangeH 
 { using type = typename rangeH<N-1U, N-1U, Next ... >::type; };

template <std::size_t ... Next >
struct rangeH<0U, Next ... >
 { using type = range<Next ... >; };

template<typename... Types>
class Application
 {
   private:
      std::tuple<std::unique_ptr<Types>...> tpl;

      template <std::size_t ... rng>
      Application (const range<rng...> &)
         : tpl{std::make_tuple(std::unique_ptr<
                  typename typeSel<rng, Types...>::type>()...)}
          { }

   public:
      Application () : Application(typename rangeH<sizeof...(Types)>::type())
       { }
 };

int main()
 {
   Application<int, float, int, std::tuple<double, long>>  a;
 }

这只是使用typeSel的一个示例，因为Application可以简单地写为

template<typename... Types>
class Application
 {
   private:
      std::tuple<std::unique_ptr<Types>...> tpl;

   public:
      Application () : tpl{std::make_tuple(std::unique_ptr<Types>()...)}
       { }
 };

如果您可以使用C ++ 14编译器，则可以使用std::index_sequence和std::make_index_sequence（并删除range和rangeH）和Application可以成为

template<typename... Types>
class Application
 {
   private:
      std::tuple<std::unique_ptr<Types>...> tpl;

      template <std::size_t ... rng>
      Application (const std::index_sequence<rng...> &)
         : tpl{std::make_tuple(std::unique_ptr<
                  typename typeSel<rng, Types...>::type>()...)}
          { }

   public:
      Application () : Application(std::make_index_sequence<sizeof...(Types)>())
       { }
 };

Answer 3

最简单，最干净的方法，使用递归模板类：

template<class...> class Application;

template<class T> class Application<T>{
  public:
   Application()
   {
      std::make_unique<T> ();
   }
};
template<class T,class...Others> class Application<T,Others...>
                        :  public Application<Others...>{
  public:
   Application():Application<Others...>()
   {
      std::make_unique<T> ();
   }
};

使用tempate类型参数列表中的TYPE

3 个答案: