2025_10_13_12_动态内存-CSDN博客

动态内存

本片援引自C++ Primer中的第12章，也是我复习的第6章

内存是我自学习高级语言以来最头疼的问题，今天可以借此篇好好梳理一番~

一、前言

我们编写的程序中所使用的对象都有严格定义的生存期。

例如：全局对象：程序启动时分配，结束时销毁。
局部对象：进入所在的程序块时被创建，离开时销毁。
静态对象（static）：在使用前分配，在程序结束时销毁。

那么在内存中这些对象如何分配呢？
全局对象何静态对象在静态内存中存储，局部对象在栈内存中存储。由编译器自动创建和销毁。

C++还支持动态分配对象，这些对象被存储在“自由空间”——堆，由程序员创建和销毁（代码显式）。

日常生活中，静态内存和栈内存接触最多了，就不过多赘述了，接下来我就详细介绍一下动态内存吧~

二、动态内存和智能指针

2.1 概述

在C++中，动态内存通过一对运算符来完成：new 和 delete。（见后文）

使用动态内存容易出现问题：

忘记释放，导致内存泄露
上有指针引用内存的情况，就释放了，导致引用非法内存的指针。

使用动态内存的原因：

程序不知道自己使用多少对象
程序不知道所需对象的准确类型
程序需要在多少个对象间共享数据

2.2 智能指针

2.2.1 概述

智能指针的行为类似常规指针，重点区别在于它负责自动释放所指向的对象。智能指针本质上就是一个封装好的自动化管理动态内存生命周期的类模板对象。

类模板将在之后的篇章中详细介绍~

2.2.2 类型

两种类型，区别在于管理底层指针的方式。

shared_ptr
unique_ptr

2.2.3 使用

头文件：#include<memory>

在这里插入图片描述

2.2.4 `shared_ptr`类

<1> 声明：必须提供指针可以指向的类型

// 声明
shared_ptr<string> p1;

<2> 初始化

默认初始化：智能指针中保存着一个空指针。
自己初始化：利用make_shared函数（见下文）

<3> 使用：和普通指针类似。解引用指针返回它指向的对象。允许多个指针指向同一个对象。

<4> 拷贝、赋值与销毁

拷贝

每个shared_ptr 都会记录有多少个其他shared_ptr 指向相同的对象，这是靠shared_ptr关联的计数器——引用计数实现的。每当拷贝shared_ptr时，计数器就会递增。

赋值

auto r = make_shared<int> (42);		// r指向的int只有一个引用者
r = q;	// 给r赋值，令它指向另一个地址
		// 递增q指向的对象的引用计数
		// 递减r原来指向的对象的引用计数
		// r原来指向的对象已没有引用者，会自动释放

销毁

shared_ptr会用所指向对象的析构函数完成销毁的，析构函数会递减它所指向的对象的引用计数，销毁对象，并释放它占用的内存和关联内存。（如果有其他shared_ptr 指向该内存，它就不会被释放）
如果shared_ptr的计数器变为0，它就会自动释放自己所管理的对象。

2.2.5 `make_shared`函数

<1> 操作

该函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr。

<2> 定义

make_shared用其参数来构造给定类型的对象，如果我们不传递任何参数，对象就会进行值初始化。

shared_ptr<int> p3 = make_shared<int> (42);			// 值初始化为42
shared_ptr<int> p5 = make_shared<int> ();			// 值初始化为0（值初始化）
// 常用auto定义一个对象来保存make_shared结果
auto p6 = make_shared<vector<string>> ();

2.2.6 直接管理内存

<1> 概述

直接管理内存就是使用两个运算符new 和delete。

虽然在特殊工具与技术那一篇中已讲过，但是我在写本篇时回去回顾，发现还有很多细节没有考虑到，所以在此篇中详细讲讲~

new和delete本质就是运算符，但他们底层会调用全局的分配函数 operator new/delete进行内存的分配和释放。初始化和销毁数据都是靠传递给new 的参数的构造和析构函数。

<2> new

概述：在自由空间分配的内存是无名的，new 无法为其分配的对象命名，而是返回一个指向该对象的指针。动态分配的对象是默认初始化的。也可以对动态分配的对象进行值初始化。

// 默认初始化
int *p = new int(18);			// 值是未定义的
// 值初始化
string *q = new string();		// 有着良好的定义的值

const对象：可以隐式初始化

const int *p = new const int(18);		// 分配并初始化
const string *q = new const string;		// 隐式初始化，而且值已经不可改变了

内存耗尽：new不能分配所要求的内存空间时，它会抛出一个类型为bad_alloc的异常（operator new函数抛出的）

定位new：不需要分配所需的内存，返回一个空指针，比如将nothrow的对象传递给new（如果不分配内存的情况下）就是定位new 的一种方式。

