¿Cuál es el propósito de std:: make pair vs el constructor de std:: pair?

Como @MSalters respondió anteriormente, ahora puede usar llaves para hacer esto en C++11 (solo lo verificó con un compilador de C++11):

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

No hay diferencia entre usar make_pair y llamar explícitamente al constructor pair con argumentos de tipo especificados. std::make_pair es más conveniente cuando los tipos son detallados porque un método de plantilla tiene deducción de tipo basada en sus parámetros dados. Por ejemplo,

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));

Vale la pena señalar que este es un lenguaje común en la programación de plantillas de C++. Se conoce como el modismo del Generador de objetos, puedes encontrar más información y un buen ejemplo aquí.

Edit Como alguien sugirió en los comentarios (desde que se eliminó), lo siguiente es un extracto ligeramente modificado del enlace en caso de que se rompa.

Un Generador de objetos permite la creación de objetos sin especificar explícitamente sus tipos. Se basa en una propiedad útil de la función plantillas que no tienen las plantillas de clase: Los parámetros de tipo de una plantilla de función se deducen automáticamente de sus parámetros reales. std::make_pair es un ejemplo simple que devuelve una instancia de la plantilla std::pair dependiendo de los parámetros reales de la función 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);
}

Los argumentos de la plantilla de clase no se pueden inferir del constructor antes de C++17

Antes de C++17 no se podía escribir algo como:

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

Puesto que eso inferiría tipos de plantilla de los argumentos del constructor.

C++17 hace posible esa sintaxis, y por lo tanto make_pair redundante.

Antes de C++17, std::make_pair nos permitía escribir código menos detallado:

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

En lugar de la más detallada:

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

Que repite los tipos, y puede ser muy largo.

La inferencia de tipos funciona en ese caso pre-C++17 porque make_pair no es un constructor.

make_pair es esencialmente equivalente a:

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

El mismo concepto se aplica a inserter vs insert_iterator.

Véase también:

• ¿Por qué no inferir parámetro de plantilla de constructor?
• https://en.wikibooks.org/wiki/More_C++_Idioms / Object_Generator

Make_pair crea una copia extra sobre el constructor directo. Siempre he escrito mis pares para proporcionar una sintaxis simple.
Esto muestra la diferencia (ejemplo de 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;
}