C++ 清空对象的最佳方法是什么？

假设我有以下代码（这只是一个示例，显然不实用）：

std:：列出对象；
对象cur_对象；
对于（int i=0；i<11；i++）{
开关（一）{
案例0：
cur_object.foo=true；
打破
案例5：
案例10：
对象。推回（当前对象）；
Object cur\u Object；//有问题的行
打破
违约：
cur_object.bar=i；
打破
}
}

为下一个过程“重置”当前对象的最有效方法是什么。例如，我不相信

cur\u object=*new object

是正确的。类最好有一个重置方法吗

解决方案：

---

在查看perf后，我的用例中建议的方法非常接近，都在0.5%的范围内，但是公认的答案是

对象。emplace_back（）

方法是最有效的。

只需将额外的对象放在列表的末尾，就可以完全避免这种情况：

std::list<Object> objects;
objects.emplace_back();    // temporary object is at the end of objects

for(int i = 0; i < 11; i++){
    switch(i){
        case 0:
            objects.back().foo = true;
            break;
        case 5:
        case 10:
            objects.emplace_back(); // current becomes stored, add new temporary
            break;
        default:
            objects.back().bar = i;
            break;
    }
}

objects.pop_back(); // get rid of temporary

std:：列出对象；
objects.emplace_back（）；//临时对象位于对象的末尾
对于（int i=0；i<11；i++）{
开关（一）{
案例0：
objects.back（）.foo=true；
打破
案例5：
案例10：
objects.emplace_back（）；//当前已存储，添加新的临时
打破
违约：
objects.back（）.bar=i；
打破
}
}
objects.pop_back（）；//除掉临时的

---

pop_back

非常便宜，在整个集合中只执行一次应该不会有问题，而且您不必担心将临时对象移动到列表中并重置它。

您可以使用placement new在旧对象的存储中构造新对象。但是，要处于行为的定义端，需要将

curObject

转换为指针：

char storage[sizeof(Object)];    //this is where we will store the object
Object* curObject = new(storage) Object();    //construct an Object within the storage

...

curObject->~Object();    //explicitly call destructor to tear down the old object
curObject = new(storage) Object();    //the storage can be reused now

---

这种方法的优点是，即使在

对象

的赋值运算符被删除时，它也能工作。

@churill-Nope，在重置

对象之前，它会在循环的多个迭代中使用。push_back（std:：move（cur_Object））

-但这取决于

对象

是否支持移动语义将起作用。（在一些罕见的情况下，您可能需要将其拼写为

cur_object=object{}；

或

cur_object=object（）；

）@Aidan注意，除非您使用一对额外的大括号，否则大小写不会构成一个全范围的块。@AidanWelch哇哦，对了，那么

cur_object={}

可能就是得到它的方法

cur_object=*新对象

也可以工作（从某种意义上讲），但会泄漏内存。这会影响效率，还是更重要的是易读性问题？@AidanWelch可能会，也可能不会-这取决于对象的数量、对象本身和其他因素。但是，此解决方案消除了“重置”对象的需要，这正是您所要求的。对象的数量可能会低至数万个，并且只有几个属性，所有字符串。如果是“低至数万个”，您为什么还要关心这里的性能？毕竟，您使用的是

std:：list

。您是否对现有解决方案进行了分析/衡量？@AidanWelch“永远”通常被定义为

O（n^2）

和

O（n）

之间的差异，而不是

O（n）

和

O（n*k）

，其中

k

是您的优化。