C++之std::tuple(一) : 使用精讲(全)

已于 2024-05-09 21:42:17 修改
阅读量5.3k 收藏 46
点赞数 54
分类专栏： #C++进阶 文章标签： c++ 开发语言
于 2024-02-03 15:44:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haokan123456789/article/details/136006995
版权

相关系列文章

C++之std::tuple(二) : 揭秘底层实现原理

C++三剑客之std::any(一) : 使用

C++之std::tuple(一) : 使用精讲(全)

C++三剑客之std::variant(一) : 使用

C++三剑客之std::variant(二)：深入剖析

深入理解可变参数(va_list、std::initializer_list和可变参数模版)

std::apply源码分析

目录

1.简介

2.std::ignore介绍

3.创建元组

3.1.直接初始化方式

3.2.使用花括号初始化列表方式（C++11及以上版本）

3.3.make_tuple方式

3.4.使用std::tie()函数方式

4.元素访问

4.1.std::get()方式

4.2.使用结构化绑定（C++17及以上）

4.3.递归遍历元素

4.4.std::apply方式(C++17及以上)

5.获取std::tuple的size

6.获取元组中的元素类型

7.std::forward_as_tuple

8.std::tuple_cat

9.std::swap

10.std::make_from_tuple

11.项目实战

11.1.std::tuple的序列化和反序列化

11.2.获取std::tuple的数据大小

12.总结

1.简介

        C++11之后引入了std::tuple，俗称元组，元组(tuple)是一种用于组合多个不同类型的值的数据结构。元组可以将不同类型的数据打包在一起，类似于一个容器，可以按照索引顺序访问其中的元素。元组的大小在编译时确定，不支持动态添加或移除元素。std::tuple的定义如下：

template<class... Types>
class tuple;

        std::tuple类似互C语言的结构体，不需要创建结构体而又有结构体的特征，在某些情况下可以取代结构体而使得程序更加简洁，直观。std::tuple理论上可以定义无数多个不同类型的成员变量。特别是你需要在函数之间返回多个值时，或者需要一次性处理多个相关值时，使用元组可以简化代码并提高可读性。

2.std::ignore介绍

在标头 <tuple> 定义，任何值均可赋给而无效果的未指定类型的对象。目的是令 std::tie 在解包 std::tuple 时作为不使用的参数的占位符使用。例如：解包 set.insert() 所返回的 pair ，但只保存布尔值。

#include <iostream>
#include <string>
#include <set>
#include <tuple>
 
int main()
{
    std::set<std::string> set_of_str;
    bool inserted = false;
    std::tie(std::ignore, inserted) = set_of_str.insert("Test");
    if (inserted) {
        std::cout << "Value was inserted successfully\n";
    }
}

输出：Value was inserted successfully

3.创建元组

3.1.直接初始化方式

//显示初始化
std::tuple<bool, int, double, std::string>  a(true, 1, 3.0, "1112222");

3.2.使用花括号初始化列表方式（C++11及以上版本）

//显示初始化
std::tuple<bool, int, double, std::string>  a{true, 1, 3.0, "1112222"};

3.3.make_tuple方式

//显示初始化
std::tuple<bool, int, double, std::string> a = make_tuple(true, 1, 3.0, "1112222");

//隐式初始化
auto b = make_tuple(true, 1, 3.0, "1112222");

3.4.使用std::tie()函数方式

 std::tie定义为：

template<class... Types>
constexpr tuple<Types&...> tie (Types&... args) noexcept;
std::tie生成一个tuple,此tuple包含的分量全部为实参的引用，与make_tuple完全相反。主要用于从tuple中提取数据。例如：

bool myBool;
int myInt;
double myDouble;
std::string myString;

std::tie(myBool, myInt, myDouble, myString) = std::make_tuple(true, 1, 3.0, "1112222");

如果是要忽略某个特定的元素，还可以使用第2章节的std::ignore来占位，例如：

bool myBool;
std::string myString;

std::tie(myBool, std::ignore, std::ignore, myString) = std::make_tuple(true, 1, 3.0, "1112222");

4.元素访问

4.1.std::get<index>()方式

使用std::get来访问std::tuple特定的元素，如：

std::tuple<bool, int, std::string> a(true, 0, "sfsfs");
bool b = std::get<0>(a);
int  c = std::get<1>(a);
std::string d = std::get<2>(a);

