Есть ли удобный способ обернуть станд.:: пара как новый тип?

Это что Повышение. Кортеж был сделан для.

, Но необходимо, вероятно, использовать станд.:: кортеж теперь...

Коллега указал на меня на два возможных решения:

Используя повышение сильное определение типа как улучшенная версия определения типа. Я никогда не слышал об этом прежде, и это, кажется, действительно не часть никакой подбиблиотеки, просто вид плавания.

Используя макрос, чтобы сгенерировать код, необходимый для различных операторов. Таким образом, я ничего не должен был бы явно писать на на уровень определения, просто делать что-то как DEFINE_PAIR_TYPE(Position, int, int, row, col);. Это является, вероятно, самым близким к тому, что я ищу, но это все еще чувствует вид зла по сравнению с некоторыми решениями, представленными другими.

Существует также эти Повышение:: библиотека Operators , чтобы автоматически сгенерировать код оператора. Это подобно библиотеке SGI, которую Martin York предложил , но мог бы быть более портативным.

Можно все еще снова использовать pair функциональность путем передачи ему:

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

, Хотя Вы все еще заканчиваете с выполнением этого для каждого operatory, Вам нужно...

К сожалению, сильный typedefs не превратит его в C++ 0x, этому дали классификацию Не готовый к C++ 0x, но открытый для перепредставления в будущем.

Можно использовать некоторые стандартные служебные шаблоны, что справка определяет операторы отношения.

#include < utility>

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

Требования к типам

требование для оператора! = то, что x == y является допустимым выражением
, требование для оператора> является этим y < x является допустимым выражением
требование для operator< = это y < x является допустимым выражением
, требование для оператора> = является этим x < y является допустимым выражением

Так в основном, он автоматически генерирует другие операторы, дают < и == все, что необходимо сделать, включают < utility>

Я должен сказать, что это - длительное размышление только для создания простой структуры.

Перегрузка operator< и оператор == и Вы сделаны. Я использую это для большого количества кода, который я пишу, главным образом потому что у меня обычно есть больше членских переменных для хранения, чем 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 :: пара именно по этой причине. Никогда не угадаешь, что есть что, а поскольку доступ к первому и второму является публичным, вы также не можете обеспечить выполнение контрактов.

Но в конце концов, это вопрос вкуса.