具有unique_ptr成员和自定义析构函数的对象的向量
是指一个存储了具有unique_ptr成员和自定义析构函数的对象的容器。unique_ptr是C++11引入的智能指针，用于管理动态分配的对象，它通过独占所有权的方式来确保资源的释放。自定义析构函数是指在对象销毁时执行特定的清理操作的函数。
这种向量的设计可以用于管理需要动态分配内存的对象，并且希望在对象销毁时执行特定的清理操作。通过使用unique_ptr成员，可以确保在向量销毁或者移除元素时，相关的资源会被正确释放，避免内存泄漏。自定义析构函数可以在对象销毁时执行额外的清理操作，例如释放其他资源或者进行日志记录。
这种向量的应用场景包括但不限于以下几个方面：
- 资源管理：当需要管理动态分配的资源时，可以使用具有unique_ptr成员和自定义析构函数的对象的向量。例如，管理数据库连接、文件句柄等资源。
- 对象组合：当需要将多个对象组合在一起，并且这些对象之间存在一定的关联关系时，可以使用具有unique_ptr成员和自定义析构函数的对象的向量。例如，管理一个图形场景中的多个图形对象。
- 异常安全：当需要确保在发生异常时，相关资源能够正确释放时，可以使用具有unique_ptr成员和自定义析构函数的对象的向量。例如，在函数执行过程中发生异常时，可以通过向量的析构函数来释放已分配的资源，保证程序的异常安全性。
腾讯云提供了一系列与云计算相关的产品，其中包括：
- 云服务器（CVM）：提供弹性计算能力，可根据业务需求快速创建、部署和管理云服务器实例。
- 云数据库MySQL版（CDB）：提供高可用、可扩展的关系型数据库服务，支持自动备份、容灾等功能。
- 云存储（COS）：提供安全、稳定、低成本的对象存储服务，适用于图片、视频、文档等大规模数据存储和分发。
- 人工智能平台（AI Lab）：提供丰富的人工智能算法和模型，支持图像识别、语音识别、自然语言处理等应用场景。
更多关于腾讯云产品的介绍和详细信息，可以访问腾讯云官方网站：https://cloud.tencent.com/
相关·内容
4回答
在我的课堂上，我写道
class Game {
private:
mtm::Dimensions dimensions;
std::vector<Character*> board;
public:
explicit Game(int height, int width):dimensions(height,width), board(height*width){
}
~Game() {}
};
但是我应该如何释放我的向量，我认为如果我保留d‘’tor为空，它会泄漏内存。
浏览 2提问于2020-06-24得票数 0
我很难理解独特指针的行为。如果我在堆上分配一个对象..。
std::unique_ptr<GameState> mMenuPtr(new MainMenu);
然后push()和move()把它放到我的GameState堆栈上，就像.
gameStates.push(std::move(mMenuPtr)); //pointer loses ownership of MainMenu during move
堆栈上的元素是否仍在堆上动态分配？如果是这样的话，结束作用域中堆栈的销毁是否释放了我分配给new的内存，还是需要某种其他方式来销毁该对象以防止内存泄漏？
我知道unique_p
浏览 0提问于2016-09-11得票数 0
回答已采纳
我有一个类，成员变量是std::unique_ptr<double[]>。初始化此变量始终由make_unique<double[]>(size)完成。但是我不知道如何为这个成员变量编写析构函数的代码
我知道std::unique_ptr有一个方法get_deleter()，但当我查看文档时，它只提供了自定义的delete。我对相似的例子做了一些研究。但所有这些都是关于新的className()，而不是make_unique()。
cpp的版本是c++17
我的代码
class test{
public:
test(int size) : size_{size
浏览 1提问于2019-06-29得票数 2
6回答
如果我不使用new来分配类的数据成员，还需要在析构函数中进行清理吗？例如，在下面的例子中，我需要delete向量吗？或者它依赖于MyType
class A {
A();
~A();
MyType x;
std::vector<MyType> v;
};
A::A() {
x = MyType(42);
v = std::vector<MyType>(5);
}
A::~A() {
// what goes here?
}
浏览 0提问于2012-06-14得票数 3
回答已采纳
几个月前我用向量编写了一个程序。我使用clear()成员函数来“重置”向量，假设它不仅会清除元素中的项并重置大小数据成员，而且还会给堆返回以前与它一起使用的内存。嗯，我偶然发现了一篇关于向量的帖子，它说这不是从向量中获取内存的正确方法，因为使用clear()并不能做到这一点，但是需要使用交换方法：
vector<MyClass>().swap(myVector);
我很好奇为什么我们要调用交换来删除旧的记忆？我想这更像是一种解决办法，因为我们使用的是交换，但其他的事情正在发生。正在调用析构函数吗？
最后一个问题，我现在读到的所有文章都说，clear()没有释放那些对象被“销毁”的内
浏览 4提问于2016-08-23得票数 0
回答已采纳
在C++编程语言中，有以下示例(3.2.4节)。
unique_ptr<Shape> read_shape(istream& is);
void user()
{
vector<unique_ptr<Shape>> v;
while (cin)
v.push_back(read_shape(cin));
draw_all(v);
// call draw() for each element
rotate_all(v,45);
// call rotate(45) for each e
浏览 9提问于2020-10-13得票数 2
回答已采纳
如下面的代码所示，我尝试通过从unique_ptr获取的原始指针删除对象。但是，正如输出所示，编译器报告了错误。但是，对于原始指针，我们可以执行这个int *p1 = new int{100}; int* p2 = p1; delete p2;。
此外，我认为unique_ptr通过移动语义来维护它的所有权。由于unique_ptr的get()函数返回原始指针，unique_ptr如何仍然拥有对象的所有权。同时，为什么原始指针没有得到所有权。同时，我也很困惑这是如何实现的。谢谢。
#include <iostream>
#include <memory>
int ma
浏览 12提问于2022-05-05得票数 1
回答已采纳
2回答
我使用的是PIMPL成语，具体而言，我使用的是提供的模板。给定下面的一组类并使用VS2015更新3进行编译，我得到了编译错误：
错误C2027使用未定义类型“C：：C_impl”(编译源文件src\A.cpp)
错误C2338无法删除不完整类型(编译源文件src\A.cpp)
警告C4150删除指向不完全类型‘C：：C_impl’的指针；没有调用析构函数(编译源文件src\A.cpp)
我可以通过取消注释C::~C()来解决这个问题，这使我相信有些东西阻止了~C()的自动生成，但我不明白是什么原因。根据，如果下列任何一项为真，则T类型的析构函数被隐式定义为已删除：
T有一个不
浏览 8提问于2016-07-21得票数 2
回答已采纳
3回答
可能重复：
我知道当一个std::vector被销毁时，它会调用每个项目的析构函数。它是否调用指向对象的指针的析构函数？
vector<myclass*> stuff;
当物品被销毁时，内部指针所指向的单个对象会被破坏吗？
浏览 2提问于2012-02-25得票数 27
4回答
与unique_ptr结合使用
、、、、
当我尝试使用std：：unique_ptr或std::make_unique时，试图在联合中使用一个片段错误。
#include <iostream>
#include <memory>
union myUnion{
struct{std::unique_ptr<float> upFloat;}structUpFloat;
struct{std::unique_ptr<int> upInt;}structUpInt;
myUnion(){}
~myUnion(){}
};
struct myStruct{
浏览 7提问于2014-07-12得票数 20
回答已采纳
假设使用以下代码将类型为A的对象移动到av (向量)中： #include <memory>
#include <vector>
struct A
{
~A() {};
std::unique_ptr<int> an_int;
};
int main(int argc, char* argv[])
{
std::vector<A> av;
av.push_back(A());
return 0;
} 这将无法按原样编译。但是，如果我不实现析构函数~A() {}，它就会工作得很好。编译器提示了一些
浏览 38提问于2020-09-06得票数 2
回答已采纳
4回答
我只是在学习c++，因为我对C和Java都有一定的理解。我不太明白为什么我写的一些代码不会泄漏内存。代码如下：
// Foo.h
class Foo {
private:
std::vector<int> v;
public:
Foo();
virtual ~Foo();
void add_int(int);
}
// Foo.cpp
Foo::Foo(): v () {}
Foo::~Foo() {}
Foo::add_int(int x) {
v.append(x);
}
存储在v中的向量显然在内部存储了一个指向堆分配的内存的指针，该内存需要释放，但我从
浏览 3提问于2013-04-01得票数 2
回答已采纳
std::vector<Object *> pVector;
当超出作用域时，指针数组/向量是否可以自动删除每个指针元素？还是必须手动删除每个对象？
那么，如果我认为:如果向量/数组存储无指针元素，它会自动调用解构函数吗？但是如果存储了指针，它应该手动删除元素吗？
浏览 0提问于2013-05-08得票数 0
8回答
几个小时前，我正在摆弄一个内存泄漏问题，结果发现我真的搞错了一些关于虚拟析构函数的基本东西！让我来解释一下我的类设计。
class Base
{
virtual push_elements()
{}
};
class Derived:public Base
{
vector<int> x;
public:
void push_elements(){
for(int i=0;i <5;i++)
x.push_back(i);
}
};
void main()
{
Base* b = new Derived();
浏览 5提问于2010-04-27得票数 6
回答已采纳
我有一个，它在std::unique_ptr<T>中保存对象。
与大多数池一样，池包含创建成本很高的对象，但是一旦借用了对象，就无法阻止具有相同设置的对象被添加到池中，因此我想对其进行扩展以防止这种情况发生。
我认为这方面有三种选择：
将std::unique_ptr<T>替换为std::shared_ptr<T>，但是没有使用多线程代码的计划，这违反了所有权的约定--池不应该仅仅为了读取它的一个属性而拥有一个对象。
在std::vector中保留一个T属性的副本，当std::unique_ptr<T>被借用并返回到池时，添加和删除std::un
浏览 2提问于2020-08-27得票数 0
回答已采纳
3回答
我有我的定制课程，比如：
class MyClass {
public:
int i;
std:string name;
void DoSomeStuff();
}
和另一个具有自定义类列表的类：
class MyClassList {
public:
std::vector<MyClasss> myClassList;
}
列表析构函数应该如何释放内存中所有使用的向量空间：
MyClassList::~MyClassList
{
myClassList.clear();
del
浏览 1提问于2015-04-28得票数 0
回答已采纳
2回答
我读了霍华德辛纳特()的答案，然后这个答案()，我只是在思考。如果你有这样一个类
class Something {
Something();
~Something();
class Impl;
std::unique_ptr<Impl> impl;
};
在编译类时，unique_ptr将被实例化(正如我从上面的另一个答案中可以看出的那样)。那么，为什么以后不定义类Impl是可以的呢？实例化不需要Impl的析构函数存在吗？
注意事项以下是为了澄清我上面的问题。
当编译器检查类Something的定义时，我就是这么想的。它将看到嵌套类Impl的声明
浏览 2提问于2017-04-13得票数 2
回答已采纳
假设我上了这些课。
Resource.h
template<typename T>
class Resource
{
protected:
// bunch of member variable
std::unique_ptr<T> resource;
public:
Resource();
~Resource();
};
ResourceManager.h
template<typename T>
class Reso
浏览 0提问于2019-03-27得票数 2
回答已采纳
让我们考虑下面的示例(使用c++11)
A.hpp：
#include <memory>
class A
{
public:
//A();
//~A();
private:
struct AImpl;
std::unique_ptr<AImpl> pImpl;
};
main.cpp：
#include "A.hpp"
int main()
{
A a;
}
使用默认构造函数和析构函数。不编译。发生以下错误：
在/usr/include/c++/4.8/内存中包含的文件:81:0，来自A.hpp:2，
浏览 1提问于2014-02-11得票数 10
回答已采纳
7回答
例如，当我不声明构造函数时，编译器将为我提供一个默认构造函数，该构造函数将没有参数，也没有定义(空体)，因此将采用no action。
因此，例如，如果我完成了一个对象，那么该对象使用的默认析构函数不会重新分配(空闲)内存吗？如果没有，我们为什么要得到它？
而且，同样的问题也适用于默认的构造函数。如果它什么也不做，为什么它是默认为我们创建的？
浏览 4提问于2011-01-29得票数 69
编辑：给任何人阅读这个问题以供将来使用:这个错误与unique_ptr没有任何关系。正如JoergB在他的回答中所说的，忘记基类的虚拟析构函数是我的一个错误。
在偶尔的运行时崩溃之后，我发现我的代码遭受了严重的内存泄漏。我运行我的程序与瓦兰，医生似乎同意:字节是绝对失去了。不过，我一辈子都找不出哪里出了问题。
我设法在这三行中确定了泄漏发生的原因：
std::unique_ptr<Operator> pointer(new Operator{"left", "right"});
NodeSpace space; // The node space
浏览 1提问于2013-01-27得票数 1
回答已采纳
7回答
因此，我在C++中的一个类中添加了析构函数。
class object { ~object() };
并使用新方法声明一个对象，从而在堆上分配它
object *pointer = new object;
我是否仍然需要使用
delete(object);
方法在程序的末尾？(析构函数不是已经对此负责了吗？)
浏览 2提问于2016-09-28得票数 0
1回答
这是我第一次在这里发问！我在为单链接列表创建副本构造函数时遇到了一些问题。我在这个网站和其他各种网站上搜索了一个类似的例子，但没有结果。我试图使用智能指针，到目前为止只使用unique_ptr(s)。此函数用于对正在传递的链接列表进行深度复制。到目前为止，我已经尝试了以下几种方法，但是我只得到了一个分段错误。我已经运行了一些测试，我相信我的insert_front()和insert_back()函数运行良好。我确实有指向头部和尾巴的指针，如果这有帮助的话。下面是我尝试过的代码。
Deque::Deque(const Deque& deque2copy){
this ->
浏览 3提问于2016-10-16得票数 1
回答已采纳
5回答
提及
在执行析构函数的主体并销毁体内分配的任何自动对象之后，类X的析构函数将调用X的直接析构函数。成员n3126.pdf 12.4§6
这让我想知道，如果不摧毁成员，那么破坏者有什么用呢？请举例说明
浏览 3提问于2013-05-27得票数 1
回答已采纳
2回答
如果我有
Class A {
int x;
};
Class B {
vector<A> y;
//...
};
我想在B中重载赋值操作符=，使用默认的=运算符就足够了吗？它会在=成员上使用vector的vector操作符吗？
编辑：说我想自己实现类似的东西，所以如果B和k都是b类型，那么b=k就能工作。我需要显式调用向量析构函数来释放b的y成员吗？
会是什么样子？
B& B::operator=(const B& b) {
if (this == &b) {
return *this;
}
y
浏览 2提问于2016-01-03得票数 1
回答已采纳
1回答
我想实现我自己的简单向量类。即使保留内存耗尽，该向量也应支持推送新元素(类型为T)。因此，我需要分配一个新的内存块，将元素复制到它，然后释放旧的内存块。
如果我使用new T[]创建一个内存块，那么我必须使用delete[]释放它，这将使要调用的向量中的每个元素的构造函数。我不想那样做，因为我只想用memcpy()复制旧的向量。
因此，我决定使用new char[]分配内存，并使用新的位置填充数组。当我需要重新分配保留内存时，我只需在该内存块上使用memcpy()，然后使用delete[]释放它。
这是否一个合理的解决办法？
浏览 0提问于2018-09-24得票数 3
回答已采纳
我在c++函数中使用向量向量。
vector<vector<int>> foo
当这个对象超出作用域时，我想自动释放内存。为了做到这一点，我使用以下方法：
unique_ptr<vector<unique_ptr<vector<int>>> foo(new vector<unique_ptr<vector<int>>())
这听起来是对的，还是我不必要地复杂化了？
PS:如果不使用unique_ptr，我想在堆上分配向量。那是
vector<vector<int&
浏览 5提问于2016-10-13得票数 1
回答已采纳
我有点理解这样一个事实:当类的实例超出作用域时，类的包装STL容器将被自动销毁。因此，当类只包装STL容器时，我不必编写析构函数。但是，如果类也必须管理一些指针呢？
比如说，在一些CUDA开发中，我希望有一个类来处理一个设备指针和一个STL容器。
class Image{
private:
float *data_device;
std::array<int, 2> shape;
public:
// some constructors and methods
~Image(){
浏览 1提问于2018-12-21得票数 1
回答已采纳
我正在编写一个具有成员函数的类，这些成员函数接受一些输入文件并生成一个请求流，这些请求流存储在一个类成员中。
但是，一旦测试结束，当执行默认析构函数时，我就会得到一个读访问冲突。我想不出是什么原因。
这是描述这个类的.hpp文件，有人能指出这里的基础知识中的任何缺陷吗？
#include <iostream>
#include <fstream>
#include <vector>
#include <memory>
#include <string>
#include <sstream>
#include <map
浏览 0提问于2016-05-03得票数 1
3回答
中断：--我不认为这是同一个问题--实际上，另一个问题是关于手动调用析构函数的一般问题。这是在创建过程中，在类本身内。仍然想知道当你这样做时会发生什么，如下面的问题所述。
一开始，我认为这很糟糕，真的很糟糕。只需分析构造函数的这段代码(请参阅下面)，这是由两个人编写的，需要将其转换为Delphi对象Pascal。它的行为必须和C版本一样。我不喜欢这种风格，很丑，但没关系。
另一件事是，在代码的两个阶段，它在失败时调用析构函数(我想关闭连接，但是删除时自动调用析构函数，为什么要这样做？)我认为这不是做这件事的方法，或者是在这里错过了什么？
另外，在调用析构函数之后，他们希望抛出一个异常(嗯？
浏览 0提问于2018-06-30得票数 6
回答已采纳
2回答
这是我在pimpl中使用unique_ptr时所看到的一个简化。我选择unique_ptr是因为我真的想让类拥有指针--我希望pimpl指针和类的生命周期是一样的。
无论如何，这是头文件：
#ifndef HELP
#define HELP 1
#include <memory>
class Help
{
public:
Help(int ii);
~Help() = default;
private:
class Impl;
std::unique_ptr<Impl> _M_impl;
};
#endif // HELP
以下是源代码：
浏览 1提问于2012-01-26得票数 62
回答已采纳
4回答
我有一个包含向量成员变量的类。我知道存储在堆栈上的向量会在它们超出作用域时被清除(即内存释放)，但我不确定销毁一个类对象-它包含一个向量成员变量-是否被认为是超出作用域的。
如果不是，那么销毁向量的合适方法是什么？
例如：
class fred {
char *stuff;
vector<int> v;
fred() : stuff(), v() {}
~fred() {
if (stuff) free(stuff);
// now how do I clear up the vector v? Will it
浏览 8提问于2012-06-12得票数 4
我要上下一节课：
State.hpp
...
class Engine;
namespace window
{
class State
{ ... } }
WConsole.hpp
...
class Engine;
namespace window
{
class Console: public State
{ .. } }
WMesssage.hpp
...
class Engine;
namespace window
{
class M
浏览 0提问于2014-01-05得票数 3
回答已采纳
我使用的是windows10上的visual，使用C++。
我正在学习pimpl成语，让我困惑的是，如果没有employee的析构函数，编译器就会产生错误:不能删除不完整的类型。我不明白为什么我需要一个用于员工的析构函数，难道有一个析构函数用于结构驱动还不够吗?因为unique_ptr。
这是一个引入pimpl成语的网站，它说：“由于std::unique_ptr是一个完整的类型，它需要一个用户声明的析构函数和复制/赋值操作符才能完成实现类。”但我仍然不明白，也没有得到多少关于完整类型定义的信息，它说。
employee.h
#pragma once
#include<iostream
浏览 6提问于2021-08-27得票数 1
我试图用绑定一些变量。问题是，当我想要绑定一个unique_ptr向量时，请尝试复制每个条目，这显然会导致编译错误。
error: call to implicitly-deleted copy constructor of 'std::__1::unique_ptr ...
note: copy constructor is implicitly deleted because 'unique_ptr<...>' has a user-declared move constructor
但是在emscripten的文档中，他们说支持unique_ptr。
浏览 10提问于2015-08-04得票数 2
回答已采纳
1回答
在我的简单游戏引擎中，我有一个包含指向实体的指针的向量。为每个实体分配new关键字。为了调用实体上的函数，我使用迭代器，因此在删除实体时，我想我也应该使用迭代器，如下所示：
vector<Entity*>::iterator iter;
for (iter = gameEntitys.begin(); iter != gameEntitys.end();) {
delete (*iter);
++iter;
}
但是我现在有一个可怕的内存泄漏，所有的分析工具都指向delete (*iter);这一行
很明显，有一些错误，但对我来说，删除向量中包含的实体(并清除另一个
浏览 2提问于2012-10-02得票数 4
回答已采纳
2回答
我目前正在为典型的数据结构(如搜索树)编写一个实现。我从B+树开始。
所涉及的课程如下：
template <typename Key, typename Record>
class BPlusNode {
/* ... */
}
template <typename Key, typename Record>
class BPlusINode : public BPlusNode<Key, Record> {
/* ... */
}
template <typename Key, typename Record>
class
浏览 4提问于2014-08-15得票数 2
回答已采纳
3回答
我在一个类中声明了一个结构的向量。我的问题是，我是必须显式地释放由类析构函数中的向量分配的内存，还是在销毁实例时自动释放。同样，我是否必须在类析构函数中包含代码来释放向量的内存。
浏览 3提问于2013-06-24得票数 0
回答已采纳
7回答
隐式析构函数不能处理哪些潜在的内存泄漏？我知道如果你有任何东西存储在堆上，它不会处理它，如果你有一个到文件或数据库的连接，那就需要手动处理。还有别的事吗？比方说，像向量这样的非基数据类型呢？
另外，在显式析构函数中，是否需要销毁原本会被隐式销毁的非堆变量，或者自动处理这些变量？
谢谢
浏览 2提问于2010-05-14得票数 3
回答已采纳
我正在使用libpcap编写一个C++多线程程序。我需要将pcap_open_live函数返回的pcap_t*句柄(每个线程一个)保存为类成员，并且我希望通过使用智能指针的std::vector或至少使用new操作符来完成此操作，以便以后可以在类析构函数中调用pcap_breakloop。
无论我尝试了什么，编译器都会像invalid application of ‘sizeof’ to incomplete type ‘pcap’或forward declaration of ‘pcap_t’ {aka ‘struct pcap’}一样给我带来错误。但是，看起来pcap_t只是struct
浏览 5提问于2021-04-27得票数 1
3回答
我想创建一个C++类，其中一个线程每分钟做一次工作。
首先，我可以将线程定义为变量成员吗？
class my_class
{
public:
my_class()
: my_thread_(task, this)
{
}
~my_class()
{
done_ = true;
}
void run()
{
while(!done_)
{
...do work in the thread...
}
}
private
浏览 3提问于2016-06-05得票数 7
回答已采纳
4回答
这个问题是基于Scott在他的书“更有效的C++”中提供的一个例子。请考虑以下课程：
// A class to represent the profile of a user in a dating site for animal lovers.
class AnimalLoverProfile
{
public:
AnimalLoverProfile(const string& name,
const string& profilePictureFileName = "",
浏览 1提问于2018-01-16得票数 1
回答已采纳
1回答
我正在构建一个循环链表，我想知道do_remove方法是否定义得很好。当我运行这个程序时，它向我展示了它是，然而，我仍然有点困惑，为什么我不需要一个虚拟的destrutor在这种情况下。
是否只有当我想通过派生类的基本指针销毁派生类时才需要虚拟析构函数？
这是否意味着，通过将基类降为派生类，然后调用派生类析构函数，它将始终调用基类析构函数？
do_remove方法中是否存在可能的漏洞？
PS:我需要两个步骤来创建和销毁对象--分配/调用构造函数/调用析构函数/去分配；这就是我目前使用::operator new的原因。
下面是我正在编写的代码的一个独立的示例：
#include <ios
浏览 1提问于2017-12-17得票数 0
回答已采纳
1回答
因此，我在Qt C++中编写了以下代码：
// Post* derives from QObject
Post* post = new Post(this);
QString url;
ParseResult result = parse(url, post); // this function takes a Post* and modifies it
// if result is succesfully parsed
if(result == ParseResult::Success){
// add the post to a std::vector<Post*>
浏览 0提问于2019-08-13得票数 2
回答已采纳
我使用的是视觉泄漏检测器，它说，当我向vector<unique_ptr<Worker>> Workers添加对象时，内存泄漏。
我得到了一个名为Worker的基类，名为私有字段名，还有一个派生类Builder。
这就是我如何向vector Workers添加新对象的方法。
Builder b = Builder(name, stoi(bricks));
Workers.push_back(make_unique<Builder>(b)); // this is the line with memory leak
在这种情况下，你能告诉我如何
浏览 2提问于2016-01-20得票数 0
回答已采纳
以下代码编译的当且仅当我删除Foo的自定义析构函数。
struct Foo {
std::unique_ptr <int> bar;
~Foo (void) {} // This Line
};
std::vector <Foo> foos;
foos.push_back (Foo ());
以下是我对这种情况的理解：
它失败了，因为unique_ptrs不能被复制，而且std::vector::push_back (thing)调用thing's复制构造函数。如果我编写Foo --一个显式移动bar的自定义复制构造函数，那么一切都会好的。
但是
浏览 8提问于2014-03-01得票数 4
回答已采纳
我试图用unique_ptr作为pimpl的成语。因此，我在类中声明一个析构函数，这样unique_ptr删除就不会在未定义impl类的地方实例化，然后在另一个文件中定义它。
这是我的布局：
包装。h：
#pragma once
#include <memory>
struct Wrapper
{
class Impl;
~Wrapper();
std::unique_ptr<Impl> _impl;
};
wrapper.cpp：
#include "wrapper.h"
class Wrapper::Impl {};
Wr
浏览 6提问于2021-08-20得票数 2
回答已采纳
2回答
我在cppreference.com上找到了这段代码。这是我见过的最奇怪的C++，我对此有几个疑问：
union S
{
std::string str;
std::vector<int> vec;
~S() {}
};
int main()
{
S s = { "Hello, world" };
// at this point, reading from s.vec is undefined behavior
std::cout << "s.str = " &l
浏览 2提问于2017-09-21得票数 5
在C++中，依赖本地对象按照构造的反向顺序进行销毁是一种糟糕的做法，还是应该在析构函数中以反向顺序显式地删除它们，以确保其遵循该顺序？
是的，你们是对的，问题本身就很糟糕。
因此，基本上这是一个场景：
class A {
private:
unique_ptr<Something> firstP;
unique_ptr<Something> secondP;
};
在某种程度上，firstP和secondP都会得到他们需要拥有的东西。我需要的是确保当A被破坏时，firstP会在第二P之后被销毁，所以firstP拥有的东西比secondP拥有
浏览 11提问于2015-08-12得票数 2
回答已采纳
假设我有两个类，名为classA和classB。我创建一个指向classA的指针，然后使用新操作符动态分配一个对象，如下所示：
classA *ptrA = new classA
classA有一个指向classB的类型指针的成员，在它的默认构造函数中，它按如下方式在堆中分配一个classB类型对象数组：
memberOfA = new classB[10]
更复杂的是，classB有一个int*类型的成员变量，在其默认构造函数中，它将堆上的整数数组归纳为如下所示：
memberOfB = new int[100]
现在，如果我使用ptrA调用delete ptrA上的delete，编译器将如
浏览 1提问于2015-10-08得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
云直播
对象存储活动推荐
腾讯云开发者
