有没有一种方便的方法将 std::pair 包装为新类型？

Question

我经常发现自己使用 std::pair 将两个相关量的逻辑分组定义为函数参数/返回值。 一些例子：行/列、标签/值等。

很多时候我真的应该滚动我自己的类，而不是仅仅使用 std::pair。 当事情开始崩溃时，很容易看出 - 当代码中充斥着 make_pair、first 和 secondary 时，很难记住什么是什么 - std::pair传达的含义比 Position 类型要少。

您发现将 std::pair 的功能包装在传达真正含义的类型中的最佳方法是什么？

以下是我考虑过的一些事情：

typedef std::pair<int, int> Position;

这至少在传递类型时为该类型提供了一个有意义的名称，但该类型并未强制执行，它实际上仍然只是一对，并且大多数相同的问题仍然存在。 然而，这写起来非常简单。

struct Position : public std::pair<int, int>
{
    typedef std::pair<int, int> Base;
    Position() : Base() {}
    Position(const Position &x) : Base(x) {}
    Position(int a, int b) : Base(a, b) {}

    int &row() { return first; }
    const int &row() const { return first; }

    int &col() { return second; }
    const int &col() const { return second; }
};

这更好，因为我们可以通过合理的描述性名称访问变量。 这里的问题是你仍然可以访问第一个和第二个，因此抽象很容易泄漏。 此外，通过函数访问简单变量会使语法变得烦人。

显而易见的下一步是将继承设为私有：

struct Position : private std::pair<int, int>
{
    typedef std::pair<int, int> Base;
    Position() {}
    Position(const Position &x) : Base(x) {}
    Position(int a, int b) : Base(a, b) {}

    int &row() { return first; }
    const int &row() const { return first; }

    int &col() { return second; }
    const int &col() const { return second; }

    bool operator<(const Position &x) const { return Base(*this) < Base(x); }
    // other forwarding operators as needed...
};

所以现在至少我们已经摆脱了对第一和第二的访问，但现在出现了一个新问题。 当我们想要将类型存储在 std::set 中时，我们现在无法访问运算符< 过载，因为我们无法访问第一个和第二个。 这意味着我们必须为我们想要的每个运算符重载定义一个转发函数。 对我来说，这通常是 ==、!= 和 <，但可能还有其他我想要的。 是的，我知道我可能不应该重载运算符< 只是将它放在关联容器中，但这使一切变得非常简单......并且为每个新类型定义这些运算符是一件痛苦的事情，我们仍然必须通过函数进行访问。 解决这个问题：

struct Position
{
    Position() {}
    Position(const Position &x) : row(x.row), col(x.col) {}
    Position(int row, int col) : row(row), col(col) {}

    int row, col;
};
bool operator<(const Position &a, const Position &b)
{
    return a.row < b.row || (!(b.row < a.row) && a.col < b.col);
}
// more overloads as needed

现在我们有了简单的变量访问，但现在定义重载运算符更加痛苦，因为我们实际上必须每次都重新实现它们，而不是仅仅将它们转发到该对的实现...

我们可以 有没有我忽略的解决方案可以让这件事变得简单而又没有缺点？ 如果没有，您会更喜欢哪个？

Answer 1

这就是 Boost.Tuple 的制作过程为了。

但你现在可能应该使用 std::tuple ...

Answer 2

一位同事向我指出了两种可能的解决方案：

使用 boost Strong typedef 作为 typedef 的改进版本。 我以前从未听说过这个，而且它似乎并不真正属于任何子图书馆，只是一种浮动的。

使用宏生成不同运算符所需的代码。 这样我就不必在每个定义级别上显式编写任何内容，只需执行类似 DEFINE_PAIR_TYPE(Position, int, int, row, col); 的操作即可。 这可能最接近我正在寻找的东西，但与其他人提出的一些解决方案相比，它仍然感觉有点邪恶。

Answer 3

还有 Boost::Operators 库自动生成操作员代码。 它类似于 SGI 库 Martin York 建议，但可能更便携。

Answer 4

您仍然可以通过转发来重用 pair 功能：

bool operator< ( const Position &a, const Position &b ) 
{
    return
        std::make_pair( a.row, a.col ) < std::make_pair( b.row, b.col );
}

尽管您最终仍然需要为您需要的每个操作员执行此操作...

Answer 5

您可以使用一些标准实用程序模板来帮助定义关系运算符。

#include <实用程序>

http://www.sgi.com/tech/stl/operators.html

类型要求

运算符 != 的要求是 x == y 是一个有效的表达式
对操作人员的要求> 是 y < x 是一个有效的表达式
运算符 <= 的要求是 y < x 是一个有效的表达式
运算符>=的要求是x < y 是一个有效的表达式

所以基本上它会自动生成其他运算符给出
并且 == 您所要做的就是包含;

Answer 6

我必须说，仅仅为了制作一个简单的结构就需要花费很多心思。

重载运算符< 和运算符 == 就完成了。 我在编写的很多代码中都使用它，主要是因为我通常要存储的成员变量多于 2 个。

struct MyStruct
{
    std::string var1;
    std::string var2;
    bool var3;

    struct less : std::binary_function<struct MyStruct, struct MyStruct, bool>
    {
        bool operator() (const struct MyStruct& s1, const struct MyStruct& s2) const
            { if (var1== a2.var1) return var2 < a2.var2; else return var3 < a2.var3; }
    };
};
typedef std::set<struct MyStruct, MyStruct::less> MySet;

或者将它们放在类定义中

bool operator==(const MyStruct& rhs) const 
    { return var1 == rhs.var1 && var2 == rhs.var2 && var3 == rhs.var3; };
bool operator<(const MyStruct& a2) const  
    { if (var1== a2.var1) return var2 < a2.var2; else return var3 < a2.var3; };

最好的原因是上面的内容很容易理解，它们可以放入类中定义很容易，如果您发现以后需要更多变量，它们也很容易扩展。 当有更简单的解决方案时，我永远不会尝试重载 std::pair 。

Answer 7

不要使用它。

正是因为这个原因，我讨厌 std::pair 。 你永远不知道哪个是哪个，而且由于对第一个和第二个的访问是公开的，你也无法执行合同。

但归根结底，这是一个品味问题。

Answer 8

不幸的是强typedef s 不会进入 C++0x，已被赋予分类“尚未准备好用于 C++0x，但开放以在将来重新提交”。