c++11 标准模板（STL）（std::tuple）（八）

最新推荐文章于 2024-08-25 23:11:21 发布
最新推荐文章于 2024-08-25 23:11:21 发布
阅读量968 收藏 24
点赞数 17
分类专栏： # std::tuple 文章标签： c++ 标准库模板 STL 元组 tuple
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/136430928
版权 
定义于头文件 <tuple>

template< class... Types >
class tuple;

(C++11 起)

类模板 std::tuple 是固定大小的异类值汇集。它是 std::pair 的推广。

若 (std::is_trivially_destructible_v<Types> && ...) 为 true ，则 tuple 的析构函数是平凡的。

(C++17 起)

模板形参

Types...-tuple 所存储的元素的类型。支持空列表。

按字典顺序比较 tuple 中的值

operator==,!=,<,<=,>,>=(std::tuple)
template< class... TTypes, class... UTypes >

bool operator==( const tuple<TTypes...>& lhs,

                 const tuple<UTypes...>& rhs );		(1)(C++11 起)
(C++14 前)
template< class... TTypes, class... UTypes >

constexpr bool operator==( const tuple<TTypes...>& lhs,

                           const tuple<UTypes...>& rhs );		(1)(C++14 起)
template< class... TTypes, class... UTypes >

bool operator!=( const tuple<TTypes...>& lhs,

                 const tuple<UTypes...>& rhs );		(2)(C++11 起)
(C++14 前)
template< class... TTypes, class... UTypes >

constexpr bool operator!=( const tuple<TTypes...>& lhs,

                           const tuple<UTypes...>& rhs );		(2)(C++14 起)
template< class... TTypes, class... UTypes >

bool operator<( const tuple<TTypes...>& lhs,

                const tuple<UTypes...>& rhs );		(3)(C++11 起)
(C++14 前)
template< class... TTypes, class... UTypes >

constexpr bool operator<( const tuple<TTypes...>& lhs,

                          const tuple<UTypes...>& rhs );		(3)(C++14 起)
template< class... TTypes, class... UTypes >

bool operator<=( const tuple<TTypes...>& lhs,

                 const tuple<UTypes...>& rhs );		(4)(C++11 起)
(C++14 前)
template< class... TTypes, class... UTypes >

constexpr bool operator<=( const tuple<TTypes...>& lhs,

                           const tuple<UTypes...>& rhs );		(4)(C++14 起)
template< class... TTypes, class... UTypes >

bool operator>( const tuple<TTypes...>& lhs,

                const tuple<UTypes...>& rhs );		(5)(C++11 起)
(C++14 前)
template< class... TTypes, class... UTypes >

constexpr bool operator>( const tuple<TTypes...>& lhs,

                          const tuple<UTypes...>& rhs );		(5)(C++14 起)
template< class... TTypes, class... UTypes >

bool operator>=( const tuple<TTypes...>& lhs,

                 const tuple<UTypes...>& rhs );		(6)(C++11 起)
(C++14 前)
template< class... TTypes, class... UTypes >

constexpr bool operator>=( const tuple<TTypes...>& lhs,

                           const tuple<UTypes...>& rhs );		(6)(C++14 起)

1-2) 比较 tuple lhs 的每个元素和 tuple rhs 的对应元素。

3-6) 以字典序比较 lhs 与 rhs ，即比较首元素，若相等则比较第二元素，若均相等则比较第三元素，以此类推。

所有比较运算符是短路的；它们在确定结果所必须的比较之外不访问 tuple 元素。

参数

lhs, rhs-要比较的 tuple

返回值

1) 若对于所有 [0, sizeof...(Types)) 中的 i 有 std::get<i>(lhs) == std::get<i>(rhs) 则为 true ，否则为 false 。对二个空 tuple 返回 true 。

2) !(lhs == rhs)

3) (bool)(std::get<0>(lhs) < std::get<0>(rhs)) || (!(bool)(std::get<0>(rhs) < std::get<0>(lhs)) && lhstail < rhstail) ，其中 lhstail 是无首元素的 lhs ，而 rhstail 是无首元素的 rhs 。对于二个空 tuple ，返回 false 。

4) !(rhs < lhs)

5) rhs < lhs

6) !(lhs < rhs)

调用示例

