C++14使用std::integer_sequence展开tuple作为函数的参数

元组是一种长度固定的允许有不同类型元素的集合，根据元素的个数不同又分别称作一元组、二元组、三元组等。C++11中标准库增加了一个叫std::tuple的类模板，用于表示元组。

下面的代码演示了使用C++创建一个三元组。

auto tuple = std::make_tuple(1, 'A', "test");

std::cout << std::get<0>(tuple) << std::endl;

std::cout << std::get<1>(tuple) << std::endl;

std::cout << std::get<2>(tuple) << std::endl;

// 下面是C++14的特性

std::cout << std::get<int>(tuple) << std::endl;

std::cout << std::get<char>(tuple) << std::endl;

std::cout << std::get<const char*>(tuple) << std::endl;

输出

1

A

test

1

A

test

许多编程语言如C#、Python等也有tuple的概念。下面的代码演示了使用Python创建一个三元组。

t = (1, 'A', "test")

print(t[0])

print(t[1])

print(t[2])

输出

1

A

test

Python从语言级别上支持将tuple展开为函数的参数，在Python中假设定义有这样一个函数func和一个元组t，下面的代码演示了将元组t的每个元素作为func函数的参数。

def func(arg1, arg2, arg3):

    print(arg1, arg2, arg3)

t = (1, 'A', "test")

func(*t)

输出

1

1 A test

可变参数模板(Variadic Template)

C++没有并没有对类似Python的这种特性提供语言或库的支持，本文的目的就是为了介绍如何在C++中实现将tuple展开作为函数的参数。假设有函数func和元组tuple如下：

void func(int arg1, char arg2, const std::string& arg3);

{

    // ...

}

auto tuple = std::make_tuple(1, 'A', "test");

手动将tuple中的元素逐个取出后作为参数调用应是下面这样的。

1

func(std::get<0>(tuple), std::get<1>(tuple), std::get<2>(tuple));

观察手动调的参数，可以看出对于N元组，调用函数时的参数是这样的一个列表。

std::get<0>(t), std::get<1>(t), ……, std::get<N – 1>(t)

于是可以使用C++11的可变参数模板(Variadic Template)写一个这样的函数模板apply

template<std::size_t... I, typename F, typename T>

void apply(F f, const T& t)

{

  func(std::get<I>(t)...);

}

其中第1行中的std::size_t… I称为模板参数组(Template Parameter Pack)，第4行的std::get<I>(t)..称为参数组展开(Parameter Pack Expansion)。

使用这个函数模板apply将tuple展开作为参数调用func函数是这样写的。

1

apply<0, 1, 2>(func, tuple);

显然这样的调用方式还不够优雅，因为需要手动写模板参数。对于N元组，这里的模板参数是这样一个序列。

0, 1, 2, 3, 4, …, N-1

如果能够使用模板参数推导(Template argument deduction)自动推导出这个序列就方便多了。C++14中的std::integer_sequence提供了这种机制。

std::integer_sequence

C++14中标准库增加了std::integer_sequence类模板用于表示编译期的整数序列。其声明如下

template<class T, T... Ints>

class integer_sequence;

下面是各模板参数的描述

T 整数序列元素的类型

…Ints 整数序列的参数组(非类型)

为了方便使用，C++14的标准库中还使用C++11的模板别名(Template Typedef或Template Alias)特性声明了下面这几个辅助使用的别名模板。

template<std::size_t... Ints>

using index_sequence = std::integer_sequence<std::size_t, Ints...>;

template<class T, T N>

using make_integer_sequence = std::integer_sequence<T, /* a sequence 0, 1, 2, ..., N-1 */>;

template<std::size_t N>

using make_index_sequence = make_integer_sequence<std::size_t, N>;

template<class... T>

using index_sequence_for = std::make_index_sequence<sizeof...(T)>;

下面的代码演示了使用std::integer_sequence创建一个含有元素0, 1, 2, 3, …, 9的vector。通过第13行的模板参数10，推导出第5行的模板参数组为0, 1, 2, 3, …, 9。

#include <utility>

#include <vector>

#include <iostream>

template<std::size_t... I>

std::vector<std::size_t> make_index_vector(std::index_sequence<I...>)

{

  return {I...};

}

int main()

{

  auto vec = make_index_vector(std::make_index_sequence<10>());

  for(auto i : vec) {

    std::cout << i << ' ';

  }

  std::cout << std::endl;

}

输出

1

0 1 2 3 4 5 6 7 8 9

使用std::integer_sequence实现apply函数模板

对于tuple可以使用std::tuple_size获取元组的元素个数，类似于前面创建vector使用std::integer_sequance实现apply函数模板的代码如下。

template<typename F, typename T, std::size_t... I>

void apply_impl(F f, const T& t, std::index_sequence<I...>)

{

  f(std::get<I>(t)...);

}

template<typename F, typename T>

void apply(F f, const T& t)

{

  apply_impl(f, t, std::make_index_sequence<std::tuple_size<T>::value>());

}

至此，使用apply函数模板时就不再需要手动写模板参数了。

apply(func, tuple);

缺点是如果func函数有返回值，其返回值会被忽略。对于返回值的问题，可以使用C++11的新的函数声明语法(New Function Declarator Syntax)特性来解决。

template<typename F, typename T, std::size_t... I>

auto apply_impl(F f, const T& t, std::index_sequence<I...>) -> decltype(f(std::get<I>(t)...))

{

  return f(std::get<I>(t)...);

}

template<typename F, typename T>

auto apply(F f, const T& t) -> decltype(apply_impl(f, t, std::make_index_sequence<std::tuple_size<T>::value>()))

{

  return apply_impl(f, t, std::make_index_sequence<std::tuple_size<T>::value>());

}

最后附上apply函数模板的完整实现和使用演示的代码。

#include <tuple>

#include <iostream>

#include <string>

#include <utility>

int func1(int arg1, char arg2, double arg3, const std::string& arg4)

{

  std::cout << "call func1(" << arg1 << ", " << arg2 << ", " << arg3 << ", " << arg4 << ")" << std::endl;

  return 0;

}

int func2(int arg1, int arg2)

{

  std::cout << "call func2(" << arg1 << ", " << arg2 << ")" << std::endl;

  return arg1 + arg2;

}

template<typename F, typename T, std::size_t... I>

auto apply_impl(F f, const T& t, std::index_sequence<I...>) -> decltype(f(std::get<I>(t)...))

{

  return f(std::get<I>(t)...);

}

template<typename F, typename T>

auto apply(F f, const T& t) -> decltype(apply_impl(f, t, std::make_index_sequence<std::tuple_size<T>::value>()))

{

  return apply_impl(f, t, std::make_index_sequence<std::tuple_size<T>::value>());

}

int main()

{

  using namespace std::literals::string_literals;

  auto tuple1 = std::make_tuple(1, 'A', 1.2, "test"s);

  auto result1 = apply(func1, tuple1);

  std::cout << "result1 = " << result1 << std::endl;

  auto tuple2 = std::make_tuple(1, 2);

  auto result2 = apply(func2, tuple2);

  std::cout << "result2 = " << result2 << std::endl;

}

输出

call func1(1, A, 1.2, test)

result1 = 0

call func2(1, 2)

result2 = 3