C++智能指针

目录

1，shared_ptr和make_shared

（1）基本用法

（2）在函数中的传递

（3）在stl中的嵌套使用

2，unique_ptr和make_unique

（1）基本用法

（2）被指向类的析构函数

3，auto_ptr

4，weak_ptr

---

1，shared_ptr和make_shared

（1）基本用法

#include<iostream>
#include <c++/memory>
using namespace std;

class A
{
public:
    ~A()
    {
        cout<<" des ";
    }
};

int main()
{
    shared_ptr<A>p=make_shared<A>(A());
    shared_ptr<A>p2=p;
    cout<<p.use_count();
    return 0;
}

输出： des 2 des

共享的智能指针，shared_ptr其实是模板类，成员use_count就是引用次数，

当指针（其实是shared_ptr的实例）的生命周期结束之后，析构函数被自动调用，于是计数会自动减1

当引用次数减到0的时候，指向的对象会被自动删除。

上述代码之所以调用了2次析构函数，是因为模板函数make_shared传参。

另外一种写法：

int main()
{
    shared_ptr<A>p(new A());
    shared_ptr<A>p2=p;
    cout<<p.use_count();
    return 0;
}

输出： 2 des

（2）在函数中的传递

#include<iostream>
#include<vector>
using namespace std;

class A
{
public:
	~A()
	{
		cout << " des ";
	}
};

vector< shared_ptr<A>>v;

void f(shared_ptr<A>p)
{
	v.push_back(p);
}

void f2()
{
	shared_ptr<A>p = make_shared<A>(A());
	cout << p.use_count();
	f(p);
}

int main()
{
	f2();
	cout << " v.size=" << v.size();
	return 0;
}

输出  des 1 v.size=1 des

说明f2函数退出的时候，智能指针还在，因为它被全局变量v引用了，直到main函数退出才销毁智能指针。

（3）在stl中的嵌套使用

#include<iostream>
#include<map>
#include<vector>
using namespace std;

class A 
{
public:
	~A()
	{
		cout << "des A";
	}
};

int main()
{
	shared_ptr<A>p = make_shared<A>(A());
	cout << "\nnext\n";
	map<int, vector<shared_ptr<A>>>m;
	m[1].emplace_back(p);
	m.erase(1);
	return 0;
}

输出：

des A
next
des A

所以在map的erase时，会析构vector，所以会析构其中的每一个指针指针。

2，unique_ptr和make_unique

（1）基本用法

#include<iostream>
#include <c++/memory>
using namespace std;

class A
{
public:
    int x=3;
    ~A()
    {
        cout<<" des ";
    }
};

int main()
{
    unique_ptr<A>p=make_unique<A>(A());
    // unique_ptr<A>p2=p;
    unique_ptr<A>p2=move(p);
    // cout<<p->x;
    cout<<p2->x;
    return 0;
}

输出： des 3 des

另外一种写法：

int main()
{
    unique_ptr<A>p(new A());
    // unique_ptr<A>p2=p;
    unique_ptr<A>p2=move(p);
    // cout<<p->x;
    cout<<p2->x;
    return 0;
}

独占的智能指针，只能移动，不能拷贝，

unique_ptr的源码是这么写的：

      // Disable copy from lvalue.
      unique_ptr(const unique_ptr&) = delete;
      unique_ptr& operator=(const unique_ptr&) = delete;

（2）被指向类的析构函数

如果被指向类没有构造函数，但是也没有调用：

class A {
public:
	A()=delete;
public:
	int x;
};
class B {
public:
	std::unique_ptr<A> aiModel_;
	int x;
};
int main()
{
	B b;
	cout << b.x;
	return 0;
}

这是可以编译运行的。

但如果是：

class A {
public:
	A()=delete;
	~A()=delete;
public:
	int x;
};
class B {
public:
	std::unique_ptr<A> aiModel_;
	int x;
};
int main()
{
	B b;
	cout << b.x;
	return 0;
}

则会编译失败，即unique_ptr一定是需要被指向类有析构函数。

3，auto_ptr

auto_ptr是古老的智能指针，基本被抛弃了，

auto_ptr也是用来实现自动析构的，它是不计数的，在复制或者赋值的时候都会实现move语义，不符合直觉，所以被抛弃了。

auto_ptr的使用场景应该是被shared_ptr和unique_ptr瓜分了。

4，weak_ptr

weak_ptr有点像shared_ptr的副本，用来解决shared_ptr的引用成环的问题。

可以用weak_ptr或者shared_ptr的指针给weak_ptr的指针赋值，weak_ptr只能读取不能修改，也不参与计数。