#include <tuple>
#include <iostream>
#include <string>
#include <typeinfo>
#include <stdexcept>
#include <iostream>
#include <iterator>
#include <vector>
#include <memory>
#include <set>
#include <map>

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}
    Cell(const Cell &cell)
    {
        x = cell.x;
        y = cell.y;
    }

    //std::tie 能用于引入字典序比较到结构体，或解包 tuple ：
    bool operator ==(const Cell &cell) const
    {
        return std::tie(x, y) == std::tie(cell.x, cell.y);
    }

    bool operator !=(const Cell &cell) const
    {
        return std::tie(x, y) != std::tie(cell.x, cell.y);
    }

    bool operator <(const Cell &cell) const
    {
        return std::tie(x, y) < std::tie(cell.x, cell.y);
    }

    bool operator <=(const Cell &cell) const
    {
        return std::tie(x, y) <= std::tie(cell.x, cell.y);
    }

    bool operator >(const Cell &cell) const
    {
        return std::tie(x, y) > std::tie(cell.x, cell.y);
    }

    bool operator >=(const Cell &cell) const
    {
        return std::tie(x, y) >= std::tie(cell.x, cell.y);
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

// 打印任何大小 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 << ")" << std::endl;
}
// 辅助函数结束

int main()
{
    //1-4) 从 tuple 提取第 I 个元素。 I 是 [0, sizeof...(Types)) 中的整数值。
    std::tuple<Cell, std::string, float> tuple1(Cell{101, 101}, "Test", 3.14);
    std::cout << "tuple1 " << typeid(tuple1).name() << ":   " << std::endl;
    print(tuple1);

    std::tuple<Cell, std::string, float> tuple3 = tuple1;

    std::tuple<Cell, std::string, float> tuple2 = std::make_tuple(Cell{102, 102}, "GGX", 3.14159);
    std::cout << "tuple2 " << typeid(tuple2).name() << ":   " << std::endl;
    print(tuple2);
    std::cout << std::endl;

    std::cout << std::boolalpha;

    std::cout << std::get<0>(tuple1) << " == " << std::get<0>(tuple2) << "      "
              << (std::get<0>(tuple1) == std::get<0>(tuple2)) << std::endl;
    std::cout << std::get<1>(tuple1) << " == " << std::get<1>(tuple2) << "      "
              << (std::get<1>(tuple1) == std::get<1>(tuple2)) << std::endl;
    std::cout << std::get<2>(tuple1) << " == " << std::get<02>(tuple2) << "      "
              << (std::get<2>(tuple1) == std::get<2>(tuple2)) << std::endl;

    std::cout << std::get<0>(tuple1) << " == " << std::get<0>(tuple3) << "      "
              << (std::get<0>(tuple1) == std::get<0>(tuple3)) << std::endl;
    std::cout << std::get<1>(tuple1) << " == " << std::get<1>(tuple3) << "      "
              << (std::get<1>(tuple1) == std::get<1>(tuple3)) << std::endl;
    std::cout << std::get<2>(tuple1) << " == " << std::get<02>(tuple3) << "      "
              << (std::get<2>(tuple1) == std::get<2>(tuple3)) << std::endl;
    std::cout << std::endl;

    std::cout << std::get<0>(tuple1) << " != " << std::get<0>(tuple2) << "      "
              << (std::get<0>(tuple1) != std::get<0>(tuple2)) << std::endl;
    std::cout << std::get<1>(tuple1) << " != " << std::get<1>(tuple2) << "      "
              << (std::get<1>(tuple1) != std::get<1>(tuple2)) << std::endl;
    std::cout << std::get<2>(tuple1) << " != " << std::get<02>(tuple2) << "      "
              << (std::get<2>(tuple1) != std::get<2>(tuple2)) << std::endl;

    std::cout << std::get<0>(tuple1) << " != " << std::get<0>(tuple3) << "      "
              << (std::get<0>(tuple1) != std::get<0>(tuple3)) << std::endl;
    std::cout << std::get<1>(tuple1) << " != " << std::get<1>(tuple3) << "      "
              << (std::get<1>(tuple1) != std::get<1>(tuple3)) << std::endl;
    std::cout << std::get<2>(tuple1) << " != " << std::get<02>(tuple3) << "      "
              << (std::get<2>(tuple1) != std::get<2>(tuple3)) << std::endl;
    std::cout << std::endl;

    std::cout << std::get<0>(tuple1) << " <  " << std::get<0>(tuple2) << "      "
              << (std::get<0>(tuple1) < std::get<0>(tuple2)) << std::endl;
    std::cout << std::get<1>(tuple1) << " <  " << std::get<1>(tuple2) << "      "
              << (std::get<1>(tuple1) < std::get<1>(tuple2)) << std::endl;
    std::cout << std::get<2>(tuple1) << " <  " << std::get<02>(tuple2) << "      "
              << (std::get<2>(tuple1) < std::get<2>(tuple2)) << std::endl;

    std::cout << std::get<0>(tuple1) << " <  " << std::get<0>(tuple3) << "      "
              << (std::get<0>(tuple1) < std::get<0>(tuple3)) << std::endl;
    std::cout << std::get<1>(tuple1) << " <  " << std::get<1>(tuple3) << "      "
              << (std::get<1>(tuple1) < std::get<1>(tuple3)) << std::endl;
    std::cout << std::get<2>(tuple1) << " <  " << std::get<02>(tuple3) << "      "
              << (std::get<2>(tuple1) < std::get<2>(tuple3)) << std::endl;
    std::cout << std::endl;

    std::cout << std::get<0>(tuple1) << " <= " << std::get<0>(tuple2) << "      "
              << (std::get<0>(tuple1) <= std::get<0>(tuple2)) << std::endl;
    std::cout << std::get<1>(tuple1) << " <= " << std::get<1>(tuple2) << "      "
              << (std::get<1>(tuple1) <= std::get<1>(tuple2)) << std::endl;
    std::cout << std::get<2>(tuple1) << " <= " << std::get<02>(tuple2) << "      "
              << (std::get<2>(tuple1) <= std::get<2>(tuple2)) << std::endl;

    std::cout << std::get<0>(tuple1) << " <= " << std::get<0>(tuple3) << "      "
              << (std::get<0>(tuple1) <= std::get<0>(tuple3)) << std::endl;
    std::cout << std::get<1>(tuple1) << " <= " << std::get<1>(tuple3) << "      "
              << (std::get<1>(tuple1) <= std::get<1>(tuple3)) << std::endl;
    std::cout << std::get<2>(tuple1) << " <= " << std::get<02>(tuple3) << "      "
              << (std::get<2>(tuple1) <= std::get<2>(tuple3)) << std::endl;
    std::cout << std::endl;

    std::cout << std::get<0>(tuple1) << " >  " << std::get<0>(tuple2) << "      "
              << (std::get<0>(tuple1) > std::get<0>(tuple2)) << std::endl;
    std::cout << std::get<1>(tuple1) << " >  " << std::get<1>(tuple2) << "      "
              << (std::get<1>(tuple1) > std::get<1>(tuple2)) << std::endl;
    std::cout << std::get<2>(tuple1) << " >  " << std::get<02>(tuple2) << "      "
              << (std::get<2>(tuple1) > std::get<2>(tuple2)) << std::endl;

    std::cout << std::get<0>(tuple1) << " >  " << std::get<0>(tuple3) << "      "
              << (std::get<0>(tuple1) > std::get<0>(tuple3)) << std::endl;
    std::cout << std::get<1>(tuple1) << " >  " << std::get<1>(tuple3) << "      "
              << (std::get<1>(tuple1) > std::get<1>(tuple3)) << std::endl;
    std::cout << std::get<2>(tuple1) << " >  " << std::get<02>(tuple3) << "      "
              << (std::get<2>(tuple1) > std::get<2>(tuple3)) << std::endl;
    std::cout << std::endl;

    std::cout << std::get<0>(tuple1) << " >= " << std::get<0>(tuple2) << "      "
              << (std::get<0>(tuple1) >= std::get<0>(tuple2)) << std::endl;
    std::cout << std::get<1>(tuple1) << " >= " << std::get<1>(tuple2) << "      "
              << (std::get<1>(tuple1) >= std::get<1>(tuple2)) << std::endl;
    std::cout << std::get<2>(tuple1) << " >= " << std::get<02>(tuple2) << "      "
              << (std::get<2>(tuple1) >= std::get<2>(tuple2)) << std::endl;

    std::cout << std::get<0>(tuple1) << " >= " << std::get<0>(tuple3) << "      "
              << (std::get<0>(tuple1) >= std::get<0>(tuple3)) << std::endl;
    std::cout << std::get<1>(tuple1) << " >= " << std::get<1>(tuple3) << "      "
              << (std::get<1>(tuple1) >= std::get<1>(tuple3)) << std::endl;
    std::cout << std::get<2>(tuple1) << " >= " << std::get<02>(tuple3) << "      "
              << (std::get<2>(tuple1) >= std::get<2>(tuple3)) << std::endl;
    std::cout << std::endl;

    return 0;
}

