Question

我刚才有一个关于堆栈变量与堆变量如何工作的快速问题。据我了解，堆栈变量是函数返回后的变量，并且堆变量是持久的。但我真正感到困惑的是如何在函数内部分配堆变量：

int MyObject::addObject(const char* a){
    MyObject newObject(a);
    return 0;
}

假设我有MyObject的构造函数newObject(const char * a)。然后在这个函数中调用它时，返回后新构造的newObject被删除了吗？如果是，那么如何在函数内分配到堆呢？如果没有，你如何在以后清理你的记忆？

此外，析构函数的作用到底是什么时候？

Answer 1

类MyObject的构造函数是MyObject()，而不是newObject()。在您的示例中，newObject是变量的名称，而不是构造函数。

要在函数内的堆上进行分配，需要调用new运算符：

int MyObject::addObject(const char* a){
    MyObject* newObject = new MyObject(a);
    //newObject is allocated on the heap

    //... Some more code...

    delete newObject;
    //you have to explicitly delete heap-allocated variables
    //if not, you get memory leaks
    return 0;
}

您的代码：

MyObject newObject(a);

创建一个名为MyObject的自动存储（堆栈）newObject，直到声明的范围结束 - 即关闭}。

此外，析构函数的作用到底是什么时候？

清理内存分配了new或new[]（或malloc）并拥有的类。当对象超出自动对象的范围时，或者为动态对象显式调用delete时，都会调用它。

Answer 2

堆栈内存就是你所说的，但更具体地说，它是当前作用域的本地内存。请注意，根据您所讨论的范围，此内存可以是全局的，也可以是函数或类的本地内存。一旦它们超出范围，它们就会被清理干净。

通过new运算符分配的堆内存。即使在指向内存的所有指针都超出范围之后，它们仍将保留在内存中。您必须通过delete在C ++中自己显式释放此内存。除非使用智能指针，否则不会这样做会导致内存泄漏。

另外需要注意的是，请使用以下示例代码：

void foo()
{
   int *bar = new int; //creates a pointer to an int on the stack, but initializes an int on the heap
   *bar = 3; //sets the int being pointed to to 3
   delete bar; //deletes the int
   bar = 0; //removes the now invalid reference
}

在堆栈上创建指针本身bar。但是，bar指出的数据。 *酒吧 - 是的，星号在这里确实有所作为。它可以获取指针指向的数据 - 在堆上。当foo返回时，bar将超出范围。如果我没有调用删除，我将失去对* bar的访问权限并且会出现内存泄漏。

对于第二个问题，dtor的作用是清理你构造的对象。默认为您提供一个，但有时您需要编写自己的。例如，如果您的类中包含原始指针，则需要在dtor中使用delete显式释放它们。当对象超出堆栈内存的范围并且为堆内存调用delete时调用它。

Answer 3

int addObject(const char* a){
    MyObject newObject(a);
    return 0;
}

此代码在堆栈上分配newObject。在进入函数时构造它（在一堆堆栈内存上调用MyObject构造函数）。当函数在从堆栈弹出内存块之前返回时，它被破坏（MyObject析构函数调用该实例）。

MyObject *foo =  new MyObject(a);

此代码在堆上分配对象。构造函数在分配了一些堆内存后由new运算符调用。内存未被释放，并且在您使用delete关键字明确表示已完成后，不会调用析构函数。

delete foo;

这可以是您在计划中想要的任何地方。

Answer 4

堆栈是在函数和方法调用中使用的区域。它基本上用于存储参数和函数本地数据（以及调用函数的过程中涉及的其他内容）。堆栈是一种LIFO类型的数据结构，这意味着您放入的最后一件事就是您从中获得的第一件事。
另一方面，堆是一个免费存储，我的意思是你可以从堆中获取任何值，无论它放在那里的顺序 - 这种区别很重要。
在C ++中，每次调用new时，都会在Heap上创建对象并返回指向该对象的指针，然后您可以使用该指针访问您的对象。这适用于复杂的对象，例如来自你或其他人创建的类的对象，以及内置类型，如int，char，double等......使用new没有什么神奇之处，在它的核心只是调用{{ 1}}，或者根据平台的某种风格，然后调用对象的构造函数。您必须记得为使用malloc创建的每个对象致电delete（或delete []p_array_of_object_pointers）。
析构函数只不过是在代码中执行new时语言调用对象的函数。析构函数使您有机会在代码中进行一些清理。在C ++这样的语言中，您必须管理自己的资源，通常用它来调用您在堆上分配的其他对象上的delete my_object_pointer或delete，或关闭文件句柄。用fopen或者这样创建......
这两个关键字都在函数和方法的内部或外部工作，无论你在何处调用它们，它们都将始终与堆一起工作。您在不使用free的情况下创建的任何内容将最终出现在其他位置，可执行文件的静态区域或堆栈，具体取决于创建的方式和位置。
每次使用以下语法new在不使用MyClassType myObject(contructor, arguments);的情况下在方法或函数内创建对象时，都会在堆栈上创建它（除非您将其声明为静态，即它在我上面提到的静态区域结束时。）

希望这有帮助。

Answer 5

堆分配使用new关键字

完成

C ++没有垃圾收集，永远不会自动释放堆分配

您可以使用delete关键字

释放它们

你需要保留一个指针，例如通过从函数返回它，或者将它指定给一个全局变量

析构函数在delete上调用，用于释放资源，例如网络套接字

所以代码就是，例如return new MyObject("foo");

Answer 6

在示例中，您可以在堆栈中分配内存。它是自动变量，它将被删除然后返回发生。如果您使用new关键字，则必须提供正确的解除分配

MyObject* newObject = new MyObject(a);

Answer 7

如何分配到堆：使用new关键字

如何从堆中释放：使用delete关键字。

为避免程序崩溃和内存泄漏，每个new必须与指定对象和类型的delete对应。

当对象被删除时，无论其存储位置如何（堆，堆栈......）

，都会调用析构函数

这里有关于记忆的更具体的信息：What and where are the stack and heap?

Answer 8

在以下情况下使用动态分配的对象实例：

1）在编译时不知道对象的实际类型 2）当您要创建的对象数在编译时未知 3）当（编译器生成的）对象的生命周期管理不符合您的需求时。

使用new运算符创建的每个对象都应该在某个时候使用delete运算符释放。如果不这样做，您将有内存泄漏，如果您依赖于对象析构函数的副作用，您将不会得到这些副作用，并且您的程序可能无法执行所需的操作。

当一个对象被创建为堆栈变量时，编译器将插入代码以在对象超出范围时调用对象析构函数。编译器如何知道要调用的析构函数？对象的类型在编译时是已知的，因此只有一个可能性，只有一个析构函数可以调用。

如果使用'delete'来销毁对象，编译器可能无法分辨使用哪个析构函数。对象可以是'basic'类型，然后将调用析构函数'basic :: ~basic（）'。

    class basic;
    class derived : public basic
    {
           ....
           ~derived();
    }

    basic *l = new derived();
    ...
    delete l;

编译器不知道对象的实际类型不是“基本”而是“派生”。但是，如果将“基本”的析构函数声明为 virtual ，则编译器将插入查询对象虚拟方法表的代码，并将调用重定向到正确的析构函数（在本例中为析构函数）破坏“派生”类型的对象。

如果您担心此问题，并且如果可以，请将析构函数设置为“虚拟”。

Stack vs Heap C ++

8 个答案: