为什么向量emplace调用复制构造函数，而set不调用复制构造函数？
向量（Vector）是一种动态数组，可以在其末尾高效地插入和删除元素。emplace_back() 是向量的一个成员函数，用于在向量末尾直接构造元素。当调用emplace_back()时，会根据传入的参数直接在向量的末尾构造一个新元素，而不是先创建一个临时对象然后再进行拷贝构造。这样做可以节省拷贝构造的开销，提高性能。
而集合（Set）是一种有序的容器，其中的元素是唯一的。在集合中插入新元素时，set会先创建一个临时对象，然后再进行拷贝构造到集合中。这是因为集合中的元素需要保持有序，因此无法直接在集合中构造元素。
总结起来，向量中使用emplace_back()是为了高效地构造元素，而集合中使用拷贝构造函数是为了维持有序性。
相关·内容
为什么在调用emplace_back()之后立即调用~Base()
为什么在析构函数调用之后可以访问sayHello()
为什么~Base()会再次被调用
#include <iostream>
#include <vector>
class Base
{
private:
static int m_count;
public:
Base()
{
std::cout << " Base created. Count = " &l
浏览 2提问于2019-06-27得票数 3
struct Object {
Object() { cout << "constructor\n"; }
Object(const Object &) { cout << "copy constructor\n"; }
Object(Object &&) { cout << "move constructor\n"; }
};
int main() {
vector<Object> v;
v.reserve(10);
v
浏览 12提问于2014-02-18得票数 23
回答已采纳
我有以下c++代码。您可以看到，我创建了一个带有构造函数和副本构造函数的结构。有人能解释一下为什么要为第一次分配调用复制构造函数而不是为其他两个任务调用复制构造函数吗？
#include <iostream>
#include <string>
#include <vector>
struct Vertex
{
float x, y, z;
Vertex(float x, float y, float z)
: x(x), y(y), z(z)
{
std::cout << "Cr
浏览 6提问于2022-08-11得票数 0
我这里有一条线：
someSTLVector.push_back(SomeClass(...));
我希望构建什么SomeClass并将其移动到向量的后面，没有任何副本。然而，破坏者被叫到这里。我试着用std::move来修改这个
someSTLVector.push_back(std::move(SomeClass(...)));
但结果并没有改变。
我还尝试在SomeClass中定义以下内容
SomeClass(SomeClass&&) = default;
SomeClass& operator= (SomeClass&&) = default;
浏览 2提问于2020-02-21得票数 1
回答已采纳
我想知道为什么我向后推回向量的元素会在这种情况下被调用其析构函数：
#include <iostream>
#include <vector>
class Foo
{
public:
Foo(int a)
: m_a(a)
{
std::cout << "Foo ctor() " << m_a << std::endl;
}
~Foo()
{
std::cout << "Foo dtor() " <&l
浏览 2提问于2014-11-07得票数 2
回答已采纳
因此，我一直在探索如何使用我创建的自定义模板类创建一个动态数组。
#include <iostream>
#include <vector>
//HOW TO SET CLASS INTO DYNAMICAL ARRAY WITH VECTOR
//CREATE A CLASS
class User{
std::string name;
public:
User(){
}
User(std::string name){
this->name = name;
}
void set_name(std
浏览 3提问于2021-09-21得票数 0
回答已采纳
具有通常的基本->派生层次结构，例如：
class Fruit { ... };
class Pear : Fruit { ... };
class Tomato : Fruit { ... };
std::vector<Fruit*> m_fruits;
使用emplace_back而不是push_back是否有意义(例如:性能更好
std::vector::emplace_back( new Pear() );
std::vector::emplace_back( new Tomato() );
浏览 0提问于2013-04-03得票数 31
回答已采纳
我试图将unique_ptr的向量生成到Example类，由于某种原因，每次调用emplace_back()时，对象都会被解构两次。我认为如果我在这里展示代码，你就更容易理解了：
#include <vector>
#include <iostream>
#include <memory>
class Example;
typedef std::unique_ptr<Example> ExampleUPointer;
std::vector<ExampleUPointer> ExampleList;
class Example {
浏览 5提问于2021-01-10得票数 1
回答已采纳
以下代码仅在删除类Test的析构函数的定义或删除std::ofstream成员时进行编译。否则，我会得到一个错误，告诉我已经删除了Test的复制构造函数。
有人能解释一下为什么吗？谢谢!
#include<fstream>
#include<vector>
class Test {
public:
Test() {};
~Test() {};
std::ofstream ofs;
};
int main() {
std::vector<Test> vec;
vec.emplace_back(Test());
}
浏览 3提问于2020-07-03得票数 1
回答已采纳
我需要一个函数，它将一个shared_ptr返回到包含大量对象的向量。下面的代码实现了这一点，但是可以看到复制构造函数被调用了很多次。
#include <iostream>
#include <vector>
#include <memory>
using namespace std;
class A {
public:
int IA ;
A(int ia) {
cout << "Constructor is called\n" ;
IA = ia ;
}
浏览 5提问于2022-06-22得票数 2
回答已采纳
嗨，下面的<elemVec>被放置在另一个<ElementA>对象的向量中，但是内容都被设置为0。我有一个显示<elemData>内容的调试行，它清楚地显示正在将值添加到向量中。
#include "ElementA.h"
#include <iostream>
#include <random>
#include <ctime>
using std::cout;
using std::endl;
int main(int argc, char** argv)
{
vector<Eleme
浏览 1提问于2015-01-13得票数 0
回答已采纳
#include <iostream>
#include<vector>
using namespace std;
class test{
public:
test(){
cout<<"constructor called"<<endl;
}
test(const test& obj){
cout<<"copy constructor called"<<endl;
浏览 1提问于2019-02-06得票数 3
我创建了一个类，它在构造函数中分配自己的内存，并在析构函数中释放它。但是，如果我制作了一个像std::vector<CLASS> m(1)这样的std：：向量，那么它分配的数据就会立即被释放。这意味着我丢失了构造函数中分配的所有数据。我怎么才能阻止这一切？示例：
#include <iostream>
#include <vector>
class test
{
public:
test()
{
std::cout<<"construction of test"<<std::endl;
浏览 3提问于2013-12-07得票数 0
回答已采纳
2回答
考虑下面的示例：
#include <iostream>
#include <vector>
class S {
public:
S() { puts("S()"); }
S(int) { puts("S(int)"); }
~S() { puts("~S()"); }
S(const S &) { puts("S(const S&)"); }
S(S &&) { puts("S&&"); }
const S &
浏览 2提问于2018-03-27得票数 1
3回答
为什么对象的析构函数在超出作用域时和在向量中被调用？例如：
std::vector<Foo> vec;
for (i=10; i<10; i++)
{
Foo object(i);
vec.push_back(object);
}
对象的析构函数是否因为每次超出作用域而被调用？没有指针或shared_pointers，我能让它工作吗？
浏览 8提问于2016-10-22得票数 2
回答已采纳
在某个结构S的左值中使用emplace_back有实际意义吗？ 如下所示： std::vector<S> v;
auto s = S(/*...*/);
v.emplace_back(s); 而不仅仅是： v.emplace_back(/* S constructor arguments */); 或者仅仅是对emplace_back的滥用，因为const S& (以及复制构造函数)是Args... args在emplace_back中的合法实例化，并且没有被明确禁止，所以才会起作用？
浏览 35提问于2019-03-18得票数 8
回答已采纳
代码如下：
vector<set<int>> sets;
set<int> myset{ 3, 5, 8, 2, 10, 9, 7, 15 };
set<int> newSet{ *myset.begin() };
sets.push_back(newSet);
set<int>::iterator it = myset.begin();
it++;
for (; it != myset.end(); it++)
{
for (vector<set<int>>::iterator it1 = sets.
浏览 0提问于2014-06-27得票数 0
1回答
我有以下代码
class base
{
private:
int k;
public:
base(const base& b){ this->k = b.k; cout<<" c-ctor "<<endl; }
base(int a = 10){ k = a; cout<<" a = "<<a<<endl; }
friend const ostream& operat
浏览 0提问于2016-12-15得票数 4
回答已采纳
2回答
为什么会有这么多的电话要复制密码，而我只希望其中的最后九个呢？甚至根本没有返回值优化的duy。
struct C
{
int _i;
C(int i) : _i(i) {}
C(const C& other) { cout << "copy cons from " << other._i << " to " << _i << endl; _i = other._i; }
};
int _tmain(int argc, _TCHAR* argv[])
{
vecto
浏览 4提问于2015-06-30得票数 3
回答已采纳
2回答
如何在向量中构造类？
、、、
我正在学习一个类，我需要这个类的向量。我希望将对象构造到位，而不是使用复制构造。复制结构的使用似乎是不可避免的。
#include <iostream>
#include <string>
#include <vector>
class MyData {
public:
int age;
std::string name;
MyData(int age, std::string name) : age(age), name(name)
{
std::cout << "MyData::
浏览 6提问于2022-08-16得票数 0
回答已采纳
我尝试将类cBar的两个实例嵌入到带有emplace_back函数的向量中。
根据调用的emplace_back，只保留向量中的位置，然后创建新实例“就位”。
现在，我试着用它做实验：
#include <vector>
#include <iostream>
#include <memory>
#include <string>
class cBar
{
public:
cBar(const int index);
cBar(cBar&& other); //needed for emplace_back?
浏览 3提问于2017-04-02得票数 7
回答已采纳
#include <iostream>
#include <vector>
struct T{
T(){
std::cout << "Constructor\n";
}
~T(){
std::cout << "Destructor\n";
}
};
int main() {
std::vector<T> vec;
vec.push_back(T());
vec.push_back(T());
re
浏览 3提问于2017-06-04得票数 0
回答已采纳
我想知道这两者之间有什么不同。我注意到emplace是c++11加法。那么，为什么要添加呢？
浏览 0提问于2013-02-09得票数 64
回答已采纳
2回答
你能解释一下“完美转发”是如何工作的吗？
我读到向量的emplace_back不需要复制或移动对象，因为它的参数是作为可变模板实现的。
std::vector<T>::emplace_back(_Args&&... __args)
你能更详细地描述一下吗？为什么它不能复制也不能移动？
浏览 0提问于2012-07-09得票数 18
我正在c++中做一个项目，我有一个对象向量，其中我想在现有向量上push_back一个对象。但是，在添加对象之前和之后检查大小时，大小从0到12297829382473034412，这让我非常困惑。下面的代码是addCommodity函数。(我已经创建了一个更小的例子来说明同样的问题，所以跳到"SMALL PROBLEM")
void Instance::addCommodity(std::vector<std::string> & tokens) {
/*if(tokens.size()!=5){
std::cerr << "
浏览 2提问于2017-01-18得票数 2
我试图将一些点保留到std：：向量中，并且有一个错误，我不明白：
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Foo{
public:
std::string str;
int i;
Foo(){
this->str = "";
this->i = 0;
}
Foo(Foo ©Foo){
th
浏览 1提问于2014-01-27得票数 3
回答已采纳
考虑到关于std::vector::emplace_back的这段话
将一个新元素附加到容器的末尾。元素是就地构造的，即不执行复制或移动操作。调用元素的构造函数的参数与提供给函数的参数完全相同。
以下样本：
#include <vector>
struct A
{
A(int){}
A(A const&) = delete;
};
int main()
{
std::vector<A> vec;
vec.emplace_back(1);
return 0;
}
在线vec.emplace_back(1); Vi
浏览 2提问于2014-04-10得票数 13
回答已采纳
3回答
我有一个std::vector<std::vector<double>>，并想在它的末尾添加一些元素，所以这是我的试验：
std::vector<std::vector<double> > vec;
vec.emplace_back({0,0});
但是这不能编译，而下面的代码可以：
std::vector<double> vector({0,0});
为什么emplace_back不能在这个位置构造元素？或者我做错了什么？
谢谢你的帮助。
浏览 0提问于2014-07-03得票数 25
回答已采纳
3回答
我希望使用non-assignable默认构造、不可复制的和对象，然后使用迭代器对新创建的对象使用特定的方法。注意，类中没有参数化构造函数，只有默认构造函数。一个简单的例子是：
#include <iostream>
#include <vector>
using namespace std;
class Test {
public:
Test() {}
private:
Test(const Test&) = delete; // To make clas un-copyable.
Test& oper
浏览 2提问于2014-11-21得票数 10
回答已采纳
2回答
我有一个包含多个文件的C++代码。我使用g++-4.8作为我的Ubuntu18.04编译器。在编译程序时，我将面临下面的错误。你能帮我修一下吗？
使用删除函数'std::basic_ofstream::basic_ofstream(const std::_basic_ofstream)‘
我没有这个错误，但是通过将emplace_back()添加到代码中，出现了以下错误：
#include "FileOutputHub.h"
#include <boost/filesystem.hpp>
#include "InitialCondition.h
浏览 12提问于2022-02-07得票数 -1
2回答
class TestClass {
public:
TestClass(string s) {
}
};
当存在TestClass时，我理解emplace和insert之间的区别(当插入副本时，嵌入构造就位)
set<TestClass> test_set;
test_set.insert(TestClass("d"));
test_set.emplace("d");
但是，如果已经有一个TestClass对象，那么它们在机制和性能方面有什么不同呢？
set<TestClass>
浏览 6提问于2016-04-22得票数 5
回答已采纳
为什么以下代码不适用于g++版本4.9.2？如果我试图构建它，编译器会抱怨在向量被告知要保留更多内存的那一行中缺少复制构造函数。
#include <vector>
class Number
{
public:
explicit Number(const int& i) : _value(i) {}
Number(const Number& other) = delete;
Number& operator=(const Number& other) = delete;
private:
int _value;
浏览 4提问于2014-12-14得票数 11
1回答
有这门课：
class A
{
int number;
int number2;
public:
A(int _number):number(_number),number2(0)
{
cout<<"Normal constructor\n";
}
A()
{
cout<<"Default constructor\n";
}
A(const A& source)
{
number = source.nu
浏览 0提问于2020-04-15得票数 3
回答已采纳
6回答
我在试着理解类的向量。第一，班级：
class A {
public:
A() { cout << "A ctor" << endl; }
~A() { cout << "A dtor" << endl; }
};
然后，代码：
int main() {
vector<A> v;
cout << "after vector created" << endl;
v.push_back(A());
cout <
浏览 0提问于2015-07-17得票数 2
回答已采纳
1回答
以下最小工作示例在使用选项1或选项2下的代码时进行编译，但在使用选项3下的代码时不编译。我假设emplace_back()隐式地使用/调用move构造函数，那么为什么显式move()是必要的？这和r-value和l-value有什么关系吗？或者这是否与需要转移所有权的std::unique_ptr有关？(我对这些概念仍不熟悉，特别是在这方面。)
为了完整起见，带有push_back()的选项4也不会编译，除非调用move()。
#include <iostream>
#include <vector>
#include <memory>
class Bet
浏览 5提问于2017-11-15得票数 8
回答已采纳
我创建了一个用唯一ID跟踪实例的类，构造这个类的新实例(或复制复制构造它)提供了一个从ID池中获取的唯一ID。销毁将ID放回池中。Print语句观察实例创建和销毁的时间。
#include <iostream>
#include <vector>
#include <list>
class IdPool {
public:
IdPool() {
m_id = allocateID();
std::cout << "c'tor id: " << m_id <&l
浏览 0提问于2019-02-03得票数 1
vector<vector<int> > res;
res.emplace_back({1,2}); // change to res.push_back({1,2}); would work
这给了我错误
main.cpp:61:25: error: no matching function for call to ‘std::vector<std::vector<int> >::emplace_back(<brace-enclosed initializer list>)’
main.cpp:61:25: note: ca
浏览 6提问于2013-12-05得票数 18
回答已采纳
我正在使用MSVC，，2013。
假设我有一个结构：
struct my_pair {
int foo, bar;
};
我想有效地添加一堆这样的东西，而不需要创建一个临时的，然后丢弃它：
vector<my_pair> v;
v.push_back(41, 42); // does not work [a]
v.push_back({41,42}); // works [b]
v.emplace_back(41,42); // does not work [c]
v.emplace_b
浏览 3提问于2013-12-16得票数 21
回答已采纳
我有一节课：
class Foo {
public:
Foo() {}
Foo(const Foo&){cout << "constructed by lvalue reference." <<endl; }
Foo(Foo&& ) {cout << "constructed by rvalue reference." << endl; }
};
然后，我插入一个向量：
Foo foo{};
vf.push_back(foo);
其产出令人惊讶：
constructe
浏览 5提问于2013-08-15得票数 13
回答已采纳
我无法编译以下dont_compile函数。我不明白为什么它不能工作。但是，它确实可以与list一起工作。
class Thing {
public:
Thing() {}
Thing(const Thing &) = delete;
};
int dont_compile(int argc, char ** argv)
{
std::vector<Thing> v;
v.emplace_back();
return 0;
}
int compiles(int argc, char ** argv)
{
std::lis
浏览 18提问于2017-07-02得票数 2
回答已采纳
4回答
我是否可以创建包含不可复制元素的向量，并且在C++11中没有默认构造函数？
示例：
#include <iostream>
#include <string>
#include <vector>
struct value {
value() = delete;
~value() = default;
value(value const&) = delete;
value& operator =(value const&) = delete;
explicit value(int i) :
浏览 0提问于2013-07-30得票数 2
1回答
根据emplace_back的定义，void emplace_back (Args&&... args);是一个可变的模板函数。因此，我写了如下：
#include <vector>
int main()
{
std::vector<int> myvector2(10,0);
myvector2.emplace_back(1,2,3,4,5,6);
}
编译器抱怨：
g++ -std=c++0x stlstudy.cc
‘
Internal compiler error: Error reporting routines re-entered.
浏览 3提问于2013-05-23得票数 5
回答已采纳
这是我在emplace上的简单程序。当我在矢量上使用emplace时，我看到复制构造函数被调用了。但是，当我在set上使用emplace时，我看不到复制构造函数被调用。我在这里漏掉了什么概念？ #include <iostream>
#include <vector>
#include <set>
using namespace std;
class MyData
{
private:
int x;
public:
int getX()
{
return x;
浏览 28提问于2021-07-20得票数 2
我很肯定我以前在这里看到过这个问题，但我在搜索时似乎找不到这篇文章，我也想不起来答案了。
为什么没有emplace或emplace_back的std::string？
我认为这与char的使用无关，因为您可以有一个字符向量，并且在向量中使用一个字符没有问题。
浏览 8提问于2020-03-04得票数 4
回答已采纳
在和中也存在类似的问题，但我认为我们还没有得到明确的答案，所以我重新提出了这个问题。
C++11标准有两种在向量末尾添加新元素的方法，它们是std::vector::push_back和std::vector::emplace_back。
它们之间的区别是std::vector::emplace_back在适当的位置构造对象，而std::vector::push_back基本上复制对象(或原始类型)或将其移动到向量的末尾。
然后，将原始类型添加到std::vector中，std::vector::push_back看起来是更好的选择。例如：
std::vector<int> vVe
浏览 0提问于2017-04-25得票数 7
回答已采纳
我试图创建一个自定义类A的对象向量：
class A {
std::ifstream _file;
std::string _fileName;
public:
A(std::string &fileName) : _fileName(fileName) {
this->_file = std::ifstream(this->_fileName, std::ios::in);
}
~A() {
this->_file.close();
}
};
总的来说，我使用for循环来推A类的n个对象
浏览 4提问于2019-09-21得票数 2
回答已采纳
当存储在容器中时，std::function构造函数到底是做什么的？
在本测试代码中：
struct A {
int sn;
A() = delete;
A(int v) : sn(v) { cout << "A::init(" << sn << ')' << endl; }
A(const A& a) : sn(a.sn+1) { cout << "A::copy(" << sn << ')' <&l
浏览 5提问于2020-10-27得票数 3
回答已采纳
这是一个演示类。我不希望我的类被复制，所以我删除了复制构造函数。我希望vector.emplace_back使用这个构造函数‘MyClass(类型类型)’。但是这些代码不能编译。为什么？
class MyClass
{
public:
typedef enum
{
e1,
e2
} Type;
private:
Type _type;
MyClass(const MyClass& other) = delete; // no copy
public:
MyClass(): _type(e1) {};
浏览 0提问于2016-11-07得票数 15
回答已采纳
在std::vector<>::emplace_back()中引发异常时会发生什么？
例如：
class Foo {
public:
Foo(int bar) {
if (bar == 4) throw std::exception("Something went wrong");
}
}
和
std::vector<std::unique_ptr<Foo>> foo_list;
foo_list.emplace_back(new Foo(3));
try {
foo_list.emplace_back(new Foo(4
浏览 1提问于2016-09-23得票数 5
回答已采纳
我有类"Obraz"，在她的存在向量中需要收集另一个类的对象。我的问题是，当我添加一个"Trojkat“对象时，它会两次调用构造函数。据我所知，这是因为向量增加了论点的副本。有什么办法能解决这个问题吗？因为我只需要一个构造函数调用。
主要部分：
Obraz o;
cin >> menu;
switch (menu){
case 1:
Trojkat t1;
o.dodajTrojkat(t1);
break;
碎片类Obraz：
class Obraz {
private:
vector <Trojkat> li
浏览 5提问于2022-04-11得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
