组织一个c++；内存中的程序-堆栈和堆 我正在学习C++，想知道这样的程序是如何在主内存中组织的。我知道有一个堆栈（带有stackframes）和一个堆。我知道动态分配某些东西会在堆上分配它。这是由诸如malloc或new之类的操作符完成的。但我不能在小C++程序中看到它们。

该程序由一个主类和一个名为

MyClass

的类组成。这类课程有：

• 一个构造器
• 一个成员变量（

  int

  ）
• 单成员函数

main类定义Myclass的一个对象，并定义指向该对象的指针

那么，这些在记忆中是如何组织的呢

#include <iostream>
using namespace std;

class MyClass {
    int i;
public:
    MyClass(int n) {
        i = n;
    }
    int get_nmbr() {
        return this->i;
    }
};


int main() {
    MyClass myClass(100), *p;
    cout << myClass.get_nmbr() << endl;
    p = &myClass;
    cout << p;
    return 0;
}

#包括
使用名称空间std；
类MyClass{
int i；
公众：
MyClass（int n）{
i=n；
}
int get_nmbr（）{
返回此->i；
}
};
int main（）{
MyClass MyClass（100），*p；
cout
myClass
在堆栈上分配。此程序不使用heap-exept，可能用于在后台分配stdout缓冲区。当
myClass
超出范围时（例如
main
返回或抛出异常时），
myClass
被破坏，堆栈被释放，使得
p
无效

在现代C++中，使用智能指针（如原始指针而不是原始指针）被认为更安全。
要在堆上分配
myClass
，您可以编写：

#include <memory>

int main() {
  std::shared_ptr<MyClass> p (new MyClass (100));  // Two heap allocations: for reference counter and for MyClass.
  auto p2 = std::make_shared<MyClass> (101);  // One heap allocation: reference counter and MyClass stored together.
  return 0;
}

#包括
int main（）{
std:：shared_ptr p（新MyClass（100））；//两个堆分配：用于引用计数器和MyClass。
auto p2=std:：make_shared（101）；//一个堆分配：引用计数器和MyClass存储在一起。
返回0；
}
myClass
在堆栈上分配。此程序不使用heap-exept在后台分配stdout缓冲区。当
myClass
超出范围时（例如
main
返回或抛出异常时），
myClass
被破坏，堆栈被释放，使得
p
无效

在现代C++中，使用智能指针（如原始指针而不是原始指针）被认为更安全。
要在堆上分配
myClass
，您可以编写：

#include <memory>

int main() {
  std::shared_ptr<MyClass> p (new MyClass (100));  // Two heap allocations: for reference counter and for MyClass.
  auto p2 = std::make_shared<MyClass> (101);  // One heap allocation: reference counter and MyClass stored together.
  return 0;
}

#包括
int main（）{
std:：shared_ptr p（新MyClass（100））；//两个堆分配：用于引用计数器和MyClass。
auto p2=std:：make_shared（101）；//一个堆分配：引用计数器和MyClass存储在一起。
返回0；
}
您有myClass对象和指针p（声明为myClass*）在堆栈上创建。所以。在myClass对象中，我也在堆栈上创建了数据成员，作为myClass对象的一部分。指针p存储在堆栈上，但您并没有为p分配，而是将p分配给已经存储在堆栈上的myClass对象的地址。所以，这里没有堆分配，至少是从存储在堆栈上的程序段您发布了。
您有myClass对象和指针p（声明为myClass*）在堆栈上创建。所以。在myClass对象中，我也在堆栈上创建了数据成员，作为myClass对象的一部分。指针p存储在堆栈上，但您并没有为p分配，而是将p分配给已经存储在堆栈上的myClass对象的地址。所以，这里没有堆分配，至少是从存储在堆栈上的程序段您发布了。
让我们一行一行地浏览一下

int main() {

一个新函数从这一行开始，然后是一个新函数

这里发生了两件事。第一，变量
myClass
在函数的作用域内声明，这使其成为局部变量，因此在堆栈上分配。编译器将发出在堆栈上保留足够空间的机器指令（通常通过碰撞
sp
堆栈指针寄存器），然后执行对类构造函数的调用。传递给构造函数的
指针是堆栈分配的基础

第二个变量
p
只是一个本地指针，编译器（取决于优化）可以将该值存储在本地堆栈或寄存器中

   cout << myClass.get_nmbr() << endl;

将
myClass
实例的地址存储在变量
p
中。这是堆栈地址

   cout << p;
   return 0;
}

注意：您可能想看一看，也许是在这个上下文中。
让我们一行一行地看一下

int main() {

一个新函数从这一行开始，然后是一个新函数

这里发生了两件事。第一，变量
myClass
在函数的作用域内声明，这使其成为局部变量，因此在堆栈上分配。编译器将发出在堆栈上保留足够空间的机器指令（通常通过碰撞
sp
堆栈指针寄存器），然后执行对类构造函数的调用。传递给构造函数的
指针是堆栈分配的基础

第二个变量
p
只是一个本地指针，编译器（取决于优化）可以将该值存储在本地堆栈或寄存器中

   cout << myClass.get_nmbr() << endl;

将
myClass
实例的地址存储在变量
p
中。这是堆栈地址

   cout << p;
   return 0;
}

注：你可能想看一看，也许在这个上下文中。
 
首先是第一件事。在C++中，你不应该使用<代码> Malc C < /C> >
在这个程序中，所有使用的内存都在堆栈上。让我们一次看一个：
MyClass myClass(100);

myClass
是堆栈上的一个自动变量，其大小等于
sizeof（myClass）；
。这包括成员
i

MyClass *p;

p
是堆栈上的一个自动变量，它指向
MyClass
的一个实例。因为它没有初始化，所以可以指向任何地方，不应该使用。它的大小等于
sizeof（MyClass*）；
并且它可能（但不一定）放在
MyClass
之后的堆栈上

cout << myClass.get_nmbr() << endl;

这里
cout << p;