0

型エイリアス内でテンプレート テンプレート引数を使用することは可能ですか? たとえば、次のような型エイリアスを書くことは可能ですか?

#include "tuple"

template<
    template<class... Types> class Container,
    class... Types
> using another_tuple = std::tuple<Types...>;

another_tuple<std::tuple<int>> t;

std::tuple などを指定すると、そのタイプを他の何かに使用するものはどれですか? GCC と Clang の両方がエラーでクラス テンプレートについて言及していますが、クラス テンプレートを必要としないようにするにはどうすればよいですか? ...s をすべて削除すると、GCC エラーは次のように変わります。

error: wrong number of template arguments (1, should be 2)
another_tuple<std::tuple<int>> t;
                            ^

わかりません。コンテナー自体はテンプレートである必要はありませんが、代わりに std::tuple を使用する方法がわかりませんでした。

nms の回答に基づいて更新します。正しい形式は次のとおりです。

another_tuple<std::tuple, int> t;

同様に、型がコンテナー内にある場合でも:

using types = std::tuple<int, char>;
another_tuple<std::tuple, types> t;

少し冗長なコードがありますが、十分なはずです。

4

1 に答える 1

0 
template<class T>struct tag{using type=T;};
template<class Tag>using type_t=typename Tag::type;
template<class...>struct types{using type=types;};

template<template<class...>class Z, class types>
struct apply_types;
template<template<class...>class Z, class types>
using apply_types_t=type_t<apply_types<Z,types>>;
template<template<class...>class Z, class...Ts>
struct apply_types<Z,types<Ts...>>:tag<Z<Ts...>> {};

template<template<class...>class M, class types>
struct map;
template<template<class...>class M, class types>
using map_t=type_t<map<M,types>>;
template<template<class...>class M, class...Ts>
struct map<M,types<Ts...>>:types<M<Ts>...>{};

template<class...lists>
struct concat:types<>{};
template<class...lists>
using concat_t=type_t<concat<lists...>>;
template<class...lhs, class...rhs>
struct concat<types<lhs...>,types<rhs...>>:
  types<lhs...,rhs...>
{};
template<class types>
struct concat<types>:
  types
{};
template<class types, class...more_types>
struct concat<types, more_types...>:
  concat<types, concat_t<more_types...>>
{};

template<class A, template<class...>class C, class T, class F>
struct condition:std::conditional<C<A>{}, T, F>{};

template<template<class...>class Z, class... T>
struct bind_1st_n {
  template<class...Ts>
  using apply=Z<T..., Ts...>;
};

template<class Tok, class list, class A>
struct replace_helper:
  condition<A, bind_1st_n<std::is_same, Tok>::template apply, list, types<A>>
{};

template<class list, class if_this, class then_these>
struct replace:
  concat<
    map_t<
      bind_1st_n<replace_helper,if_this, then_these>::template apply,
      list
    >
  >
{};

struct placeholder {};

template<class T> struct get_args;
template<class T> using get_args_t=type_t<get_args<T>>;
template<template<class...>class Z, class...Ts>
struct get_args<Z<Ts...>>:types<Ts...> {};

template<template<class...>class Z, class types>
struct apply;
template<template<class...>class Z, class types>
using apply_t=type_t<apply<Z,types>>;


template< class Container >
using another_tuple = apply_t< std::tuple, get_args_t<Container> >;

また、前に int を付けて展開し、最後に double を付けてリストを展開する場合は、次のようにします。

template< class Container >
using another_tuple = apply_t< std::tuple,
  replace_t<
    types<int, placeholder, double>,
    placeholder,
    get_args_t<Container>
  >
>;

適用するリストを作成し、それを 2 つのステップで適用します。

このコードはコンパイルされていません。

于 2015-05-25T20:56:11.713 に答える