公司里小组组织c++知识的分享会，正好我手上碰到过几个purify的内存泄露问题，就借这里总结一下c++的内存问题。
　　借鉴陈硕总结的分类，c++大致的内存问题有以下几个方面：
　　１.缓冲区溢出
　　在使用自己编写的缓冲区或者使用不安全的函数时，会遇到类似数组越界的缓冲区溢出问题，Linux内核的解决办法是栈随机化，金丝雀的检测，具体的攻击手段和例子，可以参考我另一篇的buffer lab实验。在自己写程序的时候，最重要的一点是记录或者限制缓冲区的长度，使用vector<char>这样的容器,strncpy这样更安全的函数。
　　在purify检测的时候，使用的就是类似金丝雀的机制，在缓冲区前后插入特殊的数值，如果其数值被修改了，就是溢出。
　　2.空悬指针/野指针
　　指针在所指的内存空间被释放后，没有置为NULL，指针的生存期还没有结束，这时候指针所指的区域是个随机值。并且可以继续使用！！！
　　下面使用代码进行验证，环境为win7，64位，Dev-c++5.11，gcc（c11）。

void testNullPtr(){
    int *p=new int(10);
    delete p;
    cout<<*p<<endl;
    *p=20;
    cout<<*p<<endl;
}

　　上面代码的运行结果：
　　
　　可以看出第一次是随机值，第二次竟然正常更新了。
　　在正常工程使用中，指针delete完之后置NULL，以及不要返回局部指针变量！！！如果两个指针指向同一内存，其中一个置NULL，依然解决不了空悬指针的问题。如下：
　　重置ｐ对ｑ没有任何作用！

    int *p(new int(42));
    auto q=p;
    delete p;
    p=nullptr;

　　关于局部变量的示例代码：
　　

    char *itoa(int n){
        char buf[43];
        sprintf(buf,"%d",n);
        return buf;
    }

　　将buf声明为static即可。

　　3.重复释放
　　非常经典的double free问题，运行如下程序：
　　

void testDoubleFree(){
    int *p=new int(10);
    delete p;
    delete p;
}

　　运行结果会产生运行时错误，调试状态下会有SIGTRAP信号。
　　解决办法也是指针置NULL。拓展一下，指针置NULL之后还可以释放吗？答案是可以。这里需要研究一下new和delete。
　　new和delete其实就是对malloc和free的封装。

• 对于简单数据，直接调用operator new分配内存。但是可以使用new_handler来处理new失败的情况。
• 另一处不同，malloc失败返回NULL，而new抛出异常。
• 对于复杂数据结构，例如对象，先调用operator new分配内存后，在调用其构造函数。
• delete对于简单数据，直接调用free。

• 对于复杂的数据结构，先析构，后delete。

  free的部分代码如下（glibc）:
  函数会对指针进行NULL的检测，为空直接返回，因此delete完之后置NULL可以避免重复释放问题。

    if (ptr == NULL)
        {
          catomic_increment (&calls[idx_free]);
          return;
        }

　　４.内存泄露
　　这一问题可以通过智能指针解决，下面再细讲。
　　
　　5.不配对的new[]/delete
　　new和delete在声明使用的时候需要配对使用。
　　

    int *p=new int(10);
    delete p;
    int *pa=new int[10];
    delete []pa;

　　当我们释放一个指向数组的指针时，它指示编译器指针指向一个对象数组的第一个元素，元素按逆序销毁。
　　
　　承接上面对new和delete的研究，在调用new[]和delete[]的时候。
　　

• 对于简单数据，new[]计算好大小后调用operator new。
• 对于复杂数据类型，先分配内存，写入数组大小，然后调用N次构造。
• 对于简单数据类型，delete[]和delete效果一样。

• 对于复杂的数据类型，delete[]先析构，后释放空间。

  　　注意！！！以下代码正常运行，编译器没有警告。
  　　

class Obj{
    public:
        Obj(){}
};
void FitNewDelete(){

    Obj *p=new Obj[3];
    delete p;
}

　　在《ｃ＋＋primer》中提到，上面的行为是未定义的。可能会崩溃，可以是行为异常。比较一劳永逸的办法是使用vector代替数组。
　　6.内存碎片
　　常用的解决办法是实现自己的memory pool，这里不详细讨论了，因为首先现在的malloc有所优化，第二这个问题有时候影响不大。
　　
　　上面参照了《linux多线程服务端》的分类，现在讲解一下purify的问题，purify的内存问题主要分为以下几类。
　　
　　这里不详细解释了，英文应该很好懂。
　　讲一下在工作过程中碰到的两个实例。
　　第一个是ＵＭＲ，未初始化内存读的问题，很多时候，这个问题并不算问题，不具有准确性。
　　
　　例如下面的代码就会有ＵＭＲ问题，这里是因为结构体的字节填充，其中smth的field2会因为4字节的地址对齐的需要，被填充三个字节。

