选择可变参数模板最后一个参数的有效方法

Question

我知道如何选择可变参数模板的第一个参数：

template< class...Args> struct select_first;
template< class A, class ...Args> struct select_first<A,Args...>{  using type = A;};

这非常简单。然而，select_last 并不相似：

template< class ...Args> struct select_last;
template< class A> struct select_last<A> { using type = A; };
template< class A, class Args...> struct select_last<A,Args...>{ 
        using type = typename select_last<Args...>::type;
};

该解决方案需要深度递归模板实例化。我尝试用 as 来解决这个问题：

template< class A, class Args...>
struct select_last< Args ... , A>{  using type = A; }; // but it's not compiled.

问：是否存在更有效的方法来选择可变参数模板的最后一个参数？

Answer 1

使用 C++17，最简洁的方法是

template<typename T>
struct tag
{
    using type = T;
};

template<typename... Ts>
struct select_last
{
    // Use a fold-expression to fold the comma operator over the parameter pack.
    using type = typename decltype((tag<Ts>{}, ...))::type;
};

具有 O(1) 实例化深度。

Answer 2

与上次相同的方法，O(logN) 实例化深度。仅使用 one 重载，因此它应该消耗更少的资源。

~~警告：它当前从元组类型中删除引用。~~ 注意：删除了

pack::declval

中的参考。我认为它在任何情况下仍然有效。

O(log(N)) 实例化中的索引技巧，作者：Xeo；修改为使用

std::size_t

代替

unsigned

    #include <cstddef>

    // using aliases for cleaner syntax
    template<class T> using Invoke = typename T::type;

    template<std::size_t...> struct seq{ using type = seq; };

    template<class S1, class S2> struct concat;

    template<std::size_t... I1, std::size_t... I2>
    struct concat<seq<I1...>, seq<I2...>>
      : seq<I1..., (sizeof...(I1)+I2)...>{};

    template<class S1, class S2>
    using Concat = Invoke<concat<S1, S2>>;

    template<std::size_t N> struct gen_seq;
    template<std::size_t N> using GenSeq = Invoke<gen_seq<N>>;

    template<std::size_t N>
    struct gen_seq : Concat<GenSeq<N/2>, GenSeq<N - N/2>>{};

    template<> struct gen_seq<0> : seq<>{};
    template<> struct gen_seq<1> : seq<0>{};

今天，我意识到有一个不同的、更简单的、可能更快（编译时间）的解决方案来获取元组的第 n 个类型（基本上是

std::tuple_element

的实现）。尽管这是另一个问题的直接解决方案，但为了完整性，我也会将其发布在这里。

namespace detail
{
    template<std::size_t>
    struct Any
    {
        template<class T> Any(T&&) {}
    };

    template<typename T>
    struct wrapper {};

    template<std::size_t... Is>
    struct get_nth_helper
    {
        template<typename T>
        static T deduce(Any<Is>..., wrapper<T>, ...);
    };

    template<std::size_t... Is, typename... Ts>
    auto deduce_seq(seq<Is...>, wrapper<Ts>... pp)
    -> decltype( get_nth_helper<Is...>::deduce(pp...) );
}

#include <tuple>

template<std::size_t n, class Tuple>
struct tuple_element;

template<std::size_t n, class... Ts>
struct tuple_element<n, std::tuple<Ts...>>
{
    using type = decltype( detail::deduce_seq(gen_seq<n>{},
                                              detail::wrapper<Ts>()...) );
};

最后一个元素的助手：

template<typename Tuple>
struct tuple_last_element;

template<typename... Ts>
struct tuple_last_element<std::tuple<Ts...>>
{
    using type = typename tuple_element<sizeof...(Ts)-1,
                                        std::tuple<Ts...>> :: type;
};

使用示例：