#include<new>
char *buffer = new char[sizeof(int)];
int *p = new(buffer) int(42);
p->~int();
delete[] buffer;			// 这里是释放字符数组，所以要加上"[]"。这取决于new的时候是不是数组
// 后面也会详细讲动态数组~

<3> delete

概述：将动态内存归还给系统。

细节：delete接受一个指针，指向我们想要释放的对象（必须指向内存，或者它是一个空指针）。delete执行两个动作：销毁给定的指针指向的对象，释放对应的内存。

注意：const对象的值不能被改变，但是可以销毁。
有时delete后，指针会变成空悬指针，仍然保存了释放的内存的地址。可以使其被赋予空指针。

<4> 易错点

忘记delete内存
使用已经释放的对象
同一块内存释放两次
坚持使用智能指针

2.2.7 `shared_ptr`和`new`结合使用

<1> 初始化

如果不初始化一个智能指针，它就会被初始化为一个空指针。
可以用new返回的指针来初始化智能指针。

智能指针接受的参数是explicit的。

shared_ptr<int> p1 = new int(18);		// 必须使用直接初始化的形式
// 这里是需要编译器用一个new返回的int *来创建一个shared_ptr
shared_ptr<int> p2(new int(18));		// √

在这里插入图片描述

<2> 注意

不要混合使用普通指针和智能指针（我们无法知道智能指针负责的对象何时被销毁）
不要使用get初始化另一个智能指针或为智能指针赋值

get是智能指针类型定义的函数，返回一个内置指针，指向智能指针管理的对象。使用get返回的指针的代码不能delete此指针。

<3> 其他操作

可以用reset将一个新指针赋予一个shared_ptr（改变底层对象之前，确保是当前对象仅有的用户）。reset会更新引用计数，它常和unique一起使用。

2.2.8 智能指针和异常

在发生异常时，我们直接管理的内存是不会自动释放的。比如在new和delete之间发生了异常，内存就无法被释放了。
解决方法：使用智能指针管理（shared_ptr）。
智能指针和哑类：有些类没有析构函数（为C和C++两种语言设计的类）
解决方法：可以使用shared_ptr避免内存泄露。
使用自己的释放操作：如果使用的智能指针管理的资源不是new分配的内存，需要传递给它一个删除器。

2.2.9 `unique_ptr`

<1> 概述

一个unique_ptr指向一个给定的对象。（1V1）

<2> 定义和初始化

定义：定义一个unique_ptr时，需要将其绑定到一个new返回的指针上。
初始化：直接初始化。

<3> 拷贝、赋值

不支持拷贝赋值。但可以调用release/reset将指针的所有权转移（除了const）。

release成员会返回unique_ptr保存的指针并将其置为空。release常被用来初始化另一个智能指针或给另一个智能指针赋值。

unique_ptr<string> p2(p1.release());		// 将所有权从p1转移给p2

reset接受一个可选的指针参数，令unique_ptr重新指向给定的指针，它会将目标指针原来的对象释放掉，接受新的指针。

unique_ptr<string> p3(new string("xcver"));
p2.reset(p3.release());

可以拷贝或赋值一个将要被销毁的unique_ptr。编译器会执行移动语义。

<4> 传递删除器

可以重载unique_ptr中默认的删除器，这会影响unique_ptr的类型以及如何公祖奥，在unique_ptr指定类型后，提供删除器类型（在尖括号中）。

2.2.10 `weak_ptr`

<1> 概述

不控制所指向对象生存期的智能指针。

<2> 定义和初始化

定义：指向由一个shared_ptr管理的对象。当一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。即使有weak_ptr指向对象，对象还是会被释放。

初始化：用shared_ptr初始化。

auto p = make_shared<int> (42);
weak_ptr<int> wp(p);		// wp弱共享p

<3> 作用

需要安全地访问一个可能已被 shared_ptr释放的资源，避免出现悬垂指针.
两个或多个由 shared_ptr管理的对象相互持有对方的 shared_ptr，导致引用计数无法归零，从而引发内存泄漏。

三、动态数组

3.1 概述

3.1.1 目的或意义

一次分配/释放很多对象（对象数组）。

3.1.2 方式

new 表达式：分配并初始化一个对象数组。
allocator 类：分配和初始化分离

3.1.3 注意

大多数应用多使用标准库容器（如：vector）非不是动态分配的数组，容器的类可以使用默认版本的拷贝、赋值和操作，分配动态数组的类必须自定义自己版本的操作。所以容器更不容易出现内存管理的错误。

3.2 `new` 和动态数组

3.2.1 定义

类型名后要跟一对方括号
要指明分配的对象的数目，大小必须是整型，不必是常量
返回指向第一个对象的指针（元素类型的指针，不是数组类型）

