[c++11]智能指针学习笔记

C#、Java、python和go等语言中都有垃圾自动回收机制，在对象失去引用的时候自动回收，而且基本上没有指针的概念，而C++语言不一样，C++充分信任程序员，让程序员自己去分配和管理堆内存，如果管理的不好，就会很容易的发生内存泄漏问题，而C++11增加了智能指针(Smart Pointer)。主要分为shared_ptr、unique_ptr和weak_ptr三种，使用时需要引用头文件。c++98中还有auto_ptr，基本被淘汰了，不推荐使用。而c++11中shared_ptr和weak_ptr都是参考的boost库中实现的。

本文有很多代码片段，如果不喜欢的代码风格，请移步我的SegmentFault博客。

原始指针

c语言中最常使用的是malloc()函数分配内存，free()函数释放内存，而c++中对应的是new、delete关键字。malloc()只是分配了内存，而new则更进一步，不仅分配了内存，还调用了构造函数进行初始化。使用示例：

int main()
{
    // malloc返回值是 void*
    int* argC = (int*)malloc(sizeof(int));
    free(argC);

    char*c = (char*)malloc(100);
    free(c);

    char *age = new int(25); //做了两件事情 1.分配内存 2.初始化
    int* height = new int(160);

    delete height;
    delete age;
    
    char* arr = new int[100];
    delete[] arr;
    /*delete数组需要使用delete[]，事实上，c++原始支持的数据结构组成的
    数组不需要[]也可以，但 自定义的数据类型组成的数组必须使用delete[]*/
}

new和delete必须成对出现，有时候是不小心忘记了delete，有时候则是很难判断在这个地方自己是不是该delete，这个和资源的生命周期有关，这个资源是属于我这个类管理的还是由另外一个类管理的，如果是我管理的，就由我来delete，由别人管理的就由别人delete，我就算析构了也不影响该资源的生命周期。例如：

// 情况1： 需要自己delete
const char* getName() {
    char *valueGroup = new char[1000];
    // do something
    return valueGroup;
}
// 情况2： 不需要自己delete
const char* getName2() {
    static char valueGroup[1000];
    // do something
    return valueGroup;
}

只通过函数签名来看，这两个函数没有什么区别，但是由于实现的不同，有时候需要自己管理内存，有时候不需要，这个时候就需要看文档说明了。这就是使用一个"裸"指针不好的地方。

一点改进是，如果需要自己管理内存的话，最好显示的将自己的资源传递进去，这样的话，就能知道是该资源确实应该由自己来管理。

char *getName(char* v, size_t bufferSize) {
    //do something
    return v;
}

上面还是小问题，自己小心一点，再仔细看看文档，还是有机会避免这些情况的。但是在c++引入异常的概念之后，程序的控制流就发生了根本性的改变，在写了delete的时候还是有可能发生内存泄漏。如下例：

void badThing(){
    throw 1;// 抛出一个异常
}

void test() {
    char* a = new char[1000];

    badThing();
    // do something
    delete[] a;
}
int main() {
    try {
        test();
    }
    catch (int i){
        cout << "error happened " << i << endl;
    }
}

上面的new和delete是成对出现的，但是程序在中间的时候抛出了异常，由于没有立即捕获，程序从这里退出了，并没有执行到delete，内存泄漏还是发生了。

C++中的构造函数和析构函数十分强大，可以使用构造和析构解决这种问题，比如：

class SafeIntPointer {
public:
    explicit SafeIntPointer(int v) : m_value(new int(v)) { }
    ~SafeIntPointer() {
        delete m_value;
        cout << "~SafeIntPointer" << endl;
    }
    int get() { return *m_value; }
private:
    int* m_value;
};

void badThing(){
    throw 1;// 抛出一个异常
}

void test() {
    SafeIntPointer a(5);

    badThing();
}
int main() {
    try {
        test();
    }
    catch (int i){
        cout << "error happened " << i << endl;
    }
}

// 结果
// ~SafeIntPointer
// error happened 1

可以看到，就算发生了异常，也能够保证析构函数成功执行！这里的例子是这个资源只有一个人使用，我不用了就将它释放掉。但还有种情况，一份资源被很多人共同使用，要等到所有人都不再使用的时候才能释放掉，对于这种问题，就需要对上面的SafeIntPointer增加一个引用计数，如下：

class SafeIntPointer {
public:
    explicit SafeIntPointer(int v) : m_value(new int(v)), m_used(new int(1)) { }
    ~SafeIntPointer() {
        cout << "~SafeIntPointer" << endl;
        (*m_used) --; //引用计数减1
        if(*m_used <= 0){
            delete m_used;
            delete m_value;
            cout << "real delete resources" << endl;
        }

    }
    SafeIntPointer(const SafeIntPointer& other) {
        m_used = other.m_used;
        m_value = other.m_value;
        (*m_used)++; //引用计数加1
    }
    SafeIntPointer& operator= (const SafeIntPointer& other) {
        if (this == &other) // 避免自我赋值!!
           return *this;

        m_used = other.m_used;
        m_value = other.m_value;
        (*m_used)++; //引用计数加1
        return *this;
    }

    int get() { return *m_value; }
    int getRefCount() {
        return *m_used;
    }

private:
    int* m_used;
    int* m_value;
};

int main() {
    SafeIntPointer a(5);
    cout << "ref count = " << a.getRefCount() << endl;
    SafeIntPointer b = a;
    cout << "ref count = " << a.getRefCount() << endl;
    SafeIntPointer c = b;
    cout << "ref count = " << a.getRefCount() << endl;
}

/*
ref count = 1
ref count = 2
ref count = 3
~SafeIntPointer
~SafeIntPointer
~SafeIntPointer
real delete resources
*/

可以看到每一次赋值，引用计数都加一，最后每次析构一次后引用计数减一，知道引用计数为0，才真正释放资源。要写出一个正确的管理资源的包装类还是蛮难的，比如上面那个上面例子就不是线程安全的，只能属于一个玩具，在实际工程中简直没法用。而到了C++11，终于提供了一个共享的智能指针解决这个问题。

shared_ptr共享的智能指针

shared_ptr的基本使用

shared_ptr的基本使用很简单，看几个例子就明白了：

#include 
#include 

class Object {
public:
    Object(int id) : m_id(id) {
        std::cout << "init obj " << std::endl;
    }
    ~Object() {
        std::cout << "bye bye" << m_id << std::endl;
    }
    int id() const {
        return m_id;
    }
private:
      int m_id;
};

// 取个别名 让写起来更方便
typedef std::shared_ptr