#include <iostream>
#include <type_traits>
int main()
{
    std::tuple<int, bool, char const&> t{42, true, 'c'};

    tuple_last_element<decltype(t)>::type x = 'c'; // it's a reference

    static_assert(std::is_same<decltype(x), char const&>{}, "!");
}

原版：

#include <tuple>
#include <type_traits>

namespace detail
{
    template<typename Seq, typename... TT>
    struct get_last_helper;

    template<std::size_t... II, typename... TT>
    struct get_last_helper< seq<II...>, TT... >
    {
        template<std::size_t I, std::size_t L, typename T>
        struct pack {};
        template<typename T, std::size_t L>
        struct pack<L, L, T>
        {
            T declval();
        };

        // this needs simplification..
        template<typename... TTpacked>
        struct exp : TTpacked...
        {
            static auto declval_helper()
                -> decltype(std::declval<exp>().declval());
            using type = decltype(declval_helper());
        };

        using type = typename exp<pack<II, sizeof...(TT)-1, TT>...>::type;
    };
}

template< typename Tuple >
struct get_last;

template< typename... TT >
struct get_last<std::tuple<TT...>>
{
    template<std::size_t... II>
    static seq<II...> helper(seq<II...>);
    using seq_t = decltype(helper(gen_seq<sizeof...(TT)>()));

    using type = typename detail::get_last_helper<seq_t, TT...>::type;
};


int main()
{
    using test_type = std::tuple<int, double, bool, char>;

    static_assert(std::is_same<char, get_last<test_type>::type>::value, "!");
    // fails:
    static_assert(std::is_same<int, get_last<test_type>::type>::value, "!");
}

Answer 3

如果您愿意从类型列表中盲目地删除引用（这种情况很常见：要么您知道它们是引用，要么您不在乎），您可以使用

std

之外的少量机制来完成此操作。基本上将数据填充到

tuple

或

tie

中，然后使用

std::get<sizeof...(X)-1>( tuple or tie )

提取最后一个元素。

您可以在纯类型上下文中使用

std::declval< std::tuple<Args...> >()

和

decltype

以及可能的

std::remove_reference

来完成此操作。

举个例子，假设你有一组可变的参数，并且你想返回最后一个参数而忽略其余参数：

#define RETURNS(x) ->decltype(x) { return (x); }

template<typename ...Args>
auto get_last( Args&&... args )
  RETURNS( std::get< sizeof...(Args)-1 >( std::tie(std::forward<Args>(args)...) ) )

然后我们可以在另一个函数中使用它：

template<typename ...Args>
void foo( Args&&... args ) {
  auto&& last = get_last(std::forward<Args>(args)...);
}

Answer 4

以下是另一种精益的 C++17 方法，它也使用 fold-表达式；但通过使用

std::enable_if

:

避免了临时类代理

template <typename ...Ts>
struct select_last
{
  using type = typename decltype((std::enable_if<true,Ts>{}, ...))::type;
};

template <typename ...Ts>
using select_last_t = typename select_last<Ts...>::type;

static_assert(std::is_same_v<char, select_last_t<int,double,char>>);

在 C++20 中

std::type_identity

提供了一种更具可读性的方法：

// C++20
template <typename ...Ts>
struct select_last
{
  using type = typename decltype((std::type_identity<Ts>{}, ...))::type;
};

在 C++26 中，来自 P2662 的包索引允许我们保存更多字符：

template <typename ...Ts>
Ts...[sizeof...(Ts)-1] select_last();

static_assert(std::is_same_v<char, decltype(select_last<int,double,char>())>);

Answer 5

如果 C++17 可用并且仅对最后一种类型感兴趣，那么这个

其他解决方案非常出色。

如果需要 C++14 支持（C++11 加

index_sequence

）或者如果对第 n 种类型感兴趣，那么一个好的解决方案是

#include <utility>

////////////////////////////////////////////////////////////////////////////////

template<std::size_t n, std::size_t i, class>
struct type_if_equal {
  static_assert(n != i, "see specialization");
// missing `type` typedef by purpose
};

