关于C++的基本问题内存管理

Question

// main.cpp

class Cat()
{
public:
     Cat()
     {
          a = 0;
          (*b) = 0;
     }

     int a;
     int* b;
};

int main(int argc, char* argv[])
{
     Cat cat1;
     Cat* cat2 = new Cat();
     return 0;
}

通常我不关心内存，但我想清楚地了解， cat1 和 cat2 的 a 和b 存在吗？在栈中还是在堆中？

@BoPerson：你是对的，我应该使用b = new int(0)。但对我来说更有趣的是，当对象 Cat 在堆中创建时，变量 a 在哪里？ a 也在堆中吗？堆中的指针 b 也指向堆中的内存，对吗？

Answer 1

让我就地注释和回答。

class Cat()
{
public:
     Cat()
     {
          a = 0; // ok: sets the variable a, wherever it lives
          (*b) = 0; // not ok: stores an integer 0 to wherever b points
                    // since b was never initialized to anything, it can write
                    // anywhere you can imagine. If you are lucky, your compiler
                    // implicitly initializes the pointer to zero such that you
                    // at least get a deterministic segmentation violation.
     }

     int a; // an integer variable living wherever Cat gets constructed
     int* b; // a pointer variable living wherever Cat gets constructed pointing 
             // to wherever it gets set to (b = something) could be heap, stack, 
             // mapped memory, out-of-control (like here)
};

int main(int argc, char* argv[])
{
     Cat cat1; // allocates cat1 on the stack, all attributes (a and b) live 
               // there. Where cat1.b points to is unrestricted.
     Cat* cat2 = new Cat(); // allocates an object of class Cat on heap, 
               // allocates a pointer variable cat2 on the stack and stores the 
               // pointer to said heap-allocated Cat in it
               // again, where cat2.b points to is unrestricted.
     return 0; // maybe never reached due to segfault ;-)
}

正如您在标题中提到的内存管理：当堆栈变量超出范围时，它们会自动被破坏。即cat1和cat2占用的空间（一个Cat，一个指针）在离开main()时会被回收。另外，对于 cat1，将调用析构函数。在您的情况下，没有显式析构函数，但如果 Cat 具有带有析构函数的属性，则会自动生成自动析构函数。

对于指针来说，当指针被破坏时，所指向的对象不会自动被破坏。如果你想要这样，你应该看看像 std::auto_ptr<> 这样的智能指针。 （或 Qt 中的 QScopedPoiner），它为您提供一个类似指针的对象，当 auto_ptr 被破坏时，它确实会破坏所指向的对象（通过调用它的 delete ）。

当不使用智能指针时，您需要注意使用删除运算符手动销毁指向的对象。请注意在当前作用域的每个返回路径上执行此操作（例如多次返回、引发异常）。

Answer 2

new 关键字将对象分配到堆中。虽然您的第一个示例将内存分配给堆栈。

Cat cat1; //stack

Cat* cat2 = new Cat(); //heap

堆栈内存不像堆内存那样容易获得。基本上，您将内存与 new 一起存储在堆上，并将该地址存储在指针中。

堆上的内存也可以被删除。使用“删除”命令。这使得你的程序运行更有效。

我是否遗漏了任何关键指针？

编辑：不再使用时应删除堆上的内存，不仅仅是为了提高效率，也是为了避免程序膨胀。 （内存泄漏）- 谢谢@Felice Pollano

Answer 3

cat1 分配在堆栈上。该类为 8 个字节（如果您的平台上的整数和指针为 4 个字节）。前4个字节是整数a。第二个4字节是整数b。

cat2 分配在堆内存中。否则与上面完全相同。

堆栈变量是“有作用域的”。这意味着当堆栈帧被弹出（即退出函数）时，它被释放并调用其解构函数。

另一方面，堆变量将一直保留，直到您“删除”内存为止。

另请注意，您的构建格式错误。 “*b”取消引用指针（即也获取指针指向的数据）。然后分配 0。出现的问题是 b 没有指向任何确定的内存，因此您将 0 写入可能不在进程地址空间中的未知内存位置。我本以为你的意思是“b = NULL;”