Question

我希望专家审核以下动态内存分配过程，并建议是否存在任何内存泄漏。下面的代码不是真正使用的代码，而是尝试以不同的方式理解内存分配和解除分配的概念。

class ObjMapData
{
private:
int* itsMapData;
........
public:
ObjMapData();
~ObjMapData(){if(itsMapData!= NULL) delete[] itsMapData;}
ClearMemory() {if(itsMapData!= NULL) {delete[] itsMapData; itsMapData= NULL}}
.......
void SetMapData(int* ptrData) { itsMapData = ptrData;} // or should I use int*&ptrData??
int* GetMapData() const { return itsMapData;}
}

现在我可以在没有任何内存泄漏的情况下执行以下操作吗？

bool Function1(ObjMapData& objMyMap)
{
//populate the ptrData with some data values using many different ways
int* ptrData = new int[1000]; // usually a variable from binary file header

......................
objMyMap.SetMapData(ptrData);
//don't want to delete the memory yet
return true;
}

bool Function2(ObjMapData& objMyMap)
{
int* ptrData = objMyMap.GetMapData();
//do some work such as writing updated data into a binary file
}

bool Function3(ObjMapData& objMyMap)
{
//populate the data
bool bStatus = Function1(objMyMap);

int* ptrData = objMyMap.GetMapData();
//update the map data using ptrData variable
..........
bStatus = Function2(objMyMap); // write data to a binary file
objMyMap.ClearMemory(); // not real code  in use, but for understanding the concept
bStatus = Function1(objMyMap); // re-allocate memory
ptrData = objMyMap.GetMapData();
//update the map data using ptrData variable
objMyMap.SetMapData(ptrData); // Do I need to set again or member pointer get updated automatically?
return true
}
int main()
{
ObjMapData objMyMap;
bool bStatus = Function3(objMyMap);
//default destructor of objMyMap can take care of the allocated memory cleanup
return 0;
}

感谢您抽出时间确认动态内存分配..

Answer 1

虽然这似乎与 style 有关，而不是关于内存泄漏的问题，但我会在类中私下处理数据：

class ObjMapData
{
private:
int* itsMapData;
// consider adding 'datasize' member variable   
........
public:
ObjMapData(){ itsMapData=NULL; }; // initialise member variable(s)!
~ObjMapData(){ delete[] itsMapData;}
ClearMemory() { delete[] itsMapData; itsMapData=NULL; }
.......
void CreateMapData(int size) { ClearMemory(); itsMapData= new int[size]; }
void FillDataFrom( ???? ) { ???? };
int* GetMapData() const { return itsMapData;}
}

通过添加复制构造函数和赋值方法，您可以更好地改进类，将在使用类时防止内存泄漏。

修改 的你问：

我关注的是以下哪项是正确的：无效 SetMapData（int * ptrData）Vs void SetMapData（int *＆amp; ptrData）

两者都是“正确的”，因为它们都允许在类中复制和使用外部（对类）指针 - 就“内存泄漏”而言，它取决于您要管理的代码部分你分配的记忆。你可以：

在内部进行类处理分配/解除分配

分配内存，使用某些类来操作它，在类
之外释放内存
让一个类分配内存，然后在类外部取消分配

分配内存并让某些类操作并释放它。

通常我发现1和2比3或4更有意义，即更容易理解正在发生的事情，不太可能隐藏错误等等。

然而，就“泄漏内存”而言：指向已分配内存块的指针位置，复制，分配或引用的方式无关紧要 - 它的值是一个重要的内存地址。因此，只要您new和delete内存正确地解决，您就不会泄漏内存（无论这些操作是否在类中）。

如果在你的应用程序中，你需要在你的类外部分配/解除分配int数组，那么对于成员函数 reference 指针来说它确实是有意义的，作为对读者的暗示class不对其释放负责 - 但是一些体面的评论应该清楚地表明：）

这些年来，由于错误处理了分配内存的“所有权”（对于很好的“C”来说更是如此），我遇到了许多错误，其中一些代码已被编写，假设它具有释放一个块或其他人会这样做。

这是回答你的问题还是我错过了这一点？

C ++在一个函数中分配动态内存并清除另一个函数

1 个答案: