Какова цель std:: make_pair против конструктора std:: pair?

Ответ 1

Разница заключается в том, что при std::pair вам нужно указать типы обоих элементов, тогда как std::make_pair создаст пару с типом передаваемых ей элементов, без необходимости указывать ее. Это то, что я мог собрать из разных документов в любом случае.

См. этот пример из http://www.cplusplus.com/reference/std/utility/make_pair/

pair <int,int> one;
pair <int,int> two;

one = make_pair (10,20);
two = make_pair (10.5,'A'); // ok: implicit conversion from pair<double,char>

Помимо неявного конверсионного бонуса, если вы не использовали make_pair, вам нужно будет

one = pair<int,int>(10,20)

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

Ответ 2

Как уже говорилось в @MSalters, теперь вы можете использовать фигурные скобки для этого в С++ 11 (просто проверьте это с помощью компилятора С++ 11):

pair<int, int> p = {1, 2};

Ответ 3

Нет разницы между использованием make_pair и явным вызовом конструктора pair с указанными аргументами типа. std::make_pair более удобно, когда типы являются подробными, потому что метод шаблона имеет вывод типа на основе его заданных параметров. Например,

std::vector< std::pair< std::vector<int>, std::vector<int> > > vecOfPair;
std::vector<int> emptyV;

// shorter
vecOfPair.push_back(std::make_pair(emptyV, emptyV));

 // longer
vecOfPair.push_back(std::pair< std::vector<int>, std::vector<int> >(emptyV, emptyV));

Ответ 4

Стоит отметить, что это распространенная идиома в программировании шаблонов С++. Он известен как идиома генератора объектов, вы можете найти дополнительную информацию и хороший пример здесь.

Изменить. Как кто-то предложил в комментариях (после удаления) следующее немного измененное извлечение из ссылки в случае его разрыва.

Генератор объектов позволяет создавать объекты без явного указания их типов. Он основан на полезном свойстве шаблонов функций, которые не имеют шаблонов классов: Параметры типа шаблона функции выводятся автоматически из его фактических параметров. std::make_pair - простой пример, который возвращает экземпляр шаблона std::pair в зависимости от фактических параметров функции std::make_pair.

template <class T, class U>
std::pair <T, U> 
make_pair(T t, U u)
{
  return std::pair <T, U> (t,u);
}

Ответ 5

Аргументы шаблона класса не могут быть выведены из конструктора до С++ 17

До С++ 17 вы не могли написать что-то вроде:

std::pair p(1, 'a');

так как это выведет типы шаблонов из аргументов конструктора.

С++ 17 делает возможным такой синтаксис и, следовательно, make_pair избыточным.

До С++ 17 std::make_pair позволяла нам писать меньше подробного кода:

MyLongClassName1 o1();
MyLongClassName2 o2();
auto p = std::make_pair(o1, o2);

вместо более многословного:

std::pair<MyLongClassName1,MyLongClassName2> p{o1, o2};

который повторяет типы и может быть очень длинным.

Вывод типа работает в этом случае до С++ 17, потому что make_pair не является конструктором.

make_pair по сути эквивалентен:

template<class T1, class T2>
std::pair<T1, T2> my_make_pair(T1 t1, T2 t2) {
    return std::pair<T1, T2>(t1, t2);
}

То же самое относится и к inserter против insert_iterator.

Смотрите также:

• Почему бы не вывести параметр шаблона из конструктора?
• https://en.wikibooks.org/wiki/More_C++_Idioms/Object_Generator

Минимальный пример

Чтобы сделать вещи более конкретными, мы можем наблюдать проблему минимально с:

main.cpp

template <class MyType>
struct MyClass {
    MyType i;
    MyClass(MyType i) : i(i) {}
};

template<class MyType>
MyClass<MyType> make_my_class(MyType i) {
    return MyClass<MyType>(i);
}

int main() {
    MyClass<int> my_class(1);
}

затем:

g++-8 -Wall -Wextra -Wpedantic -std=c++17 main.cpp

компилирует счастливо, но:

g++-8 -Wall -Wextra -Wpedantic -std=c++14 main.cpp

не удается с:

main.cpp: In function ‘int main():
main.cpp:13:13: error: missing template arguments before ‘my_class
     MyClass my_class(1);
             ^~~~~~~~

и требует вместо того, чтобы работать:

MyClass<int> my_class(1);

или помощник:

auto my_class = make_my_class(1);

который использует обычную функцию вместо конструктора.

Протестировано с GCC 8.1.0, Ubuntu 16.04.

Ответ 6

make_pair создает дополнительную копию над прямым конструктором. Я всегда typedef мои пары, чтобы обеспечить простой синтаксис.
Это показывает разницу (пример: Rampal Chaudhary):

class Sample
{
    static int _noOfObjects;

    int _objectNo;
public:
    Sample() :
        _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside default constructor of object "<<_objectNo<<std::endl;
    }

    Sample( const Sample& sample) :
    _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside copy constructor of object "<<_objectNo<<std::endl;
    }

    ~Sample()
    {
        std::cout<<"Destroying object "<<_objectNo<<std::endl;
    }
};
int Sample::_noOfObjects = 0;


int main(int argc, char* argv[])
{
    Sample sample;
    std::map<int,Sample> map;

    map.insert( std::make_pair( 1, sample) );
    //map.insert( std::pair<int,Sample>( 1, sample) );
    return 0;
}

Ответ 7

начиная с С++ 11 просто используйте равномерную инициализацию для пар. Так что вместо:

std::make_pair(1, 2);

или же

std::pair<int, int>(1, 2);

просто используйте

{1, 2};