C++作为一门支持手动内存管理的语言，开发者需要自己负责动态内存的申请和释放，这虽然带来了更高的灵活性，但也容易引发内存泄漏和悬空指针问题。内存泄漏指的是动态申请的内存没有被正确释放，导致内存被持续占用无法回收；悬空指针指的是指针指向的内存已经被释放，但指针仍然保留原来的地址，后续访问该指针就可能引发未定义行为。
内存泄漏和悬空指针的常见成因
内存泄漏的常见场景
内存泄漏大多是因为动态内存申请后没有匹配的释放操作，常见的场景有以下几种：
- 使用
new申请内存后，忘记调用delete释放 - 程序中途抛出异常，跳过了原本的
delete执行逻辑 - 在循环或者条件分支中申请内存，部分分支没有释放逻辑
- 指针被重新赋值，之前指向的内存地址丢失，无法再释放
悬空指针的常见场景
悬空指针的形成通常和内存释放后的指针处理有关：
- 调用
delete释放内存后，没有将指针置为nullptr，后续仍然使用该指针 - 多个指针指向同一块内存，其中一个指针释放了内存，其他指针变成悬空状态
- 返回局部变量的地址，变量销毁后指针指向无效内存
使用RAII思想管理资源
RAII（Resource Acquisition Is Initialization）是C++中管理资源的核心思想，它的核心逻辑是：将资源的管理和对象的生命周期绑定，对象构造时获取资源，对象析构时自动释放资源。这样只要对象能正确析构，资源就不会泄漏。
下面是一个简单的RAII封装示例，用来管理动态申请的int内存：
#include <iostream>
class IntWrapper {
private:
int* ptr;
public:
// 构造时获取资源
IntWrapper(int value) : ptr(new int(value)) {}
// 析构时释放资源
~IntWrapper() {
delete ptr;
ptr = nullptr;
std::cout << "内存已释放" << std::endl;
}
// 提供访问接口
int getValue() const {
return *ptr;
}
void setValue(int value) {
*ptr = value;
}
};
int main() {
// 对象在栈上创建，离开作用域会自动调用析构函数
{
IntWrapper wrapper(10);
std::cout << "值为：" << wrapper.getValue() << std::endl;
wrapper.setValue(20);
std::cout << "修改后值为：" << wrapper.getValue() << std::endl;
} // 此处wrapper析构，自动释放内存
return 0;
}
使用智能指针简化内存管理
C++标准库提供了三种智能指针，分别是unique_ptr、shared_ptr和weak_ptr，它们都基于RAII思想实现，能自动管理动态内存，大幅减少内存泄漏和悬空指针的问题。
unique_ptr：独占所有权的智能指针
unique_ptr保证同一时间只有一个指针拥有对内存的所有权，当unique_ptr被销毁时，指向的内存会自动释放。它不能拷贝，只能通过std::move转移所有权。
#include <iostream>
#include <memory>
int main() {
// 创建unique_ptr管理int内存
std::unique_ptr<int> ptr1(new int(100));
std::cout << "ptr1指向的值：" << *ptr1 << std::endl;
// 转移所有权，ptr1变为空
std::unique_ptr<int> ptr2 = std::move(ptr1);
if (ptr1 == nullptr) {
std::cout << "ptr1已经为空" << std::endl;
}
std::cout << "ptr2指向的值：" << *ptr2 << std::endl;
// ptr2离开作用域时自动释放内存
return 0;
}
shared_ptr：共享所有权的智能指针
shared_ptr通过引用计数记录有多少个指针指向同一块内存，当引用计数降为0时，才会释放内存。适合多个对象需要共享同一块内存的场景。
#include <iostream>
#include <memory>
int main() {
// 创建shared_ptr
std::shared_ptr<int> ptr1 = std::make_shared<int>(200);
std::cout << "引用计数：" << ptr1.use_count() << std::endl;
{
// 拷贝ptr1，引用计数加1
std::shared_ptr<int> ptr2 = ptr1;
std::cout << "拷贝后引用计数：" << ptr1.use_count() << std::endl;
} // ptr2销毁，引用计数减1
std::cout << "ptr2销毁后引用计数：" << ptr1.use_count() << std::endl;
// ptr1离开作用域，引用计数降为0，自动释放内存
return 0;
}
weak_ptr：解决shared_ptr循环引用问题
当两个shared_ptr互相引用时，会形成循环引用，导致引用计数永远无法降为0，引发内存泄漏。weak_ptr是弱引用，不会增加引用计数，用来观测shared_ptr指向的内存，需要使用时可以转换为shared_ptr。
#include <iostream>
#include <memory>
class B; // 前向声明
class A {
public:
std::shared_ptr<B> b_ptr;
~A() {
std::cout << "A析构" << std::endl;
}
};
class B {
public:
std::weak_ptr<A> a_ptr; // 使用weak_ptr避免循环引用
~B() {
std::cout << "B析构" << std::endl;
}
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;
// 离开作用域后，a和b都能正确析构，不会内存泄漏
return 0;
}
手动内存管理的注意事项
如果确实需要使用new和delete进行手动内存管理，需要遵守以下规则减少问题：
- 确保
new和delete匹配使用，new对应delete，new[]对应delete[] - 释放内存后立即将指针置为
nullptr，避免悬空指针 - 不要在同一个函数中申请内存，在另一个函数中释放，尽量保证内存的申请和释放在同一个作用域或者同一层逻辑中
- 避免返回动态内存的指针，优先返回智能指针或者封装的对象
- 在释放指针前检查指针是否为
nullptr，虽然delete nullptr是安全的，但检查可以避免逻辑错误
下面是一个手动内存管理的正确示例：
#include <iostream>
int main() {
int* num = new int(50);
std::cout << "动态申请的数值：" << *num << std::endl;
// 释放内存
delete num;
num = nullptr; // 置为空，避免悬空指针
// 后续访问前检查
if (num != nullptr) {
std::cout << *num << std::endl;
} else {
std::cout << "指针已经为空，无法访问" << std::endl;
}
return 0;
}
总结
避免C++中的内存泄漏和悬空指针，核心是使用RAII思想管理资源，优先使用标准库提供的智能指针替代手动的new和delete操作。如果必须手动管理内存，需要严格遵守申请释放匹配、释放后置空等规则。养成良好的内存管理习惯，能有效提升C++程序的稳定性和可靠性。