std::get<0>(a) = false;
std::get<2>(a) = "s344242";

4.2.使用结构化绑定（C++17及以上）

在C++17及以上版本中，还可以使用结构化绑定 (structured bindings) 的方式来创建和访问元组，可以更方便地访问和操作元组中的元素。结构化绑定允许直接从元组中提取元素并赋值给相应的变量。例如：

std::tuple<bool, int, std::string> myTuple(true, false, "Hello");
auto [a, b, c] = myTuple;

这将自动创建变量a、b和c，并将元组中相应位置的值赋给它们。

注意：

元组是不可变的（immutable）一旦创建就不能更改其元素的值。但是，可以通过解构赋值或使用std::get<index>(tuple)来获取元组中的值，并将新的值赋给它们，从而修改元组中的值。

std::tuple不支持迭代器，获取元素的值时只能通过元素索引或tie解包。给定的索引必须是在编译期间就已经确定的，不能在运行期间动态传递，否则会产生编译错误

4.3.递归遍历元素

        由于 tuple 自身的原因，无法直接遍历，而 get<index> 中 index 必须为运行前设置好的常数
所以 tuple 的遍历需要我们手写，代码如下:

template<class Tuple, std::size_t N>
struct VisitTuple {
    static void Visit(const Tuple& value) {
        VisitTuple<Tuple, N - 1>::Visit(value);
        std::cout << ' ' << std::get<N - 1>(value);
        return void();
    }
};
 
template<class Tuple>
struct VisitTuple<Tuple, 1> {
    static void Visit(const Tuple& value) {
        std::cout << std::get<0>(value);
        return void();
    }
};
 
template<class... Args>
void TupleVisit(const std::tuple<Args...>& value) {
    VisitTuple<decltype(value), sizeof ...(Args)>::Visit(value);
}

4.4.std::apply方式(C++17及以上)

利用可变参数的折叠表达式规则来访问std::tuple的元素，例如：

#include <iostream>
#include <tuple>
#include <utility>
 
int add(int first, int second) { return first + second; }
 
template<typename T>
T add_generic(T first, T second) { return first + second; }
 
auto add_lambda = [](auto first, auto second) { return first + second; };
 
template<typename... Ts>
std::ostream& operator<<(std::ostream& os, std::tuple<Ts...> const& theTuple)
{
    std::apply
    (
        [&os](Ts const&... tupleArgs)
        {
            os << '[';
            std::size_t n{0};
            ((os << tupleArgs << (++n != sizeof...(Ts) ? ", " : "")), ...);
            os << ']';
        }, theTuple
    );
    return os;
}
 
int main()
{
    // OK
    std::cout << std::apply(add, std::pair(1, 2)) << '\n';
 
    // 错误：无法推导函数类型
    // std::cout << std::apply(add_generic, std::make_pair(2.0f, 3.0f)) << '\n'; 
 
    // OK
    std::cout << std::apply(add_lambda, std::pair(2.0f, 3.0f)) << '\n'; 
 
    // 进阶示例
    std::tuple myTuple(25, "Hello", 9.31f, 'c');
    std::cout << myTuple << '\n';
}

输出：

3
5
[25, Hello, 9.31, c]

        上面语句((os << tupleArgs << (++n != sizeof...(Ts) ? ", " : "")), ...);利用了C++17的折叠表达式，折叠表达式是C++17新引进的语法特性。使用折叠表达式可以简化对C++11中引入的参数包的处理，从而在某些情况下避免使用递归。如果有不是很明白的地方，可参考我的博客深入理解可变参数(va_list、std::initializer_list和可变参数模版)-CSDN博客

        关于std::applay的使用有不明白的地方，可以参考我的博客std::apply源码分析-CSDN博客

5.获取std::tuple的size

std::tuple_size的定义如下：

template< class... Types >
struct tuple_size< std::tuple<Types...> >
    : std::integral_constant<std::size_t, sizeof...(Types)> { };

提供对 tuple 中元素数量的访问，作为编译时常量表达式，计算std::tuple的大小。例如：

#include <iostream>
#include <tuple>
 
template <class T>
void test(T value)
{
    int a[std::tuple_size_v<T>]; // 能用于编译时
 
    std::cout << std::tuple_size<T>{} << ' ' // 或运行时
              << sizeof a << ' ' 
              << sizeof value << '\n';
}
 
