（由于CTAD，此答案仅适用于C++14和更早的标准）

不同之处在于，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)

每次你分配到一个，这将是恼人的随着时间的推移…

C++17之前的类模板参数无法从构造函数中推断出来

在C++17之前，你不能写这样的东西：

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

由于这将从构造函数参数推断出模板类型，因此必须将其显式编写为：

std::pair<int,char> p(1, 'a');

C17使这种语法成为可能，因此make_pair是冗余的。
在C17之前，std::make_pair允许我们编写不那么冗长的代码：

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

而不是更冗长的：

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

其重复类型，并且可以非常长。
类型推断在C++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。
参见：

• Why not infer template parameter from constructor?
• 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);

它使用常规函数而不是构造函数。

std::reference_wrapper的差异

这个注解提到std::make_pair解包std::reference_wrapper，而构造函数没有，所以这是一个区别。TODO示例。
测试GCC 8.1.0，Ubuntu 16.04.

正如@MSalters在上面回复的那样，你现在可以在C11中使用花括号来做到这一点（刚刚用C11编译器验证了这一点）：

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

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

值得注意的是，这是C++模板编程中的一个常见习惯用法。它被称为对象生成器习惯用法，您可以找到更多信息和一个很好的示例here。

编辑正如有人在评论中建议的那样（自从删除后），以下是从链接中稍微修改的摘录，以防它中断。

对象生成器允许创建对象，而无需显式指定其类型。它基于函数模板的一个有用属性，而类模板没有：函数模板的类型参数是从其实际参数自动推导出来的。std::make_pair是一个简单的示例，它根据std::make_pair函数的实际参数返回std::pair模板的示例。

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

make_pair在直接构造函数上创建了一个额外的副本。我总是键入def我的pairs来提供简单的语法。
这显示了差异（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;
}

从c++11开始，只需对pairs使用统一初始化。因此，而不是：

std::make_pair(1, 2);

或

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

刚刚使用

{1, 2};