struct something {
    int field1;
    char field2;
};

/* ... */

struct something smth, smth2;
smth.field1 = 1;
smth.field2 = 'A';

smth2 = smth;

　　而我遇到的UMR代码如下：
　　

struct test: public std::binary_function<x, y, bool>
    {
        bool operator() (const x& thisInfo, y otherEntityType) const
        {
            return (thisInfo.entityType == otherEntityType);
        }
    };

　　这个函数乍看没有任何问题，函数的绑定和函数操作而已，如果做类似调用，就会有ＵＭＲ问题。
　　

this->ritTypeInfo =  std::find_if(RITS_begin, RITS_end, bind2nd(test(), entityType));

　　问题出在编译器自己合成的构造函数和拷贝构造上，如果你不希望编译器合成，或者不清楚合成的代码效果，请明确的构造出来。这里的解决办法就是构造出空的构造函数和拷贝构造函数即可。
　　接下来的一个例子也与拷贝构造函数和拷贝赋值运算符有关。
　　首先明确一下两个函数出现的地方，拷贝赋值是同类对象赋值时出现。拷贝构造是在使用＝定义变量时、将一个对象作为实参传递给一个非引用类型的形参、以及从一个返回类型为非引用类型的函数返回一个对象时使用。
　　如果自己没有定义，编译器会为我们合成一个。实例代码如下：
　　

    class CheckApp{};
    class check{
        CheckApp *pCheckApp;
        public:
            check(){
                pCheckApp=new CheckApp(); 
            }
            ~check(){
                if(pCheckApp!=NULL){
                    delete pCheckApp;
                    pCheckApp=NULL;
                }
            }
    };

　　这里在使用拷贝赋值和拷贝构造函数时，编译器会为我们合成拷贝构造和拷贝赋值函数。类似下面的代码：
　　

    check::check(const check& rhs)
        :pCheckApp(rhs.pCheckApp){}
    check& check::operator=(const check& rhs){
        if(this!=&rhs){
            pCheckApp=rhs.pCheckApp;
        }
        return *this;
    }

　　这个代码有什么问题？看一下面的图片就知道了。
　　

　　对于指针型的成员变量，合成的拷贝赋值和拷贝构造只是复制了指针本身，而不是指向的对象，这叫做浅拷贝，当其中的s1或者s2析构释放的时候，它所指向的内存空间就被释放掉了，另一个指针就变成了野指针，会出现double free。同时也存在其中一个指针更改值造成另一个对象值也更改的现象。
　　应急的解决办法是自己完成拷贝构造和拷贝赋值。代码如下：
　　

    //先完成拷贝构造，下面赋值要用
    check::check(const check& rhs){
         pCheckApp=new CheckApp();
         if(pCheckApp!=NULL){
            *pCheckApp=*(rhs.pCheckApp);
        }
    }
    //进行深拷贝，按值拷贝
    check& check::operator=(const check &rhs){
        //这个判断是防止自赋值 a=a
        if(this!=&rhs){
        //使用构造局部变量，进行成员交换
        //局部变量出作用域会自动释放
        //防止new失败，简化设计
            check tmp(rhs);
            CheckApp *tmpCheckApp=pCheckApp;
            pCheckApp=tmp.pCheckApp;
            tmp.pCheckApp=tmpCheckApp;
        }
        return *this;
    }

　　上面提到应急两个字，言外之意，应该有更好的解决办法，相信各位应该也能想到了，智能指针。
　　简单来说，智能指针在上图的S1和S2与内存空间之间加了一个代理层，一个新的对象，让s1和s2所指的对象永久有效，先命名为proxy,同时把两个指针都变成对象，sp1,sp2。proxy有两个成员，指针和计数器。sp1析构后，计数器减一，计数为0时，销毁proxy指针指向的对象。
　　空悬指针野指针可以用shared_ptr/weak_ptr解决，对于重复释放可以选择unique_ptr与scoped_ptr解决。
　　其中shared_ptr、weak_ptr、scoped_ptr为boost库模板。
　　c11吸收了shared_ptr、weak_ptr并使用具有移动语意的unique_ptr代替scoped_ptr，它们声明在memory头文件中。
　　这里简单介绍一下用法，代码如下，更多的查看手册：
　　shared_ptr运行多个指针指向同一个对象，这就可以解决上面的浅拷贝问题。　　
　　注意shared_ptr有一个非常有用的特性，删除器，可以使析构动作在构造时被捕捉。

    template<class T>