int main()
{
    test(std::make_tuple(1, 2, 3.14));
}

可能的输出：3 12 16

6.获取元组中的元素类型

std::tuple_element定义如下：

template< std::size_t I, class... Types >
class tuple_element< I, tuple<Types...> >;

可以使用std::tuple_element<index, tuple>::type来获取元组中特定索引位置的元素类型。

#include <iostream>
#include <tuple>
 
template <class... Args>
struct type_list
{
   template <std::size_t N>
   using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
};
 
int main()
{
   std::cout << std::boolalpha;
   type_list<int, char, bool>::type<2> x = true;
   std::cout << x << '\n';
}

输出：true

7.std::forward_as_tuple

定义如下：

template< class... Types >
tuple<Types&&...> forward_as_tuple( Types&&... args ) noexcept;
template< class... Types >
constexpr tuple<Types&&...> forward_as_tuple( Types&&... args ) noexcept;

用于接受右值引用数据生成 tuple, 与 std::make_tuple 不同的是它的右值是引用的，当修改其值的时候，原来赋值所用的右值也将修改，实质上就是赋予了它地址。同std::tie一样，也是生成一个全是引用的tuple,不过std::tie只接受左值，而std::forward_as_tuple左值、右值都接受。主要是用于不损失类型属性的转发数据。

注意此处 tuple 内的类型应为引用，否则相当于 std::make_tuple。例如：

signed main(int argc, char *argv[]) {
    int a = 123, c = 456;
    float b = 33.f, d = .155;
 
    std::tuple<int&, float&, int&, float&> tu = std::forward_as_tuple(a,b,c,d);
 
    std::get<0> (tu) = 2;
    std::get<1> (tu) = 4.5f;
    std::get<2> (tu) = 234;
    std::get<3> (tu) = 22.f;
 
    std::cout << a << std::endl; // 2
    std::cout << b << std::endl; // 4.5
    std::cout << c << std::endl; // 234
    std::cout << d << std::endl; // 22
    return 0;
}

注意：若参数是临时量，则 forward_as_tuple 不延续其生存期；必须在完整表达式结尾前使用它们。

8.std::tuple_cat

        此函数接受多个tuple作为参数，然后返回一个tuple。返回的这个tuple将tuple_cat的参数中的tuple的所有元素按所属的tuple在参数中的顺序以及其在tuple中的顺序排列成一个新的tuple。新tuple中元素的类型与参数中的tuple中的元素的类型完全一致。例如：

#include <iostream>
#include <string>
#include <tuple>
 
// 打印任何大小 tuple 的辅助函数
template<class Tuple, std::size_t N>
struct TuplePrinter
{
    static void print(const Tuple& t)
    {
        TuplePrinter<Tuple, N - 1>::print(t);
        std::cout << ", " << std::get<N-1>(t);
    }
};
 
template<class Tuple>
struct TuplePrinter<Tuple, 1>
{
    static void print(const Tuple& t) 
    {
        std::cout << std::get<0>(t);
    }
};
 
template<class... Args>
void print(const std::tuple<Args...>& t) 
{
    std::cout << "(";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}
// 辅助函数结束
 
int main()
{
    std::tuple<int, std::string, float> t1(10, "Test", 3.14);
    int n = 7;
    auto t2 = std::tuple_cat(t1, std::make_tuple("Foo", "bar"), t1, std::tie(n));
    n = 10;
    print(t2);
}

输出：(10, Test, 3.14, Foo, bar, 10, Test, 3.14, 10)

9.std::swap

交换两个std::tuple的内容，前提是两个std::tuple的大小和元素类型必须相同，例如：

std::tuple<int, double, char> a1;
std::tuple<int, double, char> a2;
std::tuple<unsigned int, double, char> a3;
std::tuple<int, std::string, char> a4;
std::tuple<int, double, char, std::string> a5;
a1.swap(a2); //OK
a2.swap(a3); //编译出现error
a3.swap(a4);//编译出现error
a4.swap(a5);//编译出现error

上面a1和a2的大小和元素类型都相同，因此可以交换。a2和a3、a3和a4、a4和a5类型不相同，因此不能交换。我们再看一个std::tuple交换的例子：

#include <iostream>
#include <string>
#include <tuple>
 
