一、什么是内存泄漏

在实际的 C++ 开发中，我们经常会遇到诸如程序运行中突然崩溃、程序运行所用内存越来越多最终不得不重启等问题，这些问题往往都是内存资源管理不当导致的。比如：

• 有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指针），并且后续还在使用；
• 有些内存资源已经被释放，后期又试图再释放一次（重复释放同一块内存会导致程序运行崩溃）；
• 没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多。

参考链接：C/C++什么是内存泄露，内存泄露如何避免？

二、如何检测内存泄漏

1、内存占用变化排查法

内存泄漏一般不会造成程序崩溃，所以比较隐晦，但是发现内存泄露的方法也很简单，就是让程序运行一段时间，然后查看内存先后变化，通过任务管理器（windows）或者top（unix/linux）来监控某个进程的内存变化是比较方便的，有些程序的内存泄露比较小，但是发现它的内存泄露也都是时间问题。这里列出一个内存泄漏的程序的内存变化时间图，可以看出其内存占用总体上是呈递增的

内存泄漏较大的情况下，机器cpu使用率飙升，cpu的wait百分比增加，通过top可以看到swap内存使用量不断增加，kswap进程不时出现在进程列表当中。
linux中可以通过watch -n1 "ps -o vsz -p <PID>"，实时看到特定进程的内存使用量不断地增加

2、valgrind定位法

debian/ubuntu派系的linux下安装使用方法：

sudo apt install valgrind
valgrind ./main

参考链接：valgrind排查内存泄露

3、mtrace定位法

#include <mcheck.h>
 
int main(int argc, char **argv)
{
   setenv("MALLOC_TRACE","output",1);
 
   mtrace();
}

运行程序之后，在程序的当前目录下会生成output文件，然后使用命令获取堆栈信息：

mtrace [程序名] output > msg.txt

通过查看msg.txt文件，就可以找到内存泄漏的地方、大小，如：

Memory not freed:
-----------------
           Address     Size     Caller
0x0000000001ed4760     0x18  at 0x7fface2c1780
0x0000000001ed47b0     0x18  at 0x7fface2c1780
0x0000000001ed59f0     0xb0  at 0x7fface2c1780
0x0000000001ed5ab0     0x18  at 0x7fface2c1780
0x0000000001ed5ad0     0x18  at 0x7fface2c1780
0x0000000001ed5af0     0x18  at 0x7fface2c1780

参考链接：c/c++程序内存泄漏跟踪总结

三、智能指针分类及作用

  为了避免内存泄漏，我们需要将每一个malloc和delete, new和free对应起来，显然这十分地麻烦而且容易出错，那是否有更简便的方式呢?
  试想如果我们将分配的动态内存都交由有生命周期的对象来处理，在它的析构函数中删除指向的内存，那么在对象过期时，是不是就可以自动的释放内容从而避免内存泄漏呢！
  答案是肯定的，智能指针就使用了这种思想来帮助我们C++程序员管理动态分配的内存的，它会帮助我们自动释放new出来的内存，从而避免内存泄漏！

• C++98/03 中，支持使用 auto_ptr 智能指针来实现堆内存的自动回收；
• C++11 中废弃了 auto_ptr，支持使用 unique_ptr、shared_ptr 以及 weak_ptr 这 3 个智能指针来实现堆内存的自动回收。

// 头文件
#include <memory>

参考链接： C++ 智能指针 - 全部用法详解

1、unique_ptr

特点：

• 无法同其它 unique_ptr 共享，一旦该 unique_ptr 指针放弃对所指堆内存空间的所有权，则该空间会被立即释放回收。
• 无法进行左值unique_ptr复制构造，也无法进行左值复制赋值操作，但允许临时右值赋值构造和赋值
• 保存指向某个对象的指针，当它本身离开作用域时会自动释放它指向的对象。
• 在容器中保存指针是安全的

适用场景：
动态申请的内存仅在当前作用域有效

void func(){
	int * p = new int(1111);
	/*do something*/
	delete p;
}

  如果在do something的时候，出现了异常，退出了，那delete就永远没有执行的机会，就会造成内存泄露，而如果使用unique_ptr就不会有这样的困扰了。而相比于shared_ptr，它的开销更小，甚至可以说和裸指针相当，它不需要维护引用计数的原子操作等等。所以说，如果有可能，优先选用unique_ptr。

