C++内存管理，看这就够了

前言

对于C/C++这样自己管理内存的语言，搞清楚如何去管理内存是很重要的，我觉得管理内存其实也没那么难。
在C++中有两种思路，要不自己去管理内存，要不使用智能指针，当然，后一种是C++后来版本加进去的，也是为了让C++变得更加容易和安全。

内存分配

想要搞清楚内存管理，我们先得搞清楚内存是如何分配的，或者说分为哪几块。
栈： 程序种执行的函数内的局部变量都是在栈上面创建的，函数执行结束这些存储单元会被自动释放。栈的内存分配时内置于指令集之中的，效率极高，但是由于寄存器的容量限制，所以栈内分配的容量十分有限。
堆： 程序中使用new分配的内存块，它们的释放需要程序员去管理，编译器不负责。一个new要对应一个delete，若是程序员没有释放它们，程序结束后，操作系统会自动回收。
自由存储区： 由malloc分配的内存，类似于堆，它们由free进行释放。
全局/静态存储区： 全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
常量存储区： 这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。
总结：其实这些东西都是老生长谈的了，没什么好说的，最重要的就是要知道，写代码的什么地方对应着什么样的内存，这样的内存有什么特点也就一目了然了，比如，函数内部的变量叫做局部变量，它们是存储在栈内存上的，函数结束了，它门就被释放了。

自己管理内存

自己去管理内存，听起来好像很难的样子，其实只要搞清楚了上面的内存分配，那么，自己管理内存也就简单了，自己管理的内存其实只有一块是属于程序员可以操作的，那就是堆内存，我们这里可以把自由存储区和对内存放在一起，因为它们本质上来说是一样的。
下面是一些小tips:

1. 其它的内存轮不到你来管理，我们不要去触犯基本规则即可，比如，你可以通过地址去修改某些内存的内容，但是这些内容又是只读的，可能现在不会出问题，但是尽量避免做这样的事。
2. 关于函数的返回值我想强调一下：
   函数内部临时变量在函数结束后就释放了，那么，我们不应该做的事情就是返回局部变量的引用或者指针，这样势必会造成错误，若是只返回局部变量是没有问题的，因为，会拷贝一份交由你去使用，如果是对象记得为对象内部需要使用堆内存的地方分配内存，否则依然会出错。
3. 不要去使用野指针，野指针是已经被delete或free的内存指针，所以记得把释放的内存指针指向NULL很重要。
4. 自己管理内存，一定要注意自己申请的内存一定要由自己释放，否则会造成内存泄漏。
5. 一定要注意不要让内存溢出，否则容易篡改其它内存的值。
6. 对于新手而言，不知道的内存不要去使用，要想清楚，出现问题要分析自己行为是否正确，程序崩溃了，也不要慌，冷静分析，方法是比困难多的。

智能指针

不要被名字吓到了，我开始一听很装x的样子，其实理解了以后发现也很简单的嘛。

其实智能指针就是用模板编程实现的三种类模板而已，既然知道了是类模板，那么创建出来的是一个个对象，对象内部维护了不同的内存。那么我来看一下吧。
准库提供了三种智能指针来管理动态对象，shared_ptr允许多个智能指针指向同一个对象，unique_ptr则独占所指向的对象，weak_ptr是一种弱引用，指向shared_ptr所管理的对象。

unique_ptr
同一时刻只能有一个unique_ptr指向给定的对象，当unique_ptr被销毁时，它所指向的对象也随之销毁，unique_ptr不支持拷贝和赋值。

class MyClass
{
};

void myDelete(MyClass* obj)
{
    cout << "my delete" << endl;
    delete obj;
}

void testFunc()
{
    auto obj = unique_ptr<MyClass, decltype(myDelete)*>(new MyClass(), myDelete);
}

int main()
{
    testFunc();
    system("pause");
}

shared_ptr
最安全的分配和使用动态内存的方法是调用一个名为make_shared的标准库函数。
当进行拷贝或赋值操作时，每个shared_ptr都会记录有多少个其它shared_ptr指向相同的对象，当引用计数为0时，shared_ptr会自动释放自己管理的对象。说的直白点就是这个类里面维护了一块内存和一个计数变量，每次有对象再次指向这一块内存就让引用计数加1，为0时就自动释放。看看操作吧：

int main()
{
    shared_ptr<int> p = make_shared<int>(2);
    if (p) {
        cout << *p << endl;
    }
    auto str = make_shared<string>(8, '6');
    cout << *str << endl;
    system("pause");
}

int main()
{
    shared_ptr<int> p = make_shared<int>(2);
    if (p.unique()) {
        cout << "唯一的" << endl;
    }
    //返回指向对象的shared_ptr数量
    cout << p.use_count() << endl;
    auto a = p;
    cout << p.use_count() << endl;
    system("pause");
}

我们还可以使用new返回的指针来初始化智能指针，接受指针参数的构造函数是explicit的，必须使用直接初始化来初始化一个智能指针。

    //正确
    shared_ptr<int> p1(new int(33));
    //错误，必须使用直接初始化，接受指针参数的构造函数是explicit的
    shared_ptr<int> p2=new int(44);

还有一些其它使用方式我就不列举了。
weak_ptr
weak_ptr是一种不控制所指向对象生存期的智能指针，它指向由一个shared_ptr管理的对象，将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。这个是由于shared_ptr会发生循环引用的情况，也就是死锁问题！
可以去自行找一下哦。

int main()
{
    auto p = make_shared<int>(33);
    weak_ptr<int> weakValue = p;

    //与weak_ptr共享对象的shared_ptr的数量
    cout << weakValue.use_count() << endl;
    //测试use_count是否为0
    cout << weakValue.expired() << endl;
    //如果expired为true，则返回空指针，否则返回一个指向对象的shared_ptr
    if (auto newValue = weakValue.lock()) {
        cout << newValue << endl;
    }
    system("pause");
}

由于在栈上分配的对象会自动销毁，即使中途发生异常，所以智能指针也能利用这一特性确保异常发生后对象能正常释放。

class MyClass
{
public:
    ~MyClass() { cout << "MyClass Destory..." << endl; }
};

void testFunc()
{
    MyClass obj1;
    auto obj2 = make_shared<MyClass>();
    throw exception();
}

int main()
{
    try{
        testFunc();
    }catch(...){
        cout << "catch exception..." << endl;
    }
    system("pause");
}

总结

其实内存管理是C++程序员必备的技能，不会这么容易掌握，我们只要遵循法则，并不思考、实践、理解，内存管理并不是洪水猛兽，也是非常简单的。

愿每一个程序员都能被温柔相待！