一些涉及类析构函数和删除运算符的内存管理问题？

Question

在阅读了一些教程后，我仍然不清楚 C++ 中内存管理的一些观点。

1. 当使用 new 运算符声明的类超出范围时，是否会调用其析构函数并释放内存？ 是否有必要调用删除运算符来释放类的内存并调用其析构函数？

class Test{};

void newTest(){
    Test *t = new Test;
}

int main()
{
    newTest();
    return 0;
}

2. 当变量（例如向量）所在的类被销毁时，使用 new 关键字声明的变量（例如向量）是否会被释放？ 这些变量是否必须在类的析构函数中显式删除？

class Test{
    vector<int> *vec;
public:
    Test();
};

Test::Test(){
    *vec = new vector<int>;
}

void newTest(){
    Test t;
}

int main()
{
    newTest();
    return 0;
}

3. 与问题 2 相同，但使用在堆栈上声明的普通变量。 在下面的示例中，当 t 超出范围时，向量 vec 是否被删除？

class Test{
    vector<int> vec;
};

void newTest(){
    Test t;
}

int main()
{
    newTest();
    return 0;
}

4. 最后，在类中声明向量的更好方法是通常（在堆栈上）还是使用 new 关键字（在堆上）？

Answer 1

听起来您可能有 Java 背景，因此 new 在 C++ 中的工作方式有点不同。

1. 用new分配的内存必须用delete显式销毁。此示例存在内存泄漏。

2. 与问题1类似，必须在类析构函数中删除内存才能回收。

3. 在这种情况下，向量将被自动破坏。

4. 在类中，总是更喜欢按值存储成员（而不是使用 new ），除非您有特殊原因要这样做。仅仅因为它在类中按值存储并不意味着它在堆栈上，它与包含类占用的内存区域相同。

最后请注意，在 C++ 中，您可以使用 RAII 来使内存管理更不容易出错。例如，看一下shared_ptr、scoped_ptr 和unique_ptr。这些都会在适当的时候自动释放新分配的内存。

Answer 2

1. 不，析构函数没有被调用，内存也没有被释放。您必须删除该对象。
2. 不，变量没有被释放。您必须在析构函数中删除它们。
3. 是的，vec 被删除（调用析构函数并释放内存）。
4. 如果可能的话，通常在堆栈上更好。例如，如果将对象的所有权传递给另一个对象，则这可能是不可能的。另外，不应在堆栈上分配太多内存（操作系统对此有限制），在这种情况下，应在堆上分配对象。

Answer 3

1. 不会，当指针超出范围时，使用 new 创建的对象不会自动销毁。您需要显式删除任何此类对象。
2. 同样的答案。任何使用 new 分配的内存都必须显式释放。大多数编写良好的类都会在析构函数中为您执行此操作。如果您正在编写该类，请确保清理该类使用的所有内存。
3. 该对象会自动为您销毁。而且，如果写得好，它会自动销毁它分配的任何内存。
4. 大多数类实例应该分配为局部变量，因为这将确保它们被自动清理。但是，如果您全局需要它们或作为类的一部分，则需要适当地声明它们。

Answer 4

您应该更愿意说对象具有动态存储而不是“位于堆上”。同样，使用“自动存储”而不是“在堆栈上”。

前者在标准中实际使用，而后者则更加口语化。

如果一个对象具有自动存储功能，那么当该对象超出范围（在包含块的末尾）时，编译器将自动调用其析构函数。

使用new分配的内存需要显式释放。实际指针的存储将被回收，但它指向的对象不会被回收。

因此，如果您使用new，则需要有一个匹配的delete。 new[] 需要与 delete[] 相匹配。

（“智能指针”非常有用，因为它将帮助您不必跟踪new和delete。查找一下！）。

销毁一个向量（如果分配了新的，则通过删除，或者如果是自动，则当它离开范围时）将调用其元素的析构函数。这就是为什么它应该是我们持有多个物体的首选方式。

结论：

如果可能的话尝试使用智能指针或集合。
否则，请确保删除您新增的内容。 （如果您编写一个类，请在构造函数中分配任何动态成员并在类的析构函数中删除它们。）

Answer 5

1. 当使用 new 运算符声明的类超出范围时，是否会调用其析构函数并释放内存？是否有必要调用delete运算符来释放类的内存并调用其析构函数？

首先是一些术语：

变量要么是对象，要么是指针（类不是用新指针声明的）。
对象超出范围时会自动销毁。
指针不会自动删除。

第二，更喜欢对象而不是指针

void newTest()
{
    Test t;  // t created here and automatically destroyed.
}

第三。如果必须创建一个指针。将其放入智能指针中。

void newTest()
{
    std::auto_ptr<Test> t(new Test());  // t created here and automatically destroyed.
                                        // Which will call delete on the contained pointer.
}

回答问题1：

你声明的指针超出了范围，但内存析构函数没有被调用，内存被泄漏。您需要手动执行此操作（或使用我指出的技术之一）。

1. 当变量所在的类被销毁时，使用 new 关键字声明的变量（例如向量）是否会被释放？这些变量是否必须在类的析构函数中显式删除？

术语

您的意思是用new 初始化的指针，而不是用new 关键字声明

问题2 的答案。

不。您必须在析构函数中手动调用destroy。但类中最好不要有指针。而是在类中声明一个向量对象，然后它将自动销毁。

class Test
{
    vector<int>                   vectorObject;
    std::auto_ptr<vector<int> >   vectorPtrInSmartPointer;
    vector<int>*                  vectorRaw
public:
    Test();
    ~Test();
private:
    Test(Test const& copy);
    Test& operator=(Test const& copy);
};

Test::Test()
   : vectorPtrInSmartPointer(new vector<int>())  // Need to initialize the smart pointer.
   , vectorRaw(new vector<int>)                  // Need to initialize the RAW pointer
{
   // Note the vectorObject was automatically created.
}
Test::~Test()
{
   delete vectorRaw;                             // Need to manually release the RAW pointer.
}
// Smart pointer and object auto released.

笔记：
因为类 Test 包含一个 RAW 指针（向量*），所以我必须手动禁用复制构造函数 Test::Test(Test const&) 和赋值运算符 Test&运算符=（测试常量&）。这是为了确保遵循 3 规则。

1. 与问题 2 相同，但在堆栈上声明普通变量。在下面的示例中，当 t 超出范围时，向量 vec 是否会被删除？

是的。

1. 最后，在类中声明向量的更好方法是通常（在堆栈上）还是使用 new 关键字（在堆上）？

将其称为堆栈/堆会掩盖细节（因为成员可能是动态分配对象的自动成员）。更愿意将它们视为自动变量和动态变量。当自动变量的包含范围被销毁时，自动变量会被自动销毁。所以对于函数变量来说，这意味着当你离开函数时。对于类成员来说，这意味着对象被销毁。选择是更喜欢使用自动变量（即不使用 new 进行分配）。

Answer 6

这两个简单的规则应该可以回答所有问题：

1. 您的代码中的 delete 数量应该与 new 数量一样多。
2. 尽可能从堆栈而不是堆中分配。