void func(){
	std:unique_ptr p( new int(1111) );
	/*do something*/
}

用法：

// 创建
std::unique_ptr<int> p1();
std::unique_ptr<int> p2(nullptr);
std::unique_ptr<int> p3(new int(10));
std::unique_ptr<int> p4(p3);//错误，堆内存不共享
std::unique_ptr<int> p5(std::move(p3));//正确，调用移动构造函数

// 赋值
unique_ptr<Test> t7(new Test);
unique_ptr<Test> t8(new Test);
t7 = std::move(t8);	// 必须使用移动语义，结果，t7的内存释放，t8的内存交给t7管理

// 主动释放对象
unique_ptr<Test> t9(new Test);
t9 = NULL;
t9 = nullptr;
t9.reset();

// 放弃对象控制权
Test *t10 = t9.release();

// 重置
t9.reset(new Test)。

参考链接：

1. 为何优先选用unique_ptr而不是裸指针？
2. C++11 unique_ptr智能指针详解

2、shared_ptr

特点：
  多个 shared_ptr 智能指针可以共同使用同一块堆内存。并且，由于该类型智能指针在实现上采用的是引用计数机制，即便有一个 shared_ptr 指针放弃了堆内存的“使用权”（引用计数减 1），也不会影响其他指向同一堆内存的 shared_ptr 指针（只有引用计数为 0 时，堆内存才会被自动释放）。
适用场景：
  当动态申请的内存被建立多个索引时，常常会触发一处索引释放了内存地址，而另一处索引又请求内存地址导致的异常。这时我们可以使用shared_ptr对地址空间进行托管，shared_ptr会自动记录指向当前地址的索引，当索引全部删除时会自动释放内存地址，非常的方便！

用法：

std::shared_ptr<int> p3(new int(10));
std::shared_ptr<int> p3 = std::make_shared<int>(10);
//调用拷贝构造函数
std::shared_ptr<int> p4(p3);
std::shared_ptr<int> p4 = p3;
//调用移动构造函数
std::shared_ptr<int> p5(std::move(p4)); //或者 std::shared_ptr<int> p5 = std::move(p4);

// 显示引用计数
p5.use_count()

std::move(p4) 来说，该函数会强制将 p4 转换成对应的右值，因此初始化 p5 调用的是移动构造函数。另外和调用拷贝构造函数不同，用 std::move(p4) 初始化 p5，会使得 p5 拥有了 p4 的堆内存，而 p4 则变成了空智能指针

对于申请的动态数组来说，shared_ptr 指针默认的释放规则是不支持释放数组的，只能自定义对应的释放规则，才能正确地释放申请的堆内存。

//自定义释放规则
void deleteInt(int*p) {
    delete []p;
}
//初始化智能指针，并自定义释放规则
std::shared_ptr<int> p7(new int[10], deleteInt);
// lambda 表达式
std::shared_ptr<int> p7(new int[10], [](int* p) {delete[]p; });

参考链接： C++11 shared_ptr智能指针（超级详细）

3、weak_ptr

1. 弱指针用于接管共享指针，在需要使用时可以转换成共享指针。
2. 当被接管的共享指针失效时，弱指针随即失效。
3. 弱指针不支持 * 和 -> 对指针的访问；

示例代码：

     std::weak_ptr<int> gw;
    {
		auto sp = std::make_shared<int>(42);
		gw = sp;
		// expired：判断当前智能指针是否还有托管的对象，有则返回false，无则返回true
        if (!gw.expired()) {
            std::cout << "gw is valid\n";	// 有效的，还有托管的指针
        } else {
            std::cout << "gw is expired\n";	// 过期的，没有托管的指针
        }

        auto gw_sp = gw.lock();	// lock：返回一个shared_ptr对象，指向被托管的对象，如果没有则返回空的shared_ptr对象
        std::cout << *gw_sp << std::endl;
	}

	// 当{ }体中的指针生命周期结束后，再来判断其是否还有托管的指针
    if (!gw.expired()) {
        std::cout << "gw is valid\n";	// 有效的，还有托管的指针
    } else {
        std::cout << "gw is expired\n";	// 过期的，没有托管的指针
    }

gw is valid
42
gw is expired