int main()
{
    std::tuple<int, std::string, float>
                      p1{42, "ABCD", 2.71},
                      p2;
    p2 = std::make_tuple(10, "1234", 3.14);
 
    auto print_p1_p2 = [&](auto rem) {
        std::cout << rem
                  << "p1 = {" << std::get<0>(p1)
                  << ", "     << std::get<1>(p1)
                  << ", "     << std::get<2>(p1) << "}, "
                  << "p2 = {" << std::get<0>(p2)
                  << ", "     << std::get<1>(p2)
                  << ", "     << std::get<2>(p2) << "}\n";
    };
 
    print_p1_p2("Before p1.swap(p2): ");
    p1.swap(p2);
    print_p1_p2("After  p1.swap(p2): ");
    swap(p1, p2);
    print_p1_p2("After swap(p1, p2): ");
}

输出：

Before p1.swap(p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}
After  p1.swap(p2): p1 = {10, 1234, 3.14}, p2 = {42, ABCD, 2.71}
After swap(p1, p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}

10.std::make_from_tuple

std::make_from_tuple是以元组std::tuple的元素作为构造函数的参数构造别的类型对象，如下例子：

#include <iostream>
#include <tuple>
 
struct Foo
{
    Foo(int first, float second, int third)
    {
        std::cout << first << ", " << second << ", " << third << "\n";
    }
};
 
int main()
{
    auto tuple = std::make_tuple(42, 3.14f, 0);
    std::make_from_tuple<Foo>(std::move(tuple));
}

输出：42, 3.14, 0

11.项目实战

11.1.std::tuple的序列化和反序列化

利用QDataStream的序列化数据，重写操作符operator<<和operator>>，代码如下：

template<typename... Ts>
QDataStream& operator<<(QDataStream& dataStream, std::tuple<Ts...> const& theTuple)
{
    std::apply
    (
        [&dataStream](Ts const&... tupleArgs){
            ((dataStream << tupleArgs), ...);
        }, theTuple
    );
    return dataStream;
}

template<typename... Ts>
QDataStream& operator>>(QDataStream& dataStream, std::tuple<Ts...>& theTuple)
{
    std::apply
    (
        [&dataStream](Ts&... tupleArgs){
            ((dataStream >> tupleArgs), ...);
        }, theTuple
    );
    return dataStream;
}

或

template<typename... Ts>
QDataStream& operator<<(QDataStream& dataStream, std::tuple<Ts...> const& theTuple)
{
    std::apply
    (
        [&dataStream](Ts const&... tupleArgs){
            (dataStream << ... << tupleArgs);
        }, theTuple
    );
    return dataStream;
}

template<typename... Ts>
QDataStream& operator>>(QDataStream& dataStream, std::tuple<Ts...>& theTuple)
{
    std::apply
    (
        [&dataStream](Ts&... tupleArgs){
            (dataStream >> ... >> tupleArgs);
        }, theTuple
    );
    return dataStream;
}

11.2.获取std::tuple的数据大小

获取std::tuple的实际内容大小，但是std::tuple不能包含可变内容长度字段，代码如下：

template<class Tuple, std::size_t N>
struct stTupleContentSize{
    using first = typename std::tuple_element<N-1, Tuple>::type;
    using others = stTupleContentSize<Tuple, N-1>;
    static constexpr std::size_t = sizeof(first) + others::size;
};

template<class Tuple>
struct stTupleContentSize<Tuple, 1>{
    using first = typename std::tuple_element<0, Tuple>::type;
    static constexpr std::size_t = sizeof(first);
};

调用方法：

using queryWaveParamData = std::tuple<int, bool, double, long>;
constexpr int queryWaveParamDataSize = stTupleContentSize<queryWaveParamData, std::tuple_size_v<queryWaveParamData>>::size;

12.总结

std::tuple 是一种重要的数据结构，可以用于在函数参数之间传递数据，也可以作为函数的返回值。在实际项目中，我们可以灵活地使用 std::tuple，以简化代码，提高程序的性能。

后面我们将继续通过分析std::tuple源码的方式来更深层次讲解它的实现原理，值得期待哦。。。

参考：std::tuple - cppreference.com

流星雨爱编程
关注
  • 54
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 20
    评论
