返回从函数内的新结构创建的结构

Question

在这段代码中，函数返回的结构中的数组指针是否指向与新结构定义的内存块？

#include <iostream>
#include <math.h>
struct Arr
{
const int Col;
const int Row;
double* CAR{ new double[Col * Row] };
Arr(int y, int x) : Col(x), Row(y) {}
void Del() { delete[] CAR; }
int Indx(int y, int x) { return (x + y * Col); }
int Size() { return Col * Row; }
void Print(std::string title);
};
void Arr::Print(std::string title)
{
std::cout << title << 'n';
for (int I = 0; I < Row; I++)
{
for (int In = 0; In < Col; In++)
{
std::cout << CAR[Indx(I, In)] << " / ";
}
std::cout << 'n';
}
}
const Arr retfunc(std::string h, Arr& a, Arr& b)
{
Arr* temp = NULL;
if (h == "Had") 
{
temp = new Arr(a.Row, a.Col);
for (int I = 0; I < a.Row; I++)
{
for (int In = 0; In < a.Col; In++)
{
temp->CAR[temp->Indx(I, In)] = a.CAR[a.Indx(I, In)] * b.CAR[b.Indx(I, In)];
}
}
} Arr T = *temp; return T;
}
int main()
{
int val = 5;
Arr a(2, 2);
Arr b(2, 2);
for (int I = 0; I < 2; I++)
{
for (int In = 0; In < 2; In++)
{
a.CAR[a.Indx(I, In)] = 10.0 / val + In;
b.CAR[b.Indx(I, In)] = 8.0 / val + In;
}
}
a.Print("a");
b.Print("b");
Arr S = retfunc("Had", a, b);
S.Print("S");   
S.Del();
}

那么，本质上，在S上调用delete是否会清除在retfunc中分配的相同内存？

Answer 1

您应该在retfunc的末尾有一个return *temp，它被声明为返回Arr对象。一旦解决了这个问题，S.Del()就正确地释放在retfunc中分配的存储器块。

然而，这是一个可怕的代码。您无法释放在a和b对象中分配的bloc。这不是一个错误，因为程序结束时会释放它们，但这会导致内存泄漏。此外，构造函数中有一个手动分配的内存块，但没有显式的复制构造函数或赋值运算符。如果你写：

Arr c = a;

c和a将共享相同的CAR阵列，这可能是您想要的，也可能不是您想要的。

长话短说，我认为这不是一个明显的错误，但至少是一个反模式。

Answer 2

对于初学者来说，函数retfunc存在内存泄漏，因为函数中动态分配的对象temp没有释放。

由于该类没有显式复制构造函数，因此在该声明中

Arr T = *temp

使用对象temp的数据成员到对象T的按成员复制。对象temp指针CAR的值将被复制在对象T的指针CAR中，并且由于动态分配的对象CCD_。

当在一个类中有动态分配的内存时，你需要写一个显式析构函数，为左值和右值复制构造函数，为右值和左值复制赋值运算符。