Question

假设我们要创建一个包含对象的类/结构，并用它的新实例重复替换该类/结构的对象的指针。

struct foo {
    int a[128];
};

int main() {
    foo* bar;

    for(int i = 0; i < 120000; i++) {
        delete bar;
        bar = new foo();
    }

    return 0;
}

据我所知，该程序有效，并且在删除“ foo”时成功释放了“ a”使用的内存（任务管理器告诉我它使用了大约14.5 MB的RAM）。但是，与其说这样声明，不如说我们需要一个动态对象：

struct FOO {
    int* A;
    FOO() {
        A = new int[128];
    }
};

int main() {
    FOO* BAR;

    for(int i = 0; i < 120000; i++) {
        delete BAR;
        BAR = new FOO();
    }

    return 0;
}

在这种情况下，该程序似乎无法成功释放存储在'A'处的内存（任务管理器告诉我这使用了大约78.1 MB的RAM）。为什么删除BAR的调用无法释放'A'处的内存，并且如何重新配置此代码才能做到这一点？

Answer 1

您缺少的是Foo结构中的析构函数。查看此变体：

struct FOO {
int* A;
FOO() {
    A = new int[128];
}
~FOO()
{
    delete A[];
}
};

int main() {
FOO* BAR;

for(int i = 0; i < 120000; i++) {
    delete BAR;
    BAR = new FOO();
}

return 0;
}

FOO的析构函数现在应该负责删除在构造函数中动态创建的内存。

Answer 2

您需要实现析构函数以释放在构造函数内部分配的内存。但是，在构造函数内部分配内存不是一个好主意，并且有更好的替代方法。
另外，由于要处理指针，因此请确保检查内存分配结果，并在需要时正确分配NULL以及检查删除指针是否安全
注意1：由于使用new分配数组，因此必须使用delete []而不是delete。
注意2：您甚至在分配之前就开始删除BAR。
它至少应该看起来像这样：

    struct FOO {
    int* A;
    FOO() {
        A = new int[128];
    }
    ~FOO() {
         if(A) delete[] A; // use delete[] instead of delete for an array
         A = nullptr;
    }
};

int main() {
    FOO* BAR;
    BAR = new FOO();
    for(int i = 0; i < 120000; i++) {
        if( BAR) {
            delete BAR;
            BAR = nullptr;
        }
        BAR = new FOO();
    }

    return 0;
}

如何在类旁边用“ new”声明的类中删除对象

2 个答案: