C++ 内存中的堆和栈，在堆和栈上创建对象，new、delete_在栈上new一个对象

概念来源

1 栈

栈由操作系统自动分配释放 ，用于存放函数的参数值、局部变量等，其操作方式类似于数据结构中的栈。

int main() {
    int b;              //栈
    char s[] = "abc";   //栈
    char *p2;           //栈
}
1
2
3
4
5

其中函数中定义的局部变量按照先后定义的顺序依次压入栈中，也就是说相邻变量的地址之间不会存在其它变量。栈的内存地址生长方向与堆相反，由高到低，所以后定义的变量地址低于先定义的变量，比如上面代码中变量 s 的地址小于变量 b 的地址，p2 地址小于 s 的地址。栈中存储的数据的生命周期随着函数的执行完成而结束。

2 堆

堆由开发人员分配和释放， 若开发人员不释放，程序结束时由 OS 回收，分配方式类似于链表。

int main() {
    // C 中用 malloc() 函数申请
    char* p1 = (char *)malloc(10);
    cout<<(int*)p1<<endl;       //输出：00000000003BA0C0
    // 用 free() 函数释放
    free(p1);
    // C++ 中用 new 运算符申请
    char* p2 = new char[10];
    cout << (int*)p2 << endl;       //输出：00000000003BA0C0
    // 用 delete 运算符释放
    delete[] p2;
}
1
2
3
4
5
6
7
8
9
10
11
12

其中 p1 所指的 10 字节的内存空间与 p2 所指的 10 字节内存空间都是存在于堆。堆的内存地址生长方向与栈相反，由低到高，但需要注意的是，后申请的内存空间并不一定在先申请的内存空间的后面， 即 p2 指向的地址并不一定大于 p1 所指向的内存地址，原因是先申请的内存空间一旦被释放，后申请的内存空间则会利用先前被释放的内存，从而导致先后分配的内存空间在地址上不存在先后关系。 堆中存储的数据若未释放，则其生命周期等同于程序的生命周期。

关于堆上内存空间的分配过程，首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆节点，然后将该节点从空闲节点链表中删除，并将该节点的空间分配给程序。另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确地释放本内存空间。由于找到的堆节点的大小不一定正好等于申请的大小，系统会自动地将多余的那部分重新放入空闲链表。

3 堆与栈区别

堆与栈实际上是操作系统对进程占用的内存空间的两种管理方式，主要有如下几种区别：

（1）管理方式不同。栈由操作系统自动分配释放，无需我们手动控制；堆的申请和释放工作由程序员控制，容易产生内存泄漏；

（2）空间大小不同。每个进程拥有的栈的大小要远远小于堆的大小。理论上，程序员可申请的堆大小为虚拟内存的大小，进程栈的大小 64bits 的 Windows 默认 1MB，64bits 的 Linux 默认 10MB；

（3）生长方向不同。堆的生长方向向上，内存地址由低到高；栈的生长方向向下，内存地址由高到低。

（4）分配方式不同。堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是由操作系统完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由操作系统进行释放，无需我们手工实现。

（5）分配效率不同。栈由操作系统自动分配，会在硬件层级对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是由C/C++提供的库函数或运算符来完成申请与管理，实现机制较为复杂，频繁的内存申请容易产生内存碎片。显然，堆的效率比栈要低得多。

4 创建对象的位置选择

4.1 在栈上创建对象

class Entity
{
private:
    string m_Name;
public:
    Entity(): m_Name("Unknow"){}
    Entity(const string& name): m_Name(name){}
    const string& GetName() const{return m_Name;}
};

int main()
{
    // 以下方式等价（无参数）
    Entity entity1a;
    Entity entity1b = Entity();
    
    // 以下写法是错误的：
    // 会被视为函数声明
    // Entity entity1c();
    // 不能用类型赋值
    // Entity entity1d = Entity;
    
    // 以下方式等价（有参数）
    Entity entity2a("chen");
    Entity entity2b = Entity("chen");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

创建的变量是对象本身，不是指针。

• 优点：很快，作用域结束后会自动释放对象，不会内存泄漏。
• 缺点：栈的容量比堆小的多，如果该对象很大（有多个成员等），则不推荐创建在栈。另外，如果作用域外还想使用该对象，则会出现错误。（作用域外声明的该类型指针，指向作用域中的这个对象，这个作用域结束后，该指针中的地址不变，但对象已经没了）

创建在栈上在大多数情况是推荐的，因为快且安全。

对于缺点的第二条：

Entity * e;
int b = 1;
int a = 2;
while (a > b)
{
    Entity entity("chen");
    e = &entity;
    cout << entity.GetName() << endl;
    b++;
}
// 这里e指的对象就没了
cout<< e->GetName()<< endl;

1
2
3
4
5
6
7
8
9
10
11
12
13

这种情况需要将对象创建在堆上。

4.2 在堆上创建对象

在类很大，或作用域外还想使用作用域内定义的对象时（手动控制生存周期），需要用到堆。

Entity * e;
int b = 1;
int a = 2;
while (a > b)
{
    Entity* entity = new Entity("chen");
    e = entity;
    cout << entity->GetName() << endl;
    b++;
}
cout<< e->GetName()<< endl;
// 需要手动释放对象
delete entity;
1
2
3
4
5
6
7
8
9
10
11
12
13

这里new在堆上按类型大小寻找一个足够的空间，并返回一个指针指向该空间，这也是与栈区别的地方。因此得到的是一个指针，并且速度更慢。

new和delete

new是一个操作符，他不光分配空间，还要调用类构造函数。
delete会释放空间，并调用析构函数

int* a = new int;
int *b = new int[50];  // 200 bytes
Entity *e = new Entity();
Entity *e1 = new Entity[50];

// c中分配空间会用malloc，它会按给定大小分配空间并返回空指针
// 但malloc与new就差在，malloc只负责分配空间，而new还调用了构造函数
Entity *e = (Entity*)malloc(sizeof(Entity));

delete a;
delete[] b;
delete e;
delete[] e1;

// c中释放空间是free，但free不会调用析构函数，而delete会
free(e);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17