窥视C++细节-使用tie函数解包pair对象的原理

文章目录

示例
std::tie函数
std::ignore
std::pair和std::tuple互转
解包pair返回值

示例

这是http://www.cplusplus.com/reference/tuple/tie/?kw=tie中的一个std::tie()函数的示例。

#include <iostream>     // std::cout
#include <tuple>        // std::tuple, std::make_tuple, std::tieint main ()
{int myint;char mychar;std::tuple<int,float,char> mytuple;mytuple = std::make_tuple (10, 2.6, 'a');          // packing values into tuplestd::tie (myint, std::ignore, mychar) = mytuple;   // unpacking tuple into variablesstd::cout << "myint contains: " << myint << '\n';std::cout << "mychar contains: " << mychar << '\n';return 0;
}

myint contains: 10
mychar contains: a

std::tie函数

std::tie函数可以用于建立一个由reference构成的tuple，也可以用于tuple的解包。

可能的实现：

template <typename... Args>
auto tie(Args&... args) {return std::tuple<Args&...>(args...);
}

std::tie函数，将创建一个由reference构成的匿名tuple对象，并将其返回。

这里比较有意思的是，std::tie创建的匿名tuple对象，其内部通过引用和传入的参数想关联，随意一方的改动，对方可以感知，是同步的。

我们使用一个简单的示例模式一下，代码如下：

class A
{public:A(int& i):ri(i){}void set(int x){ri = x;}private:int & ri;
};int main()
{int i = 10;A a(i);a.set(20);cout<<"i = "<<i<<endl;return 0;
}

i = 20

通过传递变量的引用，使得在多处可以对同一个变量进行修改。

  std::tuple<int,float,char> mytuple;mytuple = std::make_tuple (10, 2.6, 'a');

先是使用默认构造器，创建mytuple对象。

使用make_tuple可以快速的创建tuple对象，同时make_tuple是一个模板参数，省去了指定参数的类型。

mytuple = std::make_tuple<int,float,char>(10,2.6,'a');

这样也是可以的

make_tuple将返回的tuple对象，赋值给mytuple，将发生一次赋值运算符重载。此后mytuple就保存了10，2.6，'a’这三个数据。

std::tie (myint, std::ignore, mychar) = mytuple;

tie将返回一个临时的匿名的tuple对象，这个tuple对象和myint、mychar变量通过引用进行关联，如果对这个临时匿名的tuple的修改，myint、mychar都可以感知。

mytuple将赋值给匿名的临时tuple对象，也就是mytuple中的值分别赋给了myint、std::ignore、mychar。

本行执行完毕，std::tie函数返回的临时对象就被销毁了。同时myint变为了10，mychar变为了’a’。

std::ignore

可能的实现

namespace detail {struct ignore_t {template <typename T>const ignore_t& operator=(const T&) const { return *this; }
};
}
const detail::ignore_t ignore;

std::ignores是detail::ignore_t类型的一个const类型的实例对象。detail::ignore_t类内部提供了模板类型operator=，任意类的对象都可以给它赋值，但它的赋值什么也不做，只是单纯的返回自己，所以所有给它的值相当于全部被忽略了。这里之所以返回*this是为了实现连等式。

std::tie (myint, std::ignore, mychar) = mytuple;

在执行tuple赋值运算符重载的时候，mytuple将第二个值赋值给了std::ignore对象，这导致上面函数的调用，但是由于这个函数什么不做，所以mytuple中的第二个值就被忽略了。

class A
{public:
};class B
{public:
};int main ()
{A a;B b;int i = 100;float f = 3.14;std::ignore = i;std::ignore = f;std::ignore = a;std::ignore = b;return 0;
}

任意类型的对象都可以赋值给ignore，但什么反应也不会有。

std::pair和std::tuple互转

可以使用一个pair作为初值，初始化一个双元素tuple，也可以将一个pair赋值给一个双元素tuple。

pair<int,string> studentPair(1001,"Bob");
tuple<int,string> studentTuple;studentTuple = studentPair;cout<<"id   = "<<get<0>(studentTuple)<<endl;
cout<<"name = "<<get<1>(studentTuple)<<endl;

id   = 1001
name = Bob

解包pair返回值

#include <iostream>
#include <tuple>
#include <set>int main ()
{set<int> si;bool inserted;std::tie(std::ignore,inserted) = si.insert(10);if(inserted){cout<<"Value was inserted successfully"<<endl;}//set中已经有了10，再次插入10，将失败。std::tie(std::ignore,inserted) = si.insert(10);if(!inserted){cout<<"Value was inserted failed"<<endl;}return 0;
}

Value was inserted successfully
Value was inserted failed

set成员函数insert的返回值是一个pair。pair.first返回插入位置的迭代器，pair.second表示是否插入成功。

现在通过std::tie函数只解包出是否插入成功。