C++ 内存泄漏指的是程序动态分配的内存在使用完毕后没有被正确释放，导致这部分内存无法被后续使用，长期运行会不断消耗系统内存。下面我们详细分析常见原因和对应的解决方法。
一、C++ 内存泄漏的常见原因
1. 动态内存分配后忘记释放
使用 new 或者 new[] 分配内存后，没有对应的 delete 或者 delete[] 操作，是最基础也最常见的内存泄漏原因。比如下面的代码：
#include <iostream>
void func() {
// 分配动态内存，但是函数结束前没有释放
int* p = new int(10);
// 后续逻辑没有delete p; 导致内存泄漏
}
int main() {
func();
return 0;
}2. 异常场景下内存未释放
如果动态分配内存之后，释放内存之前出现了异常，导致程序跳过了释放逻辑，也会造成内存泄漏。例如：
#include <iostream>
#include <stdexcept>
void func() {
int* p = new int(10);
// 这里抛出异常，后面的delete不会执行
throw std::runtime_error("发生异常");
delete p;
}
int main() {
try {
func();
} catch (...) {
// 捕获异常，但是p指向的内存已经泄漏
}
return 0;
}3. 匹配规则错误
new 要和 delete 匹配，new[] 要和 delete[] 匹配，如果混用也会导致内存泄漏或者程序崩溃。比如用 new[] 分配数组却用 delete 释放：
#include <iostream>
int main() {
int* arr = new int[10];
// 错误使用delete，应该用delete[]
delete arr;
return 0;
}4. 智能指针循环引用
使用 shared_ptr 时，如果两个对象互相持有对方的 shared_ptr，会导致引用计数永远无法降为0，内存无法释放。
#include <iostream>
#include <memory>
class A;
class B;
class A {
public:
std::shared_ptr<B> b_ptr;
};
class B {
public:
std::shared_ptr<A> a_ptr;
};
int main() {
auto a = std::make_shared<A>();
auto b = std::make_shared<B>();
// 循环引用，a和b的引用计数永远为2，不会释放
a->b_ptr = b;
b->a_ptr = a;
return 0;
}二、C++ 内存泄漏的解决方法
1. 优先使用智能指针
智能指针是C++11之后引入的内存管理工具，可以自动释放动态分配的内存，避免手动释放的遗漏。常用的智能指针有 unique_ptr 和 shared_ptr：
unique_ptr独占所指向的对象，生命周期结束时自动释放内存，适合不需要共享所有权的场景。shared_ptr通过引用计数管理对象，所有指向同一对象的shared_ptr都释放后才会销毁对象，适合需要共享所有权的场景，注意避免循环引用。
用智能指针改写前面的忘记释放的例子：
#include <iostream>
#include <memory>
void func() {
// 使用unique_ptr管理动态内存，函数结束时自动释放
std::unique_ptr<int> p = std::make_unique<int>(10);
}
int main() {
func();
return 0;
}2. 遵循RAII原则
RAII即资源获取即初始化，把资源的生命周期和对象的生命周期绑定，对象构造时获取资源，析构时释放资源，即使出现异常也能保证资源被释放。除了智能指针，我们也可以自定义RAII类来管理其他资源：
#include <iostream>
class IntWrapper {
private:
int* ptr;
public:
// 构造时获取资源
IntWrapper(int val) : ptr(new int(val)) {}
// 析构时释放资源
~IntWrapper() {
delete ptr;
}
// 提供访问接口
int getValue() const {
return *ptr;
}
};
void func() {
IntWrapper wrapper(10);
// 即使这里抛出异常，wrapper析构时也会释放内存
throw std::runtime_error("发生异常");
}
int main() {
try {
func();
} catch (...) {
// 内存已经被正确释放，没有泄漏
}
return 0;
}3. 规范内存分配释放匹配规则
开发时严格遵循 new 配 delete、new[] 配 delete[] 的规则，尽量不要混用。如果必须使用原始指针，可以在分配内存后立刻写对应的释放逻辑，避免后续遗忘。
4. 解决智能指针循环引用问题
当出现循环引用时，可以把其中一方的 shared_ptr 换成 weak_ptr，weak_ptr 不会增加引用计数，不会影响对象的生命周期，需要时可以通过 lock() 方法获取 shared_ptr 访问对象：
#include <iostream>
#include <memory>
class A;
class B;
class A {
public:
std::shared_ptr<B> b_ptr;
};
class B {
public:
// 使用weak_ptr避免循环引用
std::weak_ptr<A> a_ptr;
};
int main() {
auto a = std::make_shared<A>();
auto b = std::make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;
// 此时a和b的引用计数可以正常降为0，内存会被正确释放
return 0;
}三、内存泄漏的检测方法
除了提前规避，我们还可以通过工具检测已经存在的内存泄漏。常用的工具包括：
- Valgrind：Linux平台下的内存检测工具，可以精准定位内存泄漏的位置和原因。
- Visual Studio内置的诊断工具：Windows平台下可以在调试时使用内存快照对比，发现泄漏的内存块。
- AddressSanitizer：GCC和Clang都支持的内存检测工具，编译时添加对应参数即可在运行时检测内存问题。
日常开发中，建议结合规范的内存管理习惯和定期的内存检测，最大程度减少C++程序中的内存泄漏问题。