C++中的智能指针

智能指针是在$C++14$中新引入的，所以在编译的时候最好加入$"-std=c++14"$的编译选项。智能指针一共有两种，分别是$unique\_ptr$和$shared\_ptr$。

$unique\_ptr$

$unique\_ptr$可以使用$make\_unique$来生成：

  template<typename _Tp, typename... _Args>
    inline typename _MakeUniq<_Tp>::__single_object
    make_unique(_Args&&... __args)
    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
1
2
3
4

可以看出$make\_unique$是一个模板函数，将返回一个$\_Tp$类型的指针，也就是假设有一个$point$类：

struct point
{
	int x, y;
	point(int x, int y)
	{
		this->x = x;
		this->y = y;
	}
};
1
2
3
4
5
6
7
8
9

然后声明一个指针：

std::unique_ptr<point> x = make_unique<point>(3, 5);
1

则$x$为一个指向$point(3,5)$的指针，然而由于其"$unqiue$"的特性，$x$不可被拷贝构造以及拷贝赋值，在源码里，其拷贝构造以及拷贝赋值被定义成以下的形式：

unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
1
2

在$C++$中，“$=delete$"是一种特殊的函数声明方式，用于禁用或删除某个函数的默认实现。当一个函数被声明为”$=delete$"时，编译器将不会生成该函数的默认实现，并且在尝试调用该函数时会引发编译错误。
然而，有的时候需要将$x$指向的内存转给其他指针，那么这个时候，只有唯一的一种方法，就是：

auto y = std::move(x);
//or std::unique_ptr y = std::move(x);
1
2

$shared\_ptr$

$shared\_ptr$不同于$unique\_ptr$，其可以通过拷贝赋值给其他指针，以下分别是其拷贝构造以及拷贝赋值函数。

shared_ptr& operator=(const shared_ptr& _Right) noexcept
		{	// assign shared ownership of resource owned by _Right
		shared_ptr(_Right).swap(*this);
		return (*this);
		}
shared_ptr(const shared_ptr& _Other) noexcept
		{	// construct shared_ptr object that owns same resource as _Other
		this->_Copy_construct_from(_Other);
		}
1
2
3
4
5
6
7
8
9

也就是说，$shared\_ptr$可以通过以下方式构造：

std::shared_ptr<point> x = make_shared<point>(3, 5);
auto y = x;
auto z(x);
1
2
3

同时可以通过$use\_count$方法统计一块相同的内存被几个指针共享：

cout << x.use_count() << endl;
1

共享指针有以下几个$trick$

1. 当共享指针被拷贝构造或者拷贝赋值的时候，指向的内存才算被共享了一次，所以上面的那段代码输出的结果为$3$，然而如果是进行浅拷贝的话，不算做一次共享：

auto y = std::move(x);
cout<<y.use_count()<<x.use_count()<<endl;
//该结果为3 0
1
2
3

2. 如果是传入函数并且打印$use\_count$，也有以下两种情况。

void func(std::shared_ptr<point> x)
{
	cout << x.use_count() << endl;
}
int main(void)
{
	std::shared_ptr<point> x = make_shared<point>(3, 5);
	auto y = x;
	auto z(x);
	cout << x.use_count() << endl;
	func(std::move(x));//这个右值引用如果给一个左值里面就空了
	cout << x.use_count() << endl;
}
//本结果为
//3 3 0
//如果调用x的其他属性会报段错误。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void func(std::shared_ptr<point>&& x)
{
	cout << x.use_count() << endl;
}
int main(void)
{
	std::shared_ptr<point> x = make_shared<point>(3, 5);
	auto y = x;
	auto z(x);
	cout << x.use_count() << endl;
	func(std::move(x));//这个右值引用如果给一个左值里面就空了
	cout << x.use_count() << endl;
}
//这个结果为3 3 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14

如果不按右值引用传入：

void func(std::shared_ptr<point> x)
{
	cout << x.use_count() << endl;
}
int main(void)
{
	std::shared_ptr<point> x = make_shared<point>(3, 5);
	auto y = x;
	auto z(x);
	cout << x.use_count() << endl;
	func(x);//这个右值引用如果给一个左值里面就空了
	cout << x.use_count() << endl;
}
//这个结果是3 4 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14