C++11 tuple元组

C++11 tuple 元组

tuple容器(元组), 是表示元组容器, 是不包含任何结构的,快速而低质(粗制滥造, quick and dirty)的, 可以用于函数返回多个返回值;

tuple容器, 可以使用直接初始化, 和"make_tuple()"初始化, 访问元素使用"get<>()"方法, 注意get里面的位置信息, 必须是常量表达式(const expression);

可以通过"std::tuple_size<decltype(t)>::value"获取元素数量; "std::tuple_element<0, decltype(t)>::type"获取元素类型;

如果tuple类型进行比较, 则需要保持元素数量相同, 类型可以比较, 如相同类型, 或可以相互转换类型(int&double);

无法通过普通的方法遍历tuple容器, 因为"get<>()"方法, 无法使用变量获取值;

以下代码包含一些基本的用法, 详见注释;

示例代码:

/*eclipse cdt, gcc 4.8.1*/  

#include <iostream>
#include <vector>
#include <string>
#include <tuple>  

using namespace std;  

std::tuple<std::string, int>
giveName(void)
{
    std::string cw("Caroline");
    int a(2013);
    std::tuple<std::string, int> t = std::make_tuple(cw, a);
    return t;
}  

int main()
{
    std::tuple<int, double, std::string> t(64, 128.0, "Caroline");
    std::tuple<std::string, std::string, int> t2 =
            std::make_tuple("Caroline", "Wendy", 1992);  

    //返回元素个数
    size_t num = std::tuple_size<decltype(t)>::value;
    std::cout << "num = " << num << std::endl;  

    //获取第1个值的元素类型
    std::tuple_element<1, decltype(t)>::type cnt = std::get<1>(t);
    std::cout << "cnt = " << cnt << std::endl;  

    //比较
    std::tuple<int, int> ti(24, 48);
    std::tuple<double, double> td(28.0, 56.0);
    bool b = (ti < td);
    std::cout << "b = " << b << std::endl;  

    //tuple作为返回值
    auto a = giveName();
    std::cout << "name: " << get<0>(a)
            << " years: " << get<1>(a) << std::endl;  

    return 0;
}  

输出结果:

num = 3
cnt = 128
b = 1
name: Caroline years: 2013  

C++ pair 点对

1 pair的应用

pair是将2个数据组合成一个数据,当需要这样的需求时就可以使用pair,如stl中的map就是将key和value放在一起来保存。另一个应用是,当一个函数需要返回2个数据的时候,可以选择pair。 pair的实现是一个结构体,主要的两个成员变量是first second 因为是使用struct不是class,所以可以直接使用pair的成员变量。

2 make_pair函数

template pair make_pair(T1 a, T2 b) { return pair(a, b); }

很明显,我们可以使用pair的构造函数也可以使用make_pair来生成我们需要的pair。 一般make_pair都使用在需要pair做参数的位置,可以直接调用make_pair生成pair对象很方便,代码也很清晰。 另一个使用的方面就是pair可以接受隐式的类型转换,这样可以获得更高的灵活度。灵活度也带来了一些问题如:

std::pair<int, float>(1, 1.1);

std::make_pair(1, 1.1);

是不同的,第一个就是float,而第2个会自己匹配成double。

类模板:template <class T1, class T2> struct pair

参数:T1是第一个值的数据类型,T2是第二个值的数据类型。

功能:pair将一对值组合成一个值,这一对值可以具有不同的数据类型(T1和T2),两个值可以分别用pair的两个公有函数first和second访问。

具体用法:

1.定义(构造):

1     pair<int, double> p1;  //使用默认构造函数
2     pair<int, double> p2(1, 2.4);  //用给定值初始化
3     pair<int, double> p3(p2);  //拷贝构造函数

2.访问两个元素(通过first和second):

1     pair<int, double> p1;  //使用默认构造函数
2     p1.first = 1;
3     p1.second = 2.5;
4     cout << p1.first << ‘ ‘ << p1.second << endl;

输出结果:1 2.5

3.赋值operator = :

(1)利用make_pair:

1     pair<int, double> p1;
2     p1 = make_pair(1, 1.2);

(2)变量间赋值:

    pair<int, double> p1(1, 1.2);
    pair<int, double> p2 = p1;

Pair类型概述

pair是一种模板类型,其中包含两个数据值,两个数据的类型可以不同,基本的定义如下:

pair<int, string> a;

表示a中有两个类型,第一个元素是int型的,第二个元素是string类型的,如果创建pair的时候没有对其进行初始化,则调用默认构造函数对其初始化。

pair<string, string> a("James", "Joy");

也可以像上面一样在定义的时候直接对其初始化。

