Грамотное кодирование против. std::pair, решения?

Как насчет этого:

struct MyPair : public std::pair < int, std::string >
{
    const int& keyInt() { return first; }
    void keyInt( const int& keyInt ) { first = keyInt; }
    const std::string& valueString() { return second; }
    void valueString( const std::string& valueString ) { second = valueString; }
};

Это немного многословно, однако использование этого в вашем коде может упростить чтение, например:

std::vector < MyPair > listPairs;

std::vector < MyPair >::iterator iterPair( listPairs.begin() );
if ( iterPair->keyInt() == 123 )
    iterPair->valueString( "hello" );

Кроме этого, я не вижу никакой серебряной пули, которая прояснила бы ситуацию.

std::pair — это хороший способ создать «локальный» и по существу анонимный тип с по существу анонимными столбцами; если вы используете определенную пару в таком большом лексическом пространстве, что вам нужно назвать тип и столбцы, я бы вместо этого использовал простое struct.

typedef std::pair<bool, int> IsPresent_Value;
typedef std::pair<double, int> Price_Quantity;

... вы поняли.

Вы можете создать две пары геттеров (const и non), которые будут просто возвращать ссылку на первый и второй, но будут гораздо более читабельными. Например:

string& GetField(pair& p) { return p.first; }
int& GetValue(pair& p) { return p.second; }

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

Если вы планируете использовать это часто, вы также можете создать макрос, который будет генерировать эти геттеры для вас, учитывая имена и типы: MAKE_PAIR_GETTERS(Field, string, Value, int) или около того. Упрощение геттеров, вероятно, позволит компилятору оптимизировать их, поэтому они не добавят накладных расходов во время выполнения; и использование макроса позволит легко создать эти геттеры для любого использования, которое вы используете для пар.

Вы можете использовать кортежи boost, но они на самом деле не меняют основную проблему: действительно хотите ли вы получить доступ к каждой части пары/кортежа с помощью небольшого целочисленного типа, или вам нужен более «грамотный» код. См. этот вопрос, который я разместил некоторое время назад.

Однако boost::Optional это полезный инструмент, который, как я обнаружил, заменяет довольно много случаев, когда пары/кортежи рекламируются как ответ.

Недавно я обнаружил, что использую boost::tuple вместо std::pair. Вы можете определить перечислители для каждого члена, и поэтому очевидно, что представляет собой каждый член:

typedef boost::tuple<int, int> KeyValueTuple;
enum {
  KEY
  , VALUE
};

void foo (KeyValueTuple & p) {
    p.get<KEY> () = 0;
    p.get<VALUE> () = 0;
}

void bar (int key, int value)
{
  foo (boost:tie (key, value));
}

Кстати, комментарии приветствуются, если есть скрытые затраты на использование этого подхода.

EDIT: удалить имена из глобальной области.

Просто быстрый комментарий относительно глобального пространства имен. В общем, я бы использовал:

struct KeyValueTraits
{
  typedef boost::tuple<int, int> Type;
  enum {
    KEY
    , VALUE
  };
};

void foo (KeyValueTuple::Type & p) {
    p.get<KeyValueTuple::KEY> () = 0;
    p.get<KeyValueTuple::VALUE> () = 0;
}

Похоже, что boost::fusion действительно связывает личность и значение ближе друг к другу.

Как упомянул Алекс, std::pair очень удобен, но когда это становится запутанным, создайте структуру и используйте ее таким же образом, взгляните на код std::pair, это не так уж сложно.

Мне также не нравится std::pair в том виде, в котором он используется в std::map, в записях карты должны быть ключ и значение членов.
Я даже использовал boost::MIC, чтобы избежать этого. Тем не менее, boost::MIC также имеет свою цену.

Кроме того, возврат std::pair приводит к менее читаемому коду:

if (cntnr.insert(newEntry).second) { ... }

???

Я также обнаружил, что std::pair обычно используется ленивыми программистами, которым нужно 2 значения, но они не думают, зачем эти значения нужны вместе.