专栏目录
C++11新特性std::tuple的使用方法
12-16
1. 引入头文件 #include 2. std::tuple初始化 std::tuple t1(10, "Test", 3.14); 这里要注意，不是所有的C++ 11编译器都支持copy-list-initialization的方式。如下代码所示。 std::tuple foo_tuple() { return {1, -1}; // Error until N4387 return std::tuple{1, -1}; // Always works return
【C++】std::tuple
qq_45233802的博客
08-29 530
std::tuple是C++11新标准引入的一个类模板，又称元组，是一个固定大小的异构值集合，由std::pair泛化而来。pair可以看作是tuple的一种特殊情况，成员类目限定为两个。tuple可以有任意个成员数量，但是每个确定的tuple类型的成员数目是固定的。从概念上讲，它们类似于C的结构体，但是不具有命名的数据成员，我们也可以把他当作一个通用的结构体来用，不需要创建结构体又获取结构体的特征，在某些情况下取代结构体使程序更简洁，直观。
[C++] std::tuple
weixin_55664293的博客
06-20 1万+
​ std::tuple是C++11新标准引入的一个类模板，又称为元组，是一个固定大小的异构值集合，由std::pair泛化而来。pair可以看作是tuple的一种特殊情况，成员数目限定为两个。tuple可以有任意个成员数量，但是每个确定的tuple类型的成员数目是固定的。​ 从概念上讲，它们类似于C的结构体，但是不具有命名的数据成员，我们也可以把他当做一个通用的结构体来用，不需要创建结构体又获取结构体的特征，在某些情况下可以取代结构体使程序更简洁，直观。​ tuple 的应用场景很广泛，例如当需要存储多个
std::tuple大总结
MrTsai_cpp的博客
04-17 1万+
C++11引入了一个新的较实用的模板类型，std::tuple，也即是元组。元组是一个固定大小的不同类型（异质，heterogeneous）值的集合，也即它可以同时存放不同类型的数据。 类似于python中用小括号表示的元组类型。C++已有的std::pair类型类似于一个二元组，可看作是std::tuple的一个特例，std::tuple也可看作是std::pair的泛化。
C++ tuple元组的基本用法(总结)
热门推荐
sevenjoin的博客
03-12 12万+
1，元组简介 tuple是一个固定大小的不同类型值的集合，是泛化的std::pair。我们也可以把他当做一个通用的结构体来用，不需要创建结构体又获取结构体的特征，在某些情况下可以取代结构体使程序更简洁，直观。std::tuple理论上可以有无数个任意类型的成员变量，而std::pair只能是2个成员，因此在需要保存3个及以上的数据时就需要使用tuple元组了。 tuple（元组...
std::tuple类型
人无远虑，必有近忧
02-16 1385
std::tuple是类似std::pair的模板。每个pair的成员类型都不相同，但每个pair都恰好有两个成员。不同std::tuple类型的成员类型也不相同，但一个std::tuple可以有任意数量的成员。每个确定的std::tuple类型的成员数目是固定的，但一个std::tuple类型的成员数目可以与另一个std::tuple类型不同。
C++11中std::tuple的使用
网络资源是无限的
06-01 6万+
C++11中std::tuple的使用
C++11新特性std::make_tuple的使用
12-16
std::tuple是C++ 11中引入的一个非常有用的结构，以前我们要返回一个包含不同数据类型的返回值，一般都需要自定义一个结构体或者通过函数的参数来返回，现在std::tuple就可以帮我们搞定。 1.引用头文件 #include ...
C++ STL 内 std::{bind/tuple/function} 简单实现
08-25
在C++标准库STL中，`std::bind`、`std::tuple`和`std::function`是三个非常重要的工具，它们各自有着独特的功能，同时也常常协同工作以完成复杂的功能。 1. `std::function`: 这是一个可以存储任何类型的可调用对象...
pfr：std :: tuple类似用户定义类型的方法，没有任何宏或样板代码
01-30
增强PFR 这是一个C ++ 14库，用于非常基本的反射，使您可以按索引访问结构元素，并为用户定义的类型提供其他std::tuple类的方法，而无需任何宏或样板代码。检测结果分行建立测试覆盖率更多信息开发： 主： 激励实例...
STL tuple源码分析
异次元的归来
01-14 904
STL还提供了两个便捷的函数创建tuple，一个是make_tuple，一个是tie，两者的区别在于返回的tuple类型有差异，一个返回参数类型为值类型的tuple（除非传入的参数是reference_wrapper)，一个返回的是引用类型的tuple。如果tuple的元素个数不止一个，那结果直接就是true，而只有一个元素时，需要进行一系列的判断，首先两个tuple的类型不能相同，然后，传入的tuple参数不能直接构造tuple的参数类型，也不能直接convert到tuple的参数类型。
C++之std::tuple(二) : 揭秘底层实现原理
红军不怕远征难，万水千山只等闲
02-25 2230
std::tuple存储的递归写法基于这样的思想：一个包含N(N>0)个元素的元组可以存储为一个元素（第1个元素，或者说是列表的头部）加上一个包含N-1个元素的元组(尾部)，而包含0个元素的元组是单独的特殊情况。
突破编程_C++_C++11新特性（tuple）
最新发布
突破编程
03-20 1412
C++11 新特性：tuple
C++11 tuple
ccf19881030的专栏
04-21 778
C++11 tuple(元组) tuple是C++11中引入的新类型，中文翻译就是元组。元组是一个能够容纳元素集合的对象。 每个元素可以具有不同的类型。类模板std :: tuple是固定大小的异构值集合。具体可以参考tuple-cppreference.com和tuple-cplusplus.com中的描述，并且提供了一些示例程序。 其中，tuple-cplusplus.com/中提供的示例程序...
【C++ STL之string，tuple，array详解】
iluuoip的博客
08-17 1166
在C++的STL（Standard Template Library）中，std::string是一个非常有用的字符串类。它提供了一系列操作字符串的功能，包括字符串的创建、修改、查找、拼接等。本文将详细介绍C++ STL中std::string的使用方法和一些常见操作。在C++的STL（Standard Template Library）中，std::tuple是一个非常有用的模板类。它提供了一种将多个值组合在一起的方式，类似于一个元组。
C++11 存储任意类型（std::tuple）
大袖技术
01-10 2085
一、std::tuple 我们知道，我平常使用的数组都是同一种类型的 比如 int arr[] = { 1,2,3,4 }; // arr 数组里面的元素类型都是 int 那有人就想了，下面不就是不同种类型吗 我们编译一下看看 可以看到，发生了隐式转换，最后调试结果 int arr[] = { 1, 2.6, 3, 4 }; std::cout << arr[1] << std::endl; 这时候我们想存放不同类型 就用到了std::t...
std::tuple
dianyun7150的博客
08-04 187
tuple，元组类型。头文件<tuple>，tuple是一个固定大小的不同类型（异质，heterogeneous）值的集合（这一点是tuple与其他常规STL容器的最大不同，即它可以同时存放不同类型的数据）。泛化的std::pair（也即std::pair是tuple的一个特例，长度受限为2）。当我们定义一个std::tuple时，需要指出每个成员的类型, std::tupl...
std::tuple遍历
windSnowLi
11-24 431
【代码】std::tuple遍历。
C++遍历std::tuple（C++14 ~ C++20）
J__M__C的博客
08-14 670
介绍C++遍历std::tuple的方法。
cpp11std::tuple 和 std::make_tuple
03-27
cpp11std::tuple 和 std::make_tuple 是 C++11 引入的两个新特性。 cpp11std::tuple 是一个用于存储多个值的容器，类似于 std::pair，但是可以存储多个值。cpp11std::tuple 在定义时需要指定每个元素的类型，并且可以通过 std::get 函数来获取每个元素的值。 std::make_tuple 是一个用于创建 cpp11std::tuple 对象的函数模板。它可以接受任意数量的参数，并将这些参数打包为一个 cpp11std::tuple 对象返回。 例如： ``` #include <tuple> #include <string> #include <iostream> int main() { cpp11std::tuple<int, std::string, double> t(42, "hello", 3.14); std::cout << std::get<0>(t) << " " << std::get<1>(t) << " " << std::get<2>(t) << std::endl; auto t2 = std::make_tuple(42, "world", 2.71); std::cout << std::get<0>(t2) << " " << std::get<1>(t2) << " " << std::get<2>(t2) << std::endl; } ``` 输出： ``` 42 hello 3.14 42 world 2.71 ``` 其中，第一个例子是直接定义 cpp11std::tuple 对象，第二个例子使用了 std::make_tuple 函数来创建 cpp11std::tuple 对象。
评论 20
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值