Что является станд.:: пара?

compressed_pair использование некоторый шаблонный обман для оставления свободного места. В C++ объект (маленький o) не может иметь того же адреса как другой объект.

Поэтому, даже если Вы имеете

struct A { };

A, размер не будет 0, потому что затем:

A a1;
A a2;
&a1 == &a2;

содержал бы, который не позволяется.

, Но много компиляторов сделают то, что называют "пустой оптимизацией базового класса":

struct A { };
struct B { int x; };
struct C : public A { int x; };

Здесь, для B и C хорошо иметь тот же размер, даже если sizeof(A) не может быть нуль.

Так boost::compressed_pair использует в своих интересах эту оптимизацию и, если это возможно, наследуется от одной или других из типов в паре, если это пусто.

Так std::pair мог бы быть похожим (я игнорировал много, ctors и т.д.):

template<typename FirstType, typename SecondType>
struct pair {
   FirstType first;
   SecondType second;
};

, Который означает, ли или FirstType или SecondType A, Ваш pair<A, int>, должно быть больше, чем [1 116].

, Но если Вы используете compressed_pair, его сгенерированный код будет выглядеть сродни:

 struct compressed_pair<A,int> : private A {
    int second_;
    A first() { return *this; }
    int second() { return second_; }
 };

И compressed_pair<A,int> только будет целый sizeof (интервал).

Иногда необходимо возвращать 2 значения из функции, и это часто - излишество, чтобы пойти и создать класс только для этого.

std:pair пригождается в тех случаях.

я думаю, что boost:compressed_pair в состоянии оптимизировать далеко членов размера 0. Который главным образом полезен для тяжелого шаблонного оборудования в библиотеках.

при управлении типами непосредственно это не важно.

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

boost::function<void(int)> f(boost::bind(&f, _1));

Это может внезапно оказать большое влияние для использования compressed_pair в случаях как вышеупомянутый. Что могло произойти если повышение:: свяжите хранит указатель функции и заполнителя _1 как участники сам по себе или в std::pair сам по себе? Ну, это могло чрезмерно увеличиться в размерах [до 113]. Принятие указателя функции имеет 8 байтов (весьма распространенный специально для функций членства), и заполнитель имеет один байт (см. ответ Логана для почему), затем нам, возможно, были нужны 9 байтов для связывать объекта. Из-за выравнивания это могло чрезмерно увеличить размер до 12 байтов в обычной системе на 32 бита.

boost::function поощряет его реализации применять маленькую объектную оптимизацию. Это означает, что для маленький функторы, маленький буфер, непосредственно встроенный в эти boost::function, объект используется для хранения функтора. Для больших функторов "куча" должна была бы использоваться при помощи оператора, нового для получения памяти. Вокруг повышения версия 1.34 , было решено принять эта оптимизация , потому что это было изображено, можно было получить некоторую выгоду очень высокой эффективности.

Теперь, разумное (все же, возможно, все еще довольно маленький) предел для такого маленького буфера составил бы 8 байтов. Таким образом, наши довольно простые связывают объект, был бы не , вписывается в маленький буфер и потребовал бы, чтобы оператор, новый, был сохранен. Если бы связывать объект выше использовал бы compressed_pair, он может на самом деле уменьшить свой размер до 8 байтов (или 4 байта для не являющегося членом указателя функции часто), потому что заполнитель является не чем иным как пустым объектом.

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

Это - стандартный класс для хранения пары значений. Это возвращается/используется некоторыми стандартными функциями, как std::map::insert.

boost::compressed_pair требования быть более эффективным: посмотрите здесь

станд.:: пара пригождается для нескольких других контейнерных классов в STL.

, Например:

std::map<>
std::multimap<> 

Оба станд. хранилища:: пары ключей и значений.

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

Дополнительная информация: повышение:: compressed_pair полезен, когда один из типов пары является пустой структурой. Это часто используется в шаблонном метапрограммировании, когда типы пары программно выведены из других типов. В тогда заканчиваются, у Вас обычно есть некоторая форма "пустой структуры".

я предпочел бы станд.:: пара для любого "нормального" использования, если Вы не в тяжелое шаблонное метапрограммирование.

Это - только структура с двумя переменными под капотом.

мне на самом деле не нравится использовать станд.:: пара для функциональных возвратов. Читатель кода должен был бы знать то, что .first и каков .second.

компромисс, который я использую иногда, состоит в том, чтобы сразу создавать постоянные ссылки на .first и .second при именовании ссылок ясно.

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

Что такое std::pair for, зачем мне его использовать?

Это такой же простой кортеж из двух элементов. Она была определена в первой версии STL во времена, когда компиляторы не очень широко поддерживали шаблоны и приемы метапрограммирования, которые потребовались бы для реализации более сложных типов кортежей типа Boost.Tuple.

Это полезно во многих ситуациях. std::pair используется в стандартных ассоциативных контейнерах. Его можно использовать как простую форму диапазона std::pair - таким образом, можно определить алгоритмы, принимающие по отдельности один объект, представляющий диапазон, а не два итератора. (Это полезная альтернатива во многих ситуациях.)