std ::引用对
有一个std::pair引用std::pair是否有效？ 特别是，分配操作员有问题吗？ 根据这个链接 ，运营商似乎没有特别的处理，所以默认的分配运营商将无法生成。
我想要有一pair<T&, U&>并且能够为它分配另一对（值或引用）并修改指向的对象。
不，您不能在C ++ 03中可靠地做到这一点，因为pair的构造函数需要引用T ，并且创build对引用的引用在C ++ 03中是不合法的 。
请注意，我说“可靠”。 一些仍在使用的常用编译器（对于GCC，我testing了GCC4.1， @Charles报告了GCC4.4.4）不允许形成对引用的引用，但是最近确实允许它在实现引用塌陷时允许它（ T& T如果T是一个参考types）。 如果你的代码使用这样的东西，你不能依靠它来处理其他的编译器，直到你试试看。
这听起来像你想使用boost::tuple<>
int a, b; // on the fly boost::tie(a, b) = std::make_pair(1, 2); // as variable boost::tuple<int&, int&> t = boost::tie(a, b); t.get<0>() = 1; t.get<1>() = 2;
在C ++ 11中，您可以使用std::pair< std::reference_wrapper <T>, std::reference_wrapper<U>>并且该types的对象将按照您的需要运行。
我认为这是合法的，有一个std::pair房屋参考。 std::map使用consttypes的std::pair ，毕竟它不能被分配给任何一个。
我想要有
pair<T&, U&>并且能够分配给另一对
由于您无法重置参考，因此分配不起作用。 但是，您可以复制初始化这些对象。
你是对的。 您可以创build一对引用，但是不能再使用operator = 。
我想和你一样思考。 我写了下面的课程来抓这个特殊的痒：
template <class T1, class T2> struct refpair{ T1& first; T2& second; refpair(T1& x, T2& y) : first(x), second(y) {} template <class U, class V> refpair<T1,T2>& operator=(const std::pair<U,V> &p){ first=p.first; second=p.second; return *this; } };
它可以让你做一些可怕的事情：
int main (){ int k,v; refpair<int,int> p(k,v); std::map<int,int>m; m[20]=100; m[40]=1000; m[60]=3; BOOST_FOREACH(p,m){ std::cout << "k, v = " << k << ", " << v << std::endl; } return 0; }
（请记住相关的包括）。
nastiness当然是我指定给k和v的引用隐藏在p 。 如果你做这样的事情，它几乎变得很漂亮了：
template <class T1,class T2> refpair<T1,T2> make_refpair (T1& x, T2& y){ return ( refpair<T1,T2>(x,y) ); }
这可以让你像这样循环：
BOOST_FOREACH(make_refpair(k,v),m){ std::cout << "k, v = " << k << ", " << v << std::endl; }
（所有评论欢迎，因为我不是一个C ++专家。）
我不知道在C ++ 03中std::pair是什么“错误”，但是如果我天真地重新实现它，我没有任何问题（使用相同的编译器gcc和clang ）。
double a = 1.; double b = 2.; my::pair<double, double> p1(5., 6.); my::pair<double&, double&> p2(a, b); p2 = p1; // a == 5.
所以一个解决方法可以是（1）重新实现pair （在不同的命名空间中），或者（2）专用于std::pair<T&, T&> ，或者（3）简单地使用C ++ 11（其中std::pair为裁判工作的开箱即用）
（1）这里是一个天真的实现
namespace my{ template<class T1, class T2> struct pair{ typedef T1 first_type; typedef T2 second_type; T1 first; T2 second; pair(T1 const& t1, T2 const& t2) : first(t1), second(t2){} template<class U1, class U2> pair(pair<U1, U2> const& p) : first(p.first), second(p.second){} template<class U1, class U2> pair& operator=(const pair<U1, U2>& p){ first = p.first; second = p.second; return *this; } }; template<class T1, class T2> pair<T1, T2> make_pair(T1 t1, T2 t2){ return pair<T1, T2>(t1, t2); } }
（2）在这里它是std::pair一个特殊化（有些人可能会抱怨说我在std命名空间中重载/专门化，但是我认为如果是扩展这个类的function就没关系）
namespace std{ template<class T1, class T2> struct pair<T1&, T2&>{ typedef T1& first_type; /// @c first_type is the first bound type typedef T2& second_type; /// @c second_type is the second bound type first_type first; second_type second; pair(T1& t1, T2& t2) : first(t1), second(t2){} template<class U1, class U2> pair(pair<U1, U2> const& p) : first(p.first), second(p.second){} template<class U1, class U2> pair& operator=(const pair<U1, U2>& p){ first = p.first; second = p.second; return *this; } }; }
也许我错过了一些明显的东西，如果有一些明显的缺陷，我可以编辑答案。
我最终通过构build一个非常简单的结构来解决类似的问题。 我甚至不担心赋值运算符，因为默认的运行正常。
template<class U, class V> struct pair { pair(U & first, V & second): first(first), second(second) {} U & first; V & second; }