template<std::size_t n, class T>
struct type_if_equal<n, n, T> {
  using type = T;
};

////////////////////////////////////////////////////////////////////////////////

template<std::size_t n, class Is, class... Ts>
struct select_nth;

template<std::size_t n, std::size_t... is, class... Ts>
struct select_nth<n, std::index_sequence<is...>, Ts...>
  : type_if_equal<n, is, Ts>...
{};

template<std::size_t n, class... Ts>
using select_nth_t = typename select_nth<
  n, std::index_sequence_for<Ts...>, Ts...
>::type;

////////////////////////////////////////////////////////////////////////////////

template<class T0, class... Ts>
using select_last_t = select_nth_t<sizeof...(Ts), T0, Ts...>;

////////////////////////////////////////////////////////////////////////////////

int main() {
  using T = select_last_t<int, double, double, long, long, long, int, char>;
  static_assert(std::is_same<T, char>{}, "");
}

警告：如果您需要快速编译巨大的可变参数列表，请不要使用像select_nth_t

这样简单的自制解决方案。为此目的有高度优化的模板元编程库。查看

metaben.ch 来比较几种算法的编译时性能。这个算法叫做at

，这是我使用GCC 10基于

这个代码

对

select_nth_t的测量结果：

请参阅

Louis Dionne 和 Odin Holmes 的博客文章，了解有关减少 at

 算法（又名

std::tuple_element_t

）编译时间的优秀背景信息。

Answer 6

template <class... Args>
struct select_last;

template <typename T>
struct select_last<T>
{
     using type = T;
};

template <class T, class... Args>
struct select_last<T, Args...>
{
    using type = typename select_last<Args...>::type;
};

Answer 7

抱歉参加聚会有点晚了，但我刚刚遇到了同样的问题，寻找答案，不喜欢我在这里看到的内容，并意识到可以使用元组来完成。请参阅下面的 C++11 实现。注意：还可以通过这种方式访问第 N 种类型的可变参数模板。（该示例不检查 N 是否超过可变参数的数量，但是可以使用 SFINAE 技术（例如enable_if）来完成检查）这是一个可以接受的答案还是我遗漏了问题中的任何内容？

#include <tuple>
#include <iostream>

struct A
{
    char ch = 'a';
};
struct B
{
    char ch = 'b';
};
struct C
{
    char ch = 'c';
};


template <typename... Types>
struct SomeVariadic {

    using TypesTuple = std::tuple<Types...>;

    using LastType = typename std::tuple_element<sizeof...(Types)-1, TypesTuple>::type;

    template <int N>
    using NthType = typename std::tuple_element<N, TypesTuple>::type;
};



int main(int argc, char* argv[]) {

    SomeVariadic<A,B,C>::LastType l;

    std::cout << SomeVariadic<A,B,C>::LastType().ch << " "
            << SomeVariadic<A,B,C>::NthType<1>().ch<< std::endl;
}

Answer 8

一个非常愚蠢的方法是编写一个辅助类并专门针对每个参数数量（最多可达您选择的某些限制）。您可以为此使用预处理器。

template<typename...>
struct select_last_helper;

template<typename T1>
struct select_last_helper<T1> {
    using type = T1;
};

template<typename T1, typename T2>
struct select_last_helper<T1,T2> {
    using type = T2;
};

template<typename T1, typename T2, typename T3>
struct select_last_helper<T1,T2,T3> {
    using type = T3;
};

template<typename... Ts>
struct select_last {
    using type = typename select_last_helper<Ts...>::type;
};

O(1) 模板实例化 :)

选择可变参数模板最后一个参数的有效方法

问题描述投票：0回答：8

8个回答

最新问题

选择可变参数模板最后一个参数的有效方法

问题描述 投票：0回答：8

8个回答

最新问题

问题描述投票：0回答：8