struct endPtr{
    //主要用于非动态分配的对象
    //用于不具有良好的析构函数的对象
    //deleter是个泛型类型，需要operator() 
    void operator()(T* p){
        delete [] p;
        cout<<"now delete"<<endl;   
    } 

};
void testSharePtr(){
    //shared_ptr<int> q(new int(10)); 不建议
    shared_ptr<int> q=make_shared<int> (42);
    //c11 构造 
    auto p=make_shared<int> (40);
    //使用 
    cout<<"p:"<<*p<<" use: "<<p.use_count()<<endl;
    //引用数 
    cout<<"q:"<<q.use_count()<<endl;
    //判断
    cout<<"is unique?: "<<q.unique()<<endl; 
    p=q;
    cout<<"p:"<<p.use_count()<<endl;
    cout<<"q:"<<q.use_count()<<endl;
    int *tmp=new int[100];
    //定义自己的删除器
    shared_ptr<int> r(tmp,endPtr<int>());
}

　　结果如下：
　　
　　
　　一个unique_ptr只能指向一个给定对象，不支持普通的拷贝和赋值，但是可以使用函数release或者reset转移指针所有权，scoped_ptr则不允许，两者异同：
　　A auto_ptr is a pointer with copy and with move semantics and ownership (=auto-delete).
　　
　　A unique_ptr is a auto_ptr without copy but with move semantics.
　　
　　A scoped_ptr is a auto_ptr without copy and without move semantics.
　　
　　auto_ptr‍s are allways a bad choice – that is obvious.

　　Whenever you want to explicitely have move semantics, use a unique_ptr.
　　
　　Whenever you want to explicitely disallow move semantics,use a scoped_ptr.

　　最后介绍一下weak_ptr,shared_ptr是强引用，拿铁丝绑着对象，而weak_ptr是棉线挂着（陈硕的比喻），weak_ptr不控制所指对象的生命周期，对象的释放和weak_ptr无关，这种弱引用可以拿来打破shared_ptr的循环引用问题，两个shared_ptr互相引用，会造成对象无法释放。
　　weak_ptr起到一个检测的作用！！！
　　

    auto p=make_shared<int> (42);
    //不改变引用计数
    weak_ptr<int> wp(p);
    //由于对象可能不存在，使用lock函数，如果有的话，返回shared_ptr
    if(shared_ptr<int> np=wp.lock()){
    }

　　weak_ptr还可以用于弱回调，把shared_ptr绑定到function里，会延长对象的生命周期，如果想实现对象活着就调用，否则忽略的效果，可以使用weak_ptr。
　　最后对weak_ptr和shared_ptr做一个简单的分析。
　　
　　unique_ptr使用元素，指针和删除器。

      // unique_ptr内部片段
      template <typename _Tp, typename _Dp = default_delete<_Tp> >
    class unique_ptr
    {
      // use SFINAE to determine whether _Del::pointer exists
      class _Pointer
      {
    template<typename _Up>
      static typename _Up::pointer __test(typename _Up::pointer*);

    template<typename _Up>
      static _Tp* __test(...);

    typedef typename remove_reference<_Dp>::type _Del;

      public:
    typedef decltype(__test<_Del>(0)) type;
      };

      typedef std::tuple<typename _Pointer::type, _Dp>  __tuple_type;
      __tuple_type                                      _M_t;

    public:
      typedef typename _Pointer::type   pointer;
      typedef _Tp                       element_type;
      typedef _Dp                       deleter_type;
    }；

　　shared_ptr在基类的基础上加上删除器参数。下面是示意性的摘录。
　　

      template<typename _Tp>
    class shared_ptr : public __shared_ptr<_Tp>
    {
    public:
        //其中一个构造函数
        template<typename _Tp1, typename _Deleter>
    shared_ptr(_Tp1* __p, _Deleter __d)
        : __shared_ptr<_Tp>(__p, __d) { }
    };
     template<typename _Tp, _Lock_policy _Lp>
    class __shared_ptr
    {
    public:
      typedef _Tp   element_type;
    protected:
      friend class __weak_ptr<_Tp, _Lp>;
    private:
       void*
      _M_get_deleter(const std::type_info& __ti) const noexcept
      { return _M_refcount._M_get_deleter(__ti); }
        _Tp*           _M_ptr;         // Contained pointer.
      __shared_count<_Lp>  _M_refcount;    // Reference counter.
    };