输出

tuple1 St5tupleIJ4CellNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEfEE:
({101,101}, Test, 3.14)
tuple2 St5tupleIJ4CellNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEfEE:
({102,102}, GGX, 3.14159)

{101,101} == {102,102}      false
Test == GGX      false
3.14 == 3.14159      false
{101,101} == {101,101}      true
Test == Test      true
3.14 == 3.14      true

{101,101} != {102,102}      true
Test != GGX      true
3.14 != 3.14159      true
{101,101} != {101,101}      false
Test != Test      false
3.14 != 3.14      false

{101,101} <  {102,102}      true
Test <  GGX      false
3.14 <  3.14159      true
{101,101} <  {101,101}      false
Test <  Test      false
3.14 <  3.14      false

{101,101} <= {102,102}      true
Test <= GGX      false
3.14 <= 3.14159      true
{101,101} <= {101,101}      true
Test <= Test      true
3.14 <= 3.14      true

{101,101} >  {102,102}      false
Test >  GGX      true
3.14 >  3.14159      false
{101,101} >  {101,101}      false
Test >  Test      false
3.14 >  3.14      false

{101,101} >= {102,102}      false
Test >= GGX      true
3.14 >= 3.14159      false
{101,101} >= {101,101}      true
Test >= Test      true
3.14 >= 3.14      true

