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当然是我指定给kv的引用隐藏在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是什么“错误”,但是如果我天真地重新实现它,我没有任何问题(使用相同的编译器gccclang )。

 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; }