c++11新特性之智能指针

时间 2020-06-10

标签 c++11 特性智能指针栏目 C&C++ 繁體版

原文原文链接

不少人谈到c++，说它特别难，可能有一部分就是由于c++的内存管理吧，不像java那样有虚拟机动态的管理内存，在程序运行过程当中可能就会出现内存泄漏，然而这种问题其实均可以经过c++11引入的智能指针来解决，相反我还认为这种内存管理仍是c++语言的优点，由于尽在掌握。java

c++11引入了三种智能指针：c++

std::shared_ptr
std::weak_ptr
std::unique_ptr

shared_ptr

shared_ptr使用了引用计数，每个shared_ptr的拷贝都指向相同的内存，每次拷贝都会触发引用计数+1，每次生命周期结束析构的时候引用计数-1，在最后一个shared_ptr析构的时候，内存才会释放。app

使用方法以下：源码分析

struct ClassWrapper {

    ClassWrapper() {
        cout << "construct" << endl;
        data = new int[10];
    }
    
    ~ClassWrapper() {
        cout << "deconstruct" << endl;
        if (data != nullptr) {
            delete[] data;
        }
    }

    void Print() {
        cout << "print" << endl;
    }

    int* data;
};

void Func(std::shared_ptr<ClassWrapper> ptr) {
    ptr->Print();
}

int main() {
    auto smart_ptr = std::make_shared<ClassWrapper>();
    auto ptr2 = smart_ptr; // 引用计数+1
    ptr2->Print();
    Func(smart_ptr); // 引用计数+1
    smart_ptr->Print();
    ClassWrapper *p = smart_ptr.get(); // 能够经过get获取裸指针
    p->Print();
    return 0;
}

智能指针还能够自定义删除器，在引用计数为0的时候自动调用删除器来释放对象的内存，代码以下：post

std::shared_ptr<int> ptr(new int, [](int *p){ delete p; });

关于shared_ptr有几点须要注意：优化

不要用一个裸指针初始化多个shared_ptr，会出现double_free致使程序崩溃
经过shared_from_this()返回this指针，不要把this指针做为shared_ptr返回出来，由于this指针本质就是裸指针，经过this返回可能会致使重复析构，不能把this指针交给智能指针管理。this
```
class A {
      shared_ptr<A> GetSelf() {
        return shared_from_this();
        // return shared_ptr<A>(this); 错误，会致使double free
    }  
};
```
尽可能使用make_shared，少用new。
不要delete get()返回来的裸指针。
不是new出来的空间要自定义删除器。

要避免循环引用，循环引用致使内存永远不会被释放，形成内存泄漏。spa

using namespace std;
struct A;
struct B;

struct A {
    std::shared_ptr<B> bptr;
    ~A() {
        cout << "A delete" << endl;
    }
};

struct B {
    std::shared_ptr<A> aptr;
    ~B() {
        cout << "B delete" << endl;
    }
};

int main() {
    auto aaptr = std::make_shared<A>();
    auto bbptr = std::make_shared<B>();
    aaptr->bptr = bbptr;
    bbptr->aptr = aaptr;
    return 0;
}

上面代码，产生了循环引用，致使aptr和bptr的引用计数为2，离开做用域后aptr和bptr的引用计数-1，可是永远不会为0，致使指针永远不会析构，产生了内存泄漏，如何解决这种问题呢，答案是使用weak_ptr。指针

weak_ptr

weak_ptr是用来监视shared_ptr的生命周期，它无论理shared_ptr内部的指针，它的拷贝的析构都不会影响引用计数，纯粹是做为一个旁观者监视shared_ptr中管理的资源是否存在，能够用来返回this指针和解决循环引用问题。c++11

做用1：返回this指针，上面介绍的shared_from_this()其实就是经过weak_ptr返回的this指针，这里参考我以前写的源码分析shared_ptr实现的文章，最后附上连接。

做用2：解决循环引用问题。

struct A;
struct B;

struct A {
    std::shared_ptr<B> bptr;
    ~A() {
        cout << "A delete" << endl;
    }
    void Print() {
        cout << "A" << endl;
    }
};

struct B {
    std::weak_ptr<A> aptr; // 这里改为weak_ptr
    ~B() {
        cout << "B delete" << endl;
    }
    void PrintA() {
        if (!aptr.expired()) { // 监视shared_ptr的生命周期
            auto ptr = aptr.lock();
            ptr->Print();
        }
    }
};

int main() {
    auto aaptr = std::make_shared<A>();
    auto bbptr = std::make_shared<B>();
    aaptr->bptr = bbptr;
    bbptr->aptr = aaptr;
    bbptr->PrintA();
    return 0;
}
输出：
A
A delete
B delete

unique_ptr

std::unique_ptr是一个独占型的智能指针，它不容许其它智能指针共享其内部指针，也不容许unique_ptr的拷贝和赋值。使用方法和shared_ptr相似，区别是不能够拷贝：

using namespace std;

struct A {
    ~A() {
        cout << "A delete" << endl;
    }
    void Print() {
        cout << "A" << endl;
    }
};


int main() {
    auto ptr = std::unique_ptr<A>(new A);
    auto tptr = std::make_unique<A>(); // error, c++11还不行，须要c++14
    std::unique_ptr<A> tem = ptr; // error, unique_ptr不容许移动
    ptr->Print();
    return 0;
}

unique_ptr也能够像shared_ptr同样自定义删除器，使用方法和shared_ptr相同。

关于c++11的智能指针的使用就介绍到这里，源码分析能够看我以前的文章https://www.jianshu.com/p/b6a...
你们有问题能够联系我哦~

参考资料

https://www.jianshu.com/p/b6a...

https://juejin.im/post/5dcaa8...

《深刻应用c++11:代码优化与工程级应用》更多文章，请关注个人V X 公主号：程序喵大人，欢迎交流。