// 使用get_size确定分配多少int
int *ptr = new int[get_size()];
// 可以使用表示数组类型的类型别名
typedef int arr[42];
int *p = new arr;`

3.2.2 初始化

<1> 方式

在大小后跟一个空括号
提供一个元素初始化器的花括号列表
- 数目＜元素数目，剩余元素进行值初始化
- 数目＞元素数目，new 表达式失败，不会分配任何内存

// 空括号版
int *ptr = new int[10]();
// 元素初始器版
int *ptr = new int[10]{10, 12, 4, 3};

<2> 注意

在 new表达式中**不能使用 auto**来推导数组类型。
分配空数组是合法的。
new 会返回一个合法的非空指针，我们可以像使用尾后迭代器（end()）一样使用它，可以用这个指针进行比较操作，但是不能解引用（毕竟它不指向任何元素）

3.2.3 释放

<1> 方式

delete [] ptr;

<2> 细节

每个使用到的元素被赋值了两次：默认初始化和赋值
数组中的元素按逆序销毁。如果使用了数组别名，delete时也要加上方括号，因为delete会为数组中每个元素调用一次析构函数。

3.2.4 结合智能指针

<1> 定义

标准库提供了一个可以管理new分配的数组的**unique_ptr** 版本。

unique_ptr<int[]> up(new int[10]);

<2> 细节

当up 销毁它管理的指针时，自动使用delete

可以使用下标运算符访问数组中的元素

for(size_t i = 0; i != 10; ++i)
    up[i] = i;

在这里插入图片描述

<3> 注意

shared_ptr 不直接支持管理动态数组，如果要使用，必须提供自己定义的删除器。
shared_ptr 未定义下标运算符，会影响如何访问数组中的元素。
智能指针类型不支持指针算术运算（ptr + n，ptr++，ptr2 - ptr1，==, !=, >, <）

3.3 `allocator`类

3.3.1 概述

allocator是一个模板，定义在头文件memory中，将内存分配和对象构造分离开来，分配内存是原始的、未构造的。

有没有觉得很熟悉，new定位也有这个特性。回头看之前写的东西，觉得还是不够清楚，在这里再详细的剖析一下细节吧~

特性对比 placement new allocator::construct
本质 C++ 关键字/运算符（特殊的 new表达式） std::allocator类模板的成员函数
核心功能 在指定内存地址调用对象的构造函数在分配的内存位置使用拷贝构造函数初始化对象
构造函数支持 支持对象的任何构造函数（无参、有参等）传统上主要使拷贝构造函数（通过传入一个现有对象来构造）
内存来源 任何已分配的原始内存（堆、栈、内存池等）通常来源于 allocator自身通过 allocate()分配的内存
析构方式 需要显式调用对象的析构函数（如 obj->~T();）使用 allocator的 destroy成员函数来析构对象
使用场景 更底层，提供最大灵活性，常用于内存池、自定义内存管理、性能极致优化的场景更高级、更安全，通常与标准库容器（如 std::vector）及其自定义分配器紧密集成
类型安全性 相对较低，需要开发者自行确保内存大小和对齐方式正确相对较高，因其与特定的 allocator类型关联

特性对比	`placement new`	`allocator::construct`
本质	C++ 关键字/运算符（特殊的 `new`表达式）	`std::allocator`类模板的成员函数
核心功能	在指定内存地址调用对象的构造函数	在分配的内存位置使用拷贝构造函数初始化对象
构造函数支持	支持对象的任何构造函数（无参、有参等）	传统上主要使拷贝构造函数（通过传入一个现有对象来构造）
内存来源	任何已分配的原始内存（堆、栈、内存池等）	通常来源于 `allocator`自身通过 `allocate()`分配的内存
析构方式	需要显式调用对象的析构函数（如 `obj->~T();`）	使用 `allocator`的 `destroy`成员函数来析构对象
使用场景	更底层，提供最大灵活性，常用于内存池、自定义内存管理、性能极致优化的场景	更高级、更安全，通常与标准库容器（如 `std::vector`）及其自定义分配器紧密集成
类型安全性	相对较低，需要开发者自行确保内存大小和对齐方式正确	相对较高，因其与特定的 `allocator`类型关联

3.3.2 定义

定义一个allocator 对象，必须指明可以分配的对象类型。

allocator<string> alloc;				// 可以分配string的allocator对象
auto const p = alloc.allocate(n);		// 分配n个未初始化的string

3.3.3 使用过程

为了使用allocate返回的内存，我们必须用construct构造对象，construct 成员函数一个指针和0/多个额外参数。
函数destroy 接受一个指针，对指向的对象执行析构函数。（只能对真正构造了的元素进行destroy操作），逆序删除元素。
释放内存通过deallocate，我们传递给deallocate的指针不能为空。

在这里插入图片描述