C++ C++；对象向量的内存管理

我有一些关于向量的内存管理工作原理的问题/示例

    vector<int> vec1(10);
    vector<int> vec2(10);        
    vec1 = vec2;

vec1（10）；
向量vec2（10）；
vec1=vec2；

在这种情况下，vec1的旧内存现在无法访问。这仍然是内存泄漏还是vec2的旧内存意识到没有引用它并得到清理

在另一个例子中

struct foo
{
   vector<int> foo_vec(50);
   int* arr; 
}


void myFunction()
{
   vector<foo> vec(10);
   vec[0].arr = new int[50];
   vec.erase(vec.begin());
}

structfoo
{
矢量foo_vec（50）；
int*arr；
}
void myFunction（）
{
载体vec（10）；
vec[0].arr=new int[50]；
向量擦除（vec.begin（））；
}

由于我在包含arr和分配内存的第一个向量元素上使用了

erase（）

，因此

erase（）

是释放该内存还是需要在擦除之前手动释放它？另外，当

vec

超出范围时，

vec

中的所有

foo_-vec

向量是否都会自动清理？谢谢你的帮助

当然会被清理的

否，如果

foo

的

destructor

不执行此操作（或者如果在擦除之前未手动执行此操作）

当然会被清理的

否，如果

foo

的

destructor

不执行此操作（或者如果在擦除之前未手动执行此操作）

erase（）是释放内存还是需要在擦除之前手动释放内存

规则：总是对每个

新的
使用
删除
向量
并不是什么魔法-它不知道您是如何获得该指针的，所以它不会删除它，您需要这样做

此外，当vec超出范围时，vec中的所有foo_vec向量是否都会自动清理

是的，它们的析构函数被调用，它们被释放。但是，如果析构函数不
delete[]arr


顺便提一下，一条好建议：您的代码违反了封装。您应该分别在析构函数和构造函数中分配（
new
）和释放（
delete[]
）由
foo:：arr
指向的内存（
foo:：foo（）
和
foo:~foo（）
）

最后，一个必须回答的问题：为什么
foo:：arr
不是
向量本身

erase（）是释放内存还是需要在擦除之前手动释放内存

规则：总是对每个
新的
使用
删除
向量
并不是什么魔法-它不知道您是如何获得该指针的，所以它不会删除它，您需要这样做

此外，当vec超出范围时，vec中的所有foo_vec向量是否都会自动清理

是的，它们的析构函数被调用，它们被释放。但是，如果析构函数不
delete[]arr


顺便提一下，一条好建议：您的代码违反了封装。您应该分别在析构函数和构造函数中分配（
new
）和释放（
delete[]
）由
foo:：arr
指向的内存（
foo:：foo（）
和
foo:~foo（）
）

最后，一个必须回答的问题：为什么
foo:：arr
本身不是
向量呢？

vector<int> vec1(10);
vector<int> vec2(10);        
vec1 = vec2;

通常情况下，为了让事情变得更简单，您要做的是使用智能指针，如unique指针（或例如boost:：shared_array/scoped_array）。当向量超出范围或删除向量时，将自动调用delete（或delete[]）

struct foo
{
   std::vector<int> foo_vec(50);
   std::unique_ptr<int[]> arr; 
}
...
vec[0].arr.reset(new int[50]);
vec[0].arr[12] = 42;
...
vec.erase(vec.begin());    // this will call delete[] on vec[0].arr

structfoo
{
std:：vector foo_vec（50）；
std：：唯一的ptr arr；
}
...
向量[0].arr.reset（新的整数[50]）；
vec[0].arr[12]=42；
...
向量擦除（向量开始（））；//这将调用vec[0]上的delete[]。arr
在以下情况下：

vector<int> vec1(10);
vector<int> vec2(10);        
vec1 = vec2;

通常情况下，为了让事情变得更简单，您要做的是使用智能指针，如unique指针（或例如boost:：shared_array/scoped_array）。当向量超出范围或删除向量时，将自动调用delete（或delete[]）

struct foo
{
   std::vector<int> foo_vec(50);
   std::unique_ptr<int[]> arr; 
}
...
vec[0].arr.reset(new int[50]);
vec[0].arr[12] = 42;
...
vec.erase(vec.begin());    // this will call delete[] on vec[0].arr

structfoo
{
std:：vector foo_vec（50）；
std：：唯一的ptr arr；
}
...
向量[0].arr.reset（新的整数[50]）；
vec[0].arr[12]=42；
...
向量擦除（向量开始（））；//这将调用vec[0]上的delete[]。arr
噢，这些只是我编出来帮助我更好地理解的示例，而不是我正在编写的实际代码。噢，这些只是我编出来帮助我更好地理解的示例，而不是我正在编写的实际代码。如果
vec1
和
vec2
由结构组成怎么办？那会有内存泄漏吗？这要看情况而定。当你把东西放到一个向量中时，你需要决定谁拥有这些实例。如果
vec1
和
vec2
由结构组成怎么办？那会有内存泄漏吗？这要看情况而定。当你把东西放到一个向量中时，你需要决定谁拥有这些实例。