繁星璀璨G
关注
  • 17
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11:std::tuple
weixin_42226134的博客
03-11 354
stl 的 map 容器很多读者应该都很熟悉，map 容器提供了一个 insert 方法，我们用该方法向 map 中插入元素，但是应该很少有人记得 insert 方法的返回值是什么类型，让我们来看一下 C++98/03 提供的 insert 方法的签名： std::pair<iterator,bool> insert( const value_type& value ); ...
C++之std::tuple(一) : 使用精讲(全)
红军不怕远征难，万水千山只等闲
02-03 6556
C++11之后引入了std::tuple，俗称元组，元组(tuple)是一种用于组合多个不同类型的值的数据结构。元组可以将不同类型的数据打包在一起，类似于一个容器，可以按照索引顺序访问其中的元素。元组的大小在编译时确定，不支持动态添加或移除元素。std::tuple类似互C语言的结构体，不需要创建结构体而又有结构体的特征，在某些情况下可以取代结构体而使得程序更加简洁，直观。std::tuple理论上可以定义无数多个不同类型的成员变量。
std::map＜KeyFrame *, std::tuple＜int, int＞＞ mObservations； mObservations如何打印？
草莓奶忻的博客
03-26 214
这个代码定义了一个KeyFrame结构体，它有一个名为id的成员变量。mObservations是一个std::map，它将KeyFrame指针映射到一个包含两个整数的std::tuple。printObservations函数遍历mObservations，并为每个键值对打印KeyFrame的id和观测值。如果你有一个std::map，其键是指向KeyFrame对象的指针，而值是一个std::tuple包含两个整数（假设这代表了某种观测的数据），你可以通过遍历这个std::map来打印出所有键值对。
std::is_trivially_destructible
zgcjaxj的博客
03-27 2698
std::is_trivially_destructible来判断 一个 内置类型或structure/class/union类型 是否为 “容易销毁的(trivially destructible)”，从字面意思也可以看出，主要是check这个类型的 析构函数。官网给出如下解释： A trivially destructible class is a class (defined with class, struct or union) that: uses the implicitly define
C++11——可变参数模板
Skynet的博客
02-18 1706
在C++11之前，类模板和函数模板只能包含固定数量的模板参数。 在C++11之中，类模板和函数 模板允许模板定义中包含0到任意个模板参数。 声明可变参数模板时需要在typename或class后面带上省略号"...",省略号的作用： 1、声明一个参数包，包含0到任意个参数 2、在模板定义的右边，可以将参数包展开成一个个独立的参数 可变参数模板函数 可变参数模板函数的定义如下： template<class... T> void f(T... args) { cout.
template<class T>
qingyangliuyang的专栏
12-03 2126
模板 使用中注意的问题 templateT>   (2011-10-03 17:38:57) T>" title="templateT>" style="margin:0px; padding:0px; border:0px; list-style:none; position:absolute; left:11px; top:4px">转载▼ 标签：   模板
c++11 标准模板（STL）（std::tuple）（一）
qq_40788199的博客
03-01 446
类模板 std::tuple 是固定大小的异类值汇集。它是 std::pair 的推广。
C++ STL 内 std::{bind/tuple/function} 简单实现
12-20
在C++标准库STL中，`std::bind`、`std::tuple`和`std::function`是非常重要的工具，它们提供了高级的函数操作和参数管理能力。下面将详细解释这三个概念及其简单实现的关键点。 首先，我们来看`std::function`。`...
C++17 STL标准库学习教材电子.pdf
04-12
C++17 STL标准库的学习教材主要关注C++17引入的新特性，这些特性极大地提升了C++语言的可读性、可维护性和表达性。在本章中，我们将重点讨论结构化绑定这一新特性，它是C++17的一个重要亮点。 结构化绑定允许程序员...
c++标准库STL手册
12-17
C++标准模板库（STL）是C++编程语言中的一个重要组成部分，它提供了一组高效、可重用的容器、迭代器、算法和函数对象，大大简化了数据结构和算法的实现。STL手册通常会详细阐述这些组件的使用方法，提供实例代码，...
C++17 STL标准库学习教材电子.docx
12-30
C++17 STL标准库学习教材 C++17是C++标准的一个重要版本，对于C++标准库（STL）来说，也引入了许多新的特性。这些特性可以帮助开发者编写出可读性高、可维护性强和表达性清晰的代码。本文将从C++17的新特性开始，...
C++ 模板中的template typename 和template class的区别
李牙刷儿的专栏
07-10 1933
本片we
C++11——std::tuple
Map的博客
03-19 862
std::tuple是一个固定大小的不同类型值的集合，是泛化的std::pair。和c#中的tuple类似，但是比c#中的tuple强大得多。我们也可以把他当做一个通用的结构体来用，不需要创建结构体又获取结构体的特征，在某些情况下可以取代结构体使程序更简洁，直观。 样例： // std::tuple class CTuple { public: CTuple() {} ~CTuple(...
C语言：文件（写入，读取）
2301_80311224的博客
08-21 702
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
【C++】链表
qq_38801607的博客
08-22 555
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
lly202406的博客
08-25 369
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
【C语言篇】
最新发布
2301_81072404的博客
08-25 87
条件编译（#ifdef、#ifndef、#else、#elif、#endif）指针与动态内存分配（malloc、calloc、realloc、free）文件的读写操作（fread、fwrite、fprintf、fscanf等）控制语句（if、for、while、do-while、switch等）字符串处理函数（strlen、strcpy、strcat等）运算符（算术运算符、关系运算符、逻辑运算符等）文件的打开与关闭（fopen、fclose）数据类型（整型、浮点型、字符型等）函数参数传递（传值、传址）
C++ 基础
weixin_51883798的博客
08-22 268
MyClass&& other:这是一个右值引用参数，指向要移动的对象。右值引用允许我们访问即将被销毁的对象，从中“窃取”资源。该关键字表示移动构造函数不会抛出异常。这是一个优化提示，告诉编译器在需要时可以安全地使用移动构造函数。这是C++11标准中新引入的一个特性，旨在提高性能，尤其是在涉及临时对象和资源管理时。特殊的成员函数，允许将一个对象的状态转移到另一个新创建的对象中，不需要进行复制。
C++20中的简写函数模板(abbreviated function template)
网络资源是无限的
08-25 212
C++20中的简写函数模板(abbreviated function template)
std::make_tuple();
06-08
这是一个 C++ STL（标准模板库）中的函数，用于创建一个 tuple（元组）类型的对象。make_tuple()函数接受任意数量的参数，并用这些参数初始化一个 tuple 对象，返回一个 tuple 对象。例如，以下代码创建了一个包含三个元素的 tuple 对象： ```c++ #include <tuple> #include <iostream> int main() { auto my_tuple = std::make_tuple(1, "hello", 3.14); std::cout << std::get<0>(my_tuple) << " " << std::get<1>(my_tuple) << " " << std::get<2>(my_tuple) << std::endl; return 0; } ``` 输出结果为： ``` 1 hello 3.14 ``` 其中，std::get<>()函数用于访问 tuple 中的元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值