由于pair类型的使用比较繁琐,因为如果要定义多个形同的pair类型的时候,可以时候typedef简化声明:

typedef pair<string, string> author;

author pro("May", "Lily");

author joye("James", "Joyce");

Pair对象的操作

  • 对于pair类,由于它只有两个元素,分别名为first和second,因此直接使用普通的点操作符即可访问其成员

pair<string, string> a("Lily", "Poly");

string name;

name = pair.second;

  • 生成新的pair对象

可以使用make_pair对已存在的两个数据构造一个新的pair类型:

int a = 8;

string m = "James";

pair<int, string> newone;

newone = make_pair(a, m);

原文地址:https://www.cnblogs.com/lsgxeva/p/8250879.html

时间: 2024-11-04 02:53:14

C++11 tuple元组的相关文章

c++11——tuple元组

tuple是一个固定大小的不同类型值的集合,是泛化的 std::pair.可以当做一通用的结构体使用,不需要创建结构体而又获取结构体的特征,在某些情况下可以取代结构体,使程序简洁.直观. 创建tuple 1. make_tupe tuple<const char*, int> tp = make_tuple(sendPack, nSendSize);//构造tuple 2. tie 函数(创建一个元组的左值引用) auto tp = std::tie(1, "aa", 2.

tuple元组(C++11及以后,如C++14)

类tuple与array最本质的区别当数tuple元组元素类型可以不一样,而统一数组array的元素类型必须一样. 本文主要举例: tuple_size Example 123456789101112131415161718192021222324252627 // tuple example #include <iostream> // std::cout #include <tuple> // std::tuple, std::get, std::tie, std::ignor

Python之路【第二篇】:Python基础(2)-Tuple元组

#!/usr/bin/env python3# -*- coding: utf-8 -*-#Author:Jam #0.元组'''元组和列表类似,不同之处在于元组的元素不能修改元组使用小括号,列表使用方括号元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可''' #实例:tup1 = ('Google','Runoob',1997,2000)tup2 = (1,2,3,4,5)tup3 = 'a','b','c','d' #创建空元组tup1 = () #元组中只包含一个元素时,需要在元

.NET 4新特性--Tuple元组

.NET 4定义了8个Tuple类,和一个静态Tuple类 ---------------------------------------------------------------------返回多个值 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApplication2

python里list列表,tuple元组内部功能介绍

list列表 append            #在列表尾部追加元素 clear                #把列表清空 count               #统计元素出现的次数 extend             #合并两个列表或者元组与列表合并,对原来列表的扩展 index                #获取元素的下标,索引 insert                #插入元素,可以自己指定插入位置 pop                   #删除某个元素,默认删除最后一个

C++11 tuple

tuple元组定义了一个有固定数目元素的容器,其中的每个元素类型都可以不相同,这与其他容器有着本质的区别.是对pair的泛化. 首先来介绍元组的创建和元组元素的访问.通过make_tuple()创建元组,通过get<>()来访问元组的元素.通过下面这段程序来认识这两个函数的用法: #include <iostream> #include <tuple> #include <functional> int main() { auto t1 = std::mak

tuple元组创建单元素

创建tuple单元素,一定要在结尾时添加一个逗号(,)解:如果不加逗号,哪怕是使用tuple()正确的创建元组,也会有歧义,它会把创建tuple元组的单元素,当成一个普通的输出语句结果列:如下,错误的方式,得到的结果不是tuple()元组类型 tup = ('a')print(tup) 正确的创建tuple单元素的方式 tup = ('a',)print(tup) 原文地址:https://www.cnblogs.com/mumu555/p/10929277.html

C#关键字扫盲——Tuple(元组类) 、ValueTuple(值元组)

原文:C#关键字扫盲--Tuple(元组类) .ValueTuple(值元组) 版权声明:本文为博主原创文章,随意转载. https://blog.csdn.net/Michel4Liu/article/details/79750877 Tuple.ValueTuple 当方法返回值大于一个时我们有时用out或结构体或类来处理,今天介绍一个简便的多返回值方式. ValueTuple 是 Tuple的扩展,本文只针对最新的ValueTuple 做讲解,Tuple有很多不便之处,总之过时的就让他过去

Python之tuple元组详解

元组:有序,一级元素不可以修改.不能被增加或删除(元组是可迭代对象) 一般写法括号内最后面加个英文逗号用来区分: test  =  (,) test1 = (11,22,) 例: test = (123, 456, 789, 'abc',) 1.通过索引取值 v = test[2] #取出 789 print(v) 2.切片取值 v1, v2 = test[1:3] #取出456和789 pritn(v1, v2) 3.可以for循环,是可迭代对象 for item in test: print