　　最后给一个玩具型的参考实现，来自c++primer答案参考。
　　

/***************************************************************************
*  @file       shared_pointer.hpp
*  @author     Yue Wang
*  @date       04  Feb 2014
*                  Jul 2015
*                  Oct 2015 
*  @remark     This code is for the exercises from C++ Primer 5th Edition
*  @note
***************************************************************************/

#pragma once
#include <functional>
#include "delete.hpp"

namespace cp5
{
    template<typename T>
    class SharedPointer;

    template<typename T>
    auto swap(SharedPointer<T>& lhs, SharedPointer<T>& rhs)
    {
        using std::swap;
        swap(lhs.ptr, rhs.ptr);
        swap(lhs.ref_count, rhs.ref_count);
        swap(lhs.deleter, rhs.deleter);
    }

    template<typename T>
    class SharedPointer
    {
    public:
        //
        //  Default Ctor
        //
        SharedPointer()
            : ptr{ nullptr }, ref_count{ new std::size_t(1) }, deleter{ cp5::Delete{} }
        { }
        //
        //  Ctor that takes raw pointer
        //
        explicit SharedPointer(T* raw_ptr)
            : ptr{ raw_ptr }, ref_count{ new std::size_t(1) }, deleter{ cp5::Delete{} }
        { }
        //
        //  Copy Ctor
        //
        SharedPointer(SharedPointer const& other)
            : ptr{ other.ptr }, ref_count{ other.ref_count }, deleter{ other.deleter }
        {
            ++*ref_count;
        }
        //
        //  Move Ctor
        //
        SharedPointer(SharedPointer && other) noexcept
            : ptr{ other.ptr }, ref_count{ other.ref_count }, deleter{ std::move(other.deleter) }
        {
            other.ptr = nullptr;
            other.ref_count = nullptr;
        }
        //
        //  Copy assignment
        //
        SharedPointer& operator=(SharedPointer const& rhs)
        {
            //increment first to ensure safty for self-assignment
            ++*rhs.ref_count;
            decrement_and_destroy();
            ptr = rhs.ptr, ref_count = rhs.ref_count, deleter = rhs.deleter;
            return *this;
        }
        //
        //  Move assignment
        //
        SharedPointer& operator=(SharedPointer && rhs) noexcept
        {
            cp5::swap(*this, rhs);
            rhs.decrement_and_destroy();
            return *this;
        }
        //
        //  Conversion operator
        //
        operator bool() const
        {
            return ptr ? true : false;
        }
        //
        //  Dereference
        //
        T& operator* () const
        {
            return *ptr;
        }
        //
        //  Arrow
        //
        T* operator->() const
        {
            return &*ptr;
        }
        //
        //  Use count
        //
        auto use_count() const
        {
            return *ref_count;
        }
        //
        //  Get underlying pointer
        //
        auto get() const
        {
            return ptr;
        }
        //
        //  Check if the unique user
        //
        auto unique() const
        {
            return 1 == *refCount;
        }
        //
        //  Swap
        //
        auto swap(SharedPointer& rhs)
        {
            ::swap(*this, rhs);
        }
        //
        // Free the object pointed to, if unique
        //
        auto reset()
        {
            decrement_and_destroy();
        }
        //
        // Reset with the new raw pointer
        //
        auto reset(T* pointer)
        {
            if (ptr != pointer)
            {
                decrement_n_destroy();
                ptr = pointer;
                ref_count = new std::size_t(1);
            }
        }
        //
        //  Reset with raw pointer and deleter
        //
        auto reset(T *pointer, const std::function<void(T*)>& d)
        {
            reset(pointer);
            deleter = d;
        }
        //
        //  Dtor
        //
        ~SharedPointer()
        {
            decrement_and_destroy();
        }
    private:
        T* ptr;
        std::size_t* ref_count;
        std::function<void(T*)> deleter;

        auto decrement_and_destroy()
        {
            if (ptr && 0 == --*ref_count)
                delete ref_count, 
                deleter(ptr);
            else if (!ptr)
                delete ref_count;
            ref_count = nullptr;
            ptr = nullptr;
        }
    };
}//namespace