目的是std::make_pair
什么?
为什么不做std::pair<int, char>(0, 'a')
呢?
两种方法有什么区别?
std::make_pair
是多余的。下面有一个答案详细说明了这一点。
目的是std::make_pair
什么?
为什么不做std::pair<int, char>(0, 'a')
呢?
两种方法有什么区别?
std::make_pair
是多余的。下面有一个答案详细说明了这一点。
Answers:
不同之处在于,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)
每次您分配给一个人,随着时间的流逝都会很烦人...
one = {10, 20}
现在可以做到,但是我没有C ++ 11编译器可以方便地对其进行检查。
make_pair
适用于未命名的类型,包括结构,联合,lambda和其他名称。
在C ++ 17之前无法从构造函数推断类模板参数
在C ++ 17之前,您不能编写如下内容:
std::pair p(1, 'a');
因为那样会从构造函数参数中推断出模板类型。
C ++ 17使该语法成为可能,因此是make_pair
多余的。
在C ++ 17之前,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
VS insert_iterator
。
也可以看看:
最小的例子
为了使事情更具体,我们可以使用以下方法最小地观察该问题:
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示例。
std::make_pair
C ++ 17中没有弃用它?
make_pair
解包参考包装,因此它实际上与CTAD不同。
使用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 ++模板编程中的常见用法。它被称为对象生成器惯用法,您可以在此处找到更多信息和一个不错的示例。
编辑正如评论中某人所建议的(已删除),以下内容是从链接中稍作修改的摘录,以防其中断。
对象生成器允许创建对象而无需显式指定其类型。它基于类模板所没有的功能模板的有用属性:功能模板的类型参数是根据其实际参数自动推导出的。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);
}
&&
从C ++ 11开始。
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;
}
std::move
在的内部insert
和/或周围,我都得到相同的结果sample
。只有当我改变std::map<int,Sample>
到std::map<int,Sample const&>
我减少构造的对象的数量,只有当我删除拷贝构造函数,我消除所有副本(显然)。在完成所有这些更改之后,我的结果包括对同一对象的一次调用默认构造函数和两次调用析构函数。我想我一定很想念东西。(g ++ 5.4.1,c ++ 11)
emplace
而不是insert
如果您只是构造一个要立即插入的值(并且您不想要额外的实例。)这不是我的专业领域,如果我什至可以说我有一个,而是复制/移动C ++ 11引入的语义对我有很大帮助。
从c ++ 11开始,只需对使用统一初始化即可。所以代替:
std::make_pair(1, 2);
要么
std::pair<int, int>(1, 2);
只是使用
{1, 2};
{1, 2}
可用于初始化一对,但不提交类型对。即,使用自动时,您必须在RHS上输入一种类型: auto p = std::pair{"Tokyo"s, 9.00};
。