1

假设我有一个可以递增的模板参数列表。我想增加这个列表的头部。这是代码

template<int N>
struct Counter {
    static constexpr Counter<N+1> increment();
};
template<int N>
constexpr Counter<N+1> Counter<N>::increment() {
    return Counter<N+1>();
}

//List (will be used as List of Counters)
template <typename... TAIL>
struct List {};

template <typename HEAD, typename... TAIL>
struct List<HEAD,TAIL...> {};



template <typename HEAD, typename... TAIL>
auto incrFront() -> decltype(List<decltype(HEAD::increment()),TAIL...>()) {
    return List<decltype(HEAD::increment()),TAIL...>();
}

它确实有效：

auto l0 = incrFront<Counter<0>>(); // Ok, decltype(l0) == List<Counter<1>>
l0 =  List<Counter<1>>(); //Ok, right type
auto l1 = incrFront<Counter<0>,Counter<1>>();  // Ok, decltype(l1) == List<Counter<1>,Counter<1>>
l1 = List<Counter<1>,Counter<1>>();

现在，我想增加列表的后面，所以

template <typename... HEAD, typename TAIL>
auto incrBack() -> decltype(List<decltype(HEAD...,TAIL::increment())>()) {
    return List<decltype(HEAD...,TAIL::increment()>();
}

但是在这个范围内没有声明错误'incrBack'

我尝试在此之前添加另一种方法：

template <typename... HEAD>
auto incrBack() -> decltype(List<HEAD...>()) {
    std::cout << "Should not be here\n";
    return List<HEAD...>();
}

希望在解决重载时永远不会调用此方法，但确实调用了此方法。

有什么线索吗？我只是希望这个例子能够正常工作：

auto l2 = incrBack<Counter<1>,Counter<1>>();  // I want decltype(l2) == List<Counter<1>,Counter<2>>
l2 = incrFront<Counter<0>,Counter<2>>();  //should be possible
4

1 回答 1

3

首先，编写代码来操作List<>而不是裸变量类型列表，这会更容易。

其次，不要使用模板函数，而是使用模板类。

template<typename T>
struct inc {
  typedef decltype(T::increment()) type;
};
template<typename T>
using Inc = typename inc<T>::type;

现在我们可以讨论Inc<HEAD>而不是decltype( HEAD::increment() )，这应该使您的代码更具可读性。

编写以下template类：

template<typename List, typename T>
struct append;
template<typename List, typename T>
using Append = typename append<List,T>::type;
template<template<typename...>class TypeList, typename... Ts, typename T>
struct append<TypeList<Ts...>, T> {
  typedef TypeList<Ts..., T> type;
};
template<typename List>
struct reverse;
template<typename List>
using Reverse = typename reverse<List>::type;
template<template<typename...>class TypeList>
struct reverse<TypeList<>> {
  typedef TypeList<> type;
};
template<template<typename...>class TypeList, typename T0, typename... Ts>
struct reverse<TypeList<T0, Ts...>> {
  typedef Append< Reverse<TypeList<Ts...>>, T0 > type;
};

和类似的。请注意，我对类型进行操作，并且我专注于从传递给 a 的一些通用可变类型包产生的类型template——这意味着我不依赖于使用一种方法将可变参数打包成单一类型。

我还写template了别名来减少typename垃圾邮件。

接下来，应用函子：

template<template<typename>class Func, typename List>
struct apply_to_first;
template<template<typename>class Func, typename List>
using ApplyToFirst = typename apply_to_first<Func, List>::type;
template<template<typename>class Func, template<typename...>class TypeList, typename T0, typename... Ts>
struct apply_to_first<Func, TypeList<T0, Ts...>> {
  typedef TypeList< typename Func<T0>::type, Ts... > type;
};

然后IncFirst：

template<typename List>
using IncFirst = ApplyToFirst< inc, List >;

现在很短。

至于IncLast，则稍微难一些：

template<typename List>
using IncLast = Reverse< IncFirst < Reverse<List> > >;

但仍然适合一条线。不过，我更喜欢这个更详细的版本：

template<template<typename>class Func, typename List>
using ApplyToLast = Reverse< ApplyToFirst< Func, Reverse<List> > >;

template<typename List>
using IncLast = ApplyToLast< inc, List >;

现在，我没有直接回答你的问题，因为我从来没有写过incrFront（我也没有编译上面的，所以它可能充满了语法错误）。

因此incrFirst，incrLast在您将繁重的工作转移到上述迷你元编程库之后：

template<typename... Ts>
IncFirst<List<Ts...>> incrFirst() {
  return IncFirst<List<Ts...>>();
}
template<typename... Ts>
IncLast<List<Ts...>> incrLast() {
  return IncLast<List<Ts...>>();
}
于 2013-05-21T13:47:43.913 回答