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

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 对象中分配的块。不是错误，因为程序结束会释放它们，但这是导致内存泄漏的原因。此外，您在构造函数中有一个手动分配的内存块，但没有显式的复制构造函数或赋值运算符。如果你写：

Arr c = a;

c 和 a 都将共享同一个 CAR 数组，这可能是也可能不是您想要的。

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

Answer 2

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

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

Arr T = *temp

使用成员方式将对象 temp 的数据成员复制到对象 T。对象 temp 的指针 CAR 的值将被复制到对象 T 的指针 CAR 中，并且由于是有效的指针到动态分配对象temp的生命周期。

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