std::pair 引用

Question

拥有std::pair 的引用是否有效？特别是，赋值运算符有问题吗？根据this link的说法，operator=似乎没有特殊处理，所以无法生成默认的赋值运算符。

我想要一个 pair<T&, U&> 并能够为其分配另一对（值或引用）并修改指向的对象。

Answer 1

在 C++11 中，您可以使用 std::pair<std::reference_wrapper<T>, std::reference_wrapper<U>>，该类型的对象将完全按照您的意愿行事。

Answer 2

不，你不能在 C++03 中可靠地做到这一点，因为 pair 的构造函数引用了 T，并在 C++03 中创建了 reference to a reference is not legal。

请注意，我说的是“可靠”。一些仍在使用的常见编译器（对于 GCC，我测试了 GCC4.1，@Charles 报告了 GCC4.4.4）不允许形成对引用的引用，但最近允许在它们实现时允许它引用折叠（T& 是 T，如果 T 是引用类型）。如果你的代码使用了这样的东西，你不能依赖它在其他编译器上工作，直到你尝试并看到。

听起来你想使用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;

Answer 3

我认为拥有std::pair 住房参考是合法的。 std::map 使用 std::pair 和 const 类型，毕竟不能分配给任何一个。

我想要一个 pair<T&, U&> 并能够分配给它另一对

分配不起作用，因为您无法重置引用。但是，您可以复制初始化此类对象。

Answer 4

你是对的。您可以创建一对引用，但不能再使用operator =。

Answer 5

我想我的想法和你一样。我写了以下课程来解决这个特殊的痒：

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

（记住相关的包含）。

当然，我分配给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;      
}

（欢迎所有 cmets，因为我绝不是 c++ 专家。）

Answer 6

我不知道 C++03 中 std::pair 的“错误”是什么，但如果我天真地重新实现它，我没有任何问题，（使用相同的编译器 gcc 和 @987654323 @)。

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 命名空间进行重载/特化，但我认为如果它可以扩展类）

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

也许我遗漏了一些明显的东西，如果指出了一些明显的缺陷，我可以编辑答案。

Answer 7

发布c++14，可以这样做：

int a, b;
auto const p(std::make_pair(std::ref(a), std::ref(b)));

也可以使用std::cref()。

Answer 8

我最终通过构建一个非常简单的结构解决了类似的问题。我什至不担心赋值运算符，因为默认的应该可以正常工作。

template<class U, class V>
struct pair
{
pair(U & first, V & second): first(first), second(second) {}
U & first;
V & second;
}