智能指针shared_ptr

如果有可能就使用unique_ptr，然后很多时候对象是需要共享的，因此shared_ptr也就会用得很多。shared_ptr允许多个指向同一个对象，当指向对象的最后一个shared_ptr销毁时，该对象也就会自动销毁。因此，善用shared_ptr，能够远离内存泄漏。

基本使用

它的很多操作与unique_ptr类似。下面是三种常见的定义方式：

shared_ptr sp;//声明一个指向int类型的智能指针
sp.reset(new int(42));
if(sp){
    cout << "sp is not null" <("hello");//sp1是一个智能指针
shared_ptr sp2(new int(42));

而make_shared方式是推荐的一种，它使用一次分配，比较安全。

不能将一个原始指针直接赋值给一个智能指针，例如，下面这种方法是错误的：

std::shared_ptr p = new int(1); //编译报错，不允许直接赋值

shared_ptr不能通过直接将原始指针赋值来初始化，需要通过构造函数和辅助方法来初始化。对于一个未初始化的智能指针，可以通过reset方法来初始化，当智能指针中有值的时候，调用reset会使引用计数减1。另外，智能指针可以通过重载的bool类型操作符来判断智能指针中是否为空（未初始化）。

获取原始指针

当需要获取原始指针时，可以通过get方法来返回原始指针，代码如下：

std::shared_ptr ptr(new int(1));
int* p = ptr.get();

哪些操作会改变计数

我们都知道，当引用计数为0时，shared_ptr所管理的对象自动销毁，那么哪些情况会影响引用计数呢？

赋值

例如：

auto sp = make_shared(1024);//sp的引用计数为1

再比如：

auto sp1 = make_shared("obj1");
auto sp2 = make_shared("obj2");
auto sp1 = sp2;

该操作会减少sp1的引用计数，增加sp2的引用计数。有的人可能不理解，为什么这样还会减少sp1的引用计数？试想一下，sp1指向对象obj1，sp2指向对象obj2，那么赋值之后，sp1也会指向obj2，那就是说指向obj1的就少了，指向obj2的就会多，如果此时没有其他shared_ptr指向obj1，那么obj1将会销毁。

拷贝

例如：

auto sp2 = make_shared(1024);
auto sp1(sp2);

该操作会使得sp1和sp2都指向同一个对象。而关于拷贝比较容易忽略的就是作为参数传入函数：

auto sp2 = make_shared(1024);
func(sp2);//func的执行会增加其引用计数

可以看一个具体的例子：

#include
#include
void func0(std::shared_ptr sp)
{
    std::cout<<"fun0:"< &sp)
{
    std::cout<<"fun1:"<(1024);
    func0(sp);
    func1(sp);
    return 0;
}

其运行输出结果为：

fun0:2                                                    
fun1:1 

很显然，fun0，拷贝了shard_ptr sp，而fun1，并没有拷贝，因此前者会增加引用计数，计数变为2，而后者并不影响。

reset

调用reset会减少计数：

sp.reset()

而如果sp是唯一指向该对象的，则该对象被销毁。

应当注意使用的方式

虽然shared_ptr能很大程度避免内存泄漏，但是使用不当，仍然可能导致意外发生。

存放于容器中的shared_ptr

如果你的容器中存放的是shared_ptr，而你后面又不再需要它时，记得使用erase删除那些不要的元素，否则由于引用计数一直存在，其对象将始终得不到销毁，除非容器本身被销毁。

不要使用多个裸指针初始化多个shared_ptr

注意，下面方式是不该使用的：

#include
#include
int main()
{
    auto *p = new std::string("hello");
    std::shared_ptr sp1(p);
    /*不要这样做！！*/
    std::shared_ptr sp2(p);
    return 0;
}

这样会导致两个shared_ptr管理同一个对象，当其中一个被销毁时，其管理的对象会被销毁，而另外一个销毁时，对象会二次销毁，然而实际上，对象已经不在了，最终造成严重后果。而与这种情况类似的，就是使用get()获取裸指针，然后去初始化另外一个shared_ptr，或者delete get返回的指针：

#include
#include
int main()
{
    auto sp = std::make_shared("wechat:shouwangxiansheng");
    std::string *p = sp.get();
    std::shared_ptr sp2(p);/*不要这样做!!*/
    delete p;/*不要这样做*/
    return 0;
}

循环引用

在对象之间出现循环引用时，会使得共享指针引用计数不会降到０，也就不能销毁。

 

#include 
#include 
using std::shared_ptr;
using std::make_shared;
// 一段内存泄露的代码
struct Son;
struct Father{
    shared_ptr son_;
};
struct Son{
    shared_ptr father_;
};
int main() 
{
    auto father = make_shared();
    auto son = make_shared();
    father->son_ = son;
    son->father_ = father;
    std::cout<<"one father's son:"<

---

编译运行结果为：

xhy@ubuntu:~/cpp_learn/share_ptr$ ./test 
one father's son:2
one son's father:2

函数结束前，堆上的两个对象的引用计数都是２，所以即便函数结束，将两个栈上的的共享指针分别析构，最后堆上的两个对象的引用数也不会为０，而是１，两个对象不会调用析构函数进行析构，从而内存泄漏。参考weak_ptr可以解决。

如果对象不是new分配的，请传递删除器

与unique_ptr类似，它可以指定删除器，默认是使用delete。例如：

#include
#include
#include
void myClose(int *fd)
{
    close(*fd);
}
int main()
{
    int socketFd = 10;//just for example
    std::shared_ptr up(&socketFd,myClose);
    return 0;
}

关于指定删除器

智能指针初始化可以指定删除器，代码如下：

void DeleteIntPtr(int* p)
{
    delete p;
}
std::shared_ptr p(new int,DeleteIntPtr);

当p的引用计数为0时，自动调用删除器DeleteIntPtr来释放对象的内存。删除器可以是一个lambda表达式，因此，上面的写法还可以改为：

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

当我们用shared_ptr管理动态数组时，需要指定删除器，因为std::shared_ptr的默认删除器不支持数组对象，代码如下：

std::shared_ptr p(new int[10],[](int* p){delete[] p;}); //指定delete[]

也可以将std::default_delete作为删除器。default_delete的内部是通过调用delete来实现功能的，代码如下：

std::shared_ptr p(new int[10],std::default_delete );

另外，还可以通过封装一个make_shared_array方法来让shared_ptr支持数组，代码如下：

template
shared_ptr make_shared_array(size_t size)
{
    return shared_ptr(new T[size],default_delete());
}

测试代码如下：

std::shared_ptr p = make_shared_array(10);
std::shared_ptr p = make_shared_array(10);

与unique_ptr的区别

首先最明显的区别自然是它们一个是专享对象，一个是共享对象。而正是由于共享，包括要维护引用计数等，它带来的开销相比于unique_ptr来说要大。另外，shared_ptr无法直接处理数组，因为它使用delete来销毁对象，而对于数组，需要用delete[]。因此，需要指定删除器：

#include
#include
int main()
{
    auto sp = std::make_shared("wechat:shouwangxiansheng");
    std::string *p = sp.get();
    //std::shared_ptr sp1(new int[10]);//不能这样
    std::shared_ptr sp1(new int[10],[](int *p){delete[] p;});
    return 0;
}

示例中使用了lambda表达式。不过一般来说，好好的容器不用，为什么要用动态数组呢？

参考资料：https://xhy3054.github.io/cpp-shared-ptr/

总结

以上就是shared_ptr基本内容，一般来说，规范使用shared_ptr能很大程度避免内存泄露。注意，shared_ptr提供，*，->操作，不直接提供指针运算和[]。