目录
在 C++ 编程中，内存管理是一个至关重要的环节。合理的内存分配和管理不仅能提高程序的性能，还能避免诸如内存泄漏、悬空指针等严重问题。C++ 提供了多种内存分配方式，从基础的栈内存分配到灵活的堆内存分配，每种方式都有其特点和适用场景。
一、C++ 内存的基本概念
1.1 内存的物理与逻辑结构
在计算机系统中，物理内存是实际的硬件存储设备，用于存储程序运行时的数据和指令。而逻辑内存则是操作系统为每个进程提供的一个抽象的内存空间视图，它使得每个进程都认为自己拥有整个系统内存。操作系统通过内存管理单元（MMU）将逻辑地址转换为物理地址，实现内存的高效管理和保护。
1.2 C++ 程序的内存区域划分
C++ 程序在运行时，其内存空间通常被划分为以下几个区域：
- 栈（Stack）：栈是一块连续的内存区域，由编译器自动管理。主要用于存储局部变量、函数参数、返回地址等。栈的分配和释放速度非常快，遵循后进先出（LIFO）的原则。
- 堆（Heap）：堆是一块不连续的内存区域，用于动态内存分配。程序员通过new和delete操作符在堆上分配和释放内存。堆内存的管理相对复杂，容易出现内存泄漏等问题。
- 全局 / 静态存储区：用于存储全局变量和静态变量。该区域在程序启动时分配，程序结束时释放。全局变量和静态变量根据初始化情况，又分为初始化的全局 / 静态存储区和未初始化的全局 / 静态存储区（BSS 段） 。
- 常量存储区：用于存储常量，如字符串常量。常量存储区的内容在程序运行期间是只读的。
可以用下图来直观展示 C++ 程序的内存区域划分：
二、栈内存分配
2.1 栈内存的特点
栈内存具有以下特点：
- 自动管理：栈内存的分配和释放由编译器自动完成，无需程序员手动干预。
- 速度快：由于栈的操作遵循后进先出原则，并且是在连续的内存区域进行操作，所以栈内存的分配和释放速度非常快。
- 大小有限：栈的大小在程序运行前通常是固定的，不同的操作系统和编译器对栈的大小限制不同。如果函数调用层级过深，或者局部变量占用空间过大，可能会导致栈溢出。
2.2 栈内存分配示例
下面通过一个简单的 C++ 代码示例来展示栈内存的分配和使用：
#include <iostream>
void function() {
int localVar = 10; // 局部变量 localVar 在栈上分配内存
std::cout << "Local variable in function: " << localVar << std::endl;
}
int main() {
int mainVar = 20; // 局部变量 mainVar 在栈上分配内存
std::cout << "Local variable in main: " << mainVar << std::endl;
function();
return 0;
}
mainVar和localVar都是局部变量，它们在函数调用时在栈上分配内存，函数结束时，栈内存会自动释放。
三、堆内存分配
3.1 new和delete操作符
在 C++ 中，使用new操作符在堆上分配内存，使用delete操作符释放堆内存。new操作符返回一个指向分配内存的指针，delete操作符用于释放new分配的内存。
①基本数据类型的堆内存分配
#include <iostream>
int main() {
int* ptr = new int; // 在堆上分配一个 int 类型的内存空间
*ptr = 10; // 向分配的内存空间写入数据
std::cout << "Value in heap memory: " << *ptr << std::endl;
delete ptr; // 释放堆内存
return 0;
}
②数组的堆内存分配
#include <iostream>
int main() {
int* arr = new int[5]; // 在堆上分配一个包含 5 个 int 元素的数组
for (int i = 0; i < 5; ++i) {
arr[i] = i;
}
for (int i = 0; i < 5; ++i) {
std::cout << "arr[" << i << "]: " << arr[i] << std::endl;
}
delete[] arr; // 释放堆上的数组内存
return 0;
}
需要注意的是，在释放数组内存时，必须使用delete[]，否则可能会导致内存泄漏或程序崩溃。
4.2 内存泄漏与悬空指针问题
①内存泄漏：当使用new分配的内存没有通过delete释放时，就会发生内存泄漏。随着程序的运行，内存泄漏会导致可用内存逐渐减少，最终可能导致程序性能下降甚至崩溃。
#include <iostream>
void memoryLeak() {
int* ptr = new int;
// 没有调用 delete ptr，导致内存泄漏
}
int main() {
memoryLeak();
return 0;
}②悬空指针：当通过delete释放了堆内存后，如果没有将指针设置为nullptr，该指针就会成为悬空指针。使用悬空指针进行解引用操作会导致未定义行为。
#include <iostream>
int main() {
int* ptr = new int;
*ptr = 10;
delete ptr;
// 此时 ptr 成为悬空指针
std::cout << *ptr << std::endl; // 未定义行为
return 0;
}
为了避免悬空指针问题，可以在释放内存后将指针设置为nullptr：
#include <iostream>
int main() {
int* ptr = new int;
*ptr = 10;
delete ptr;
ptr = nullptr; // 将指针设置为 nullptr
return 0;
}4.3 new和delete的重载
在 C++ 中，可以重载new和delete操作符，以实现自定义的内存分配策略。例如，可以实现内存池来提高内存分配的效率，减少内存碎片。
#include <iostream>
#include <cstdlib>
class MemoryPool {
private:
static const size_t POOL_SIZE = 1024; // 内存池大小
char* pool;
size_t current;
public:
MemoryPool() : pool(static_cast<char*>(std::malloc(POOL_SIZE))), current(0) {}
~MemoryPool() { std::free(pool); }
void* allocate(size_t size) {
if (POOL_SIZE - current < size) {
return std::malloc(size); // 内存池不足时，使用标准 malloc
}
void* result = pool + current;
current += size;
return result;
}
void deallocate(void* ptr) {
// 简单实现，不支持真正的释放回内存池，仅标记为可分配
if (ptr >= pool && ptr < pool + POOL_SIZE) {
// 这里可以添加更复杂的标记逻辑
} else {
std::free(ptr);
}
}
};
MemoryPool globalPool;
void* operator new(size_t size) {
return globalPool.allocate(size);
}
void operator delete(void* ptr) noexcept {
globalPool.deallocate(ptr);
}
class MyClass {
public:
int data;
MyClass() : data(0) {}
};
int main() {
MyClass* obj = new MyClass;
obj->data = 10;
std::cout << "Data in MyClass: " << obj->data << std::endl;
delete obj;
return 0;
}
通过重载new和delete操作符，实现了一个简单的内存池。当分配内存时，优先从内存池中获取，如果内存池不足，则使用标准的malloc函数。释放内存时，对于从内存池中分配的内存，简单标记为可分配（实际应用中可实现更复杂的回收逻辑），对于使用malloc分配的内存，则使用free释放。
四、智能指针与动态内存管理
4.1 智能指针的概念
智能指针是 C++ 标准库提供的一种用于自动管理动态内存的类模板。它通过封装原始指针，并在适当的时候自动释放所指向的内存，从而避免了手动管理内存时容易出现的内存泄漏和悬空指针问题。
4.2 std::unique_ptr
std::unique_ptr是一种独占所有权的智能指针，它不支持拷贝构造和赋值操作，确保每个std::unique_ptr实例都唯一地拥有所指向的对象。当std::unique_ptr对象被销毁时，它所指向的内存会自动释放。
#include <iostream>
#include <memory>
class MyClass {
public:
MyClass() { std::cout << "MyClass constructor" << std::endl; }
~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
std::unique_ptr<MyClass> ptr(new MyClass); // 创建 std::unique_ptr
// ptr 离开作用域时，MyClass 对象的内存会自动释放
return 0;
}
std::unique_ptr还提供了release和reset等成员函数，用于转移所有权和释放当前指向的对象。
4.3 std::shared_ptr
std::shared_ptr是一种共享所有权的智能指针，多个std::shared_ptr可以指向同一个对象，通过引用计数来管理对象的生命周期。当最后一个指向对象的std::shared_ptr被销毁时，对象的内存会自动释放。
#include <iostream>
#include <memory>
class MyClass {
public:
MyClass() { std::cout << "MyClass constructor" << std::endl; }
~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};
int main() {
std::shared_ptr<MyClass> ptr1(new MyClass); // 创建 std::shared_ptr
std::shared_ptr<MyClass> ptr2 = ptr1; // 共享所有权，引用计数加 1
// 当 ptr1 和 ptr2 都离开作用域时，MyClass 对象的内存会自动释放
return 0;
}
std::shared_ptr还提供了use_count等成员函数，用于获取当前对象的引用计数。
4.4 std::weak_ptr
std::weak_ptr是一种弱引用的智能指针，它不影响对象的生命周期，主要用于解决std::shared_ptr循环引用的问题。std::weak_ptr不能直接解引用，需要先通过lock函数将其转换为std::shared_ptr。
#include <iostream>
#include <memory>
class B;
class A {
public:
std::weak_ptr<B> ptrB;
~A() { std::cout << "A destructor" << std::endl; }
};
class B {
public:
std::weak_ptr<A> ptrA;
~B() { std::cout << "B destructor" << std::endl; }
};
int main() {
std::shared_ptr<A> a(new A);
std::shared_ptr<B> b(new B);
a->ptrB = b;
b->ptrA = a;
// 当 a 和 b 离开作用域时，对象 A 和 B 的内存会正常释放
return 0;
}
通过std::weak_ptr打破了A和B之间的循环引用，避免了内存泄漏。
五、总结
本文详细介绍了 C++ 中的内存分配相关知识，包括栈内存和堆内存的分配方式、new和delete操作符的使用、内存泄漏和悬空指针问题，以及智能指针在动态内存管理中的应用。合理选择和使用内存分配方式，正确处理内存管理问题，对于编写高效、稳定的 C++ 程序至关重要。在实际编程中，应根据具体需求选择合适的内存管理策略，充分利用 C++ 提供的内存管理工具，提高程序的质量和性能。