C++智能指针的实现与使用(详解)_c++智能指针实现-CSDN博客

本文链接：https://blog.csdn.net/qq135595696/article/details/123977078

C++智能指针的实现与使用(详解)

智能指针介绍

缘起

C++指针的实际问题

分配内存忘记释放，导致内存泄漏
有指针引用时释放内存，导致其它指针非法访问异常
一些对象的声明周期难以明确

办法

首先重载运算符*、->、[]、=使得一个类具有指针的操作

其次，使用模板编程，使得一个模板类可以接入各种类型

最后，自己管理内存。

使用方法

get、swap、unique、use_count、reset、make_shared(模板方法)

注意事项

智能指针不是线程安全的。

#include <iostream>
#include <memory>//常用智能指针头
#include <string>

int main()
{
	//初始化一个整数
	shared_ptr<int> intger(0);
	//初始化一个整型数组(40个字节，即存放10个整数)
	shared_ptr<int> intarr = make_shared<int>(10);
	//初始化一个字符串
	shared_ptr<string> str = make_shared<string>("world");

	const char* temp = str->c_str();

	string ss = *str;

	str.reset();

	if (str != nullptr)
		temp = str.get()->c_str();

	shared_ptr<string> str1 = make_shared<string>("hello");
	str.swap(str1);

	if (str.unique())
		cout << "针对指向对象当前只有一个指针指向它" << endl;

	cout << "针对指向对象当前有几个指针指向它: " << str.use_count() << endl;
	return 0;
}

以下内容参考链接：https://blog.csdn.net/flowing_wind/article/details/81301001

shared_ptr允许多个指针指向同一个对象，unique_ptr则“独占”所指向的对象。标准库还定义了另外一个名为weak_ptr的伴随类，它是一种弱作用，指向shared_ptr所管理的对象，这三种智能指针都定义在memory头文件中。

shared_ptr类

创建智能指针时需要提供额外的信息，如指针可以指向的类型：

shared_ptr<string> p1;
shared_ptr<list<int>> p2;

默认初始化的智能指针中保存着一个空指针。

智能指针的使用方式和普通指针类似，解引用一个智能指针返回它指向的对象，在一个条件判断中使用智能指针就是检测它是不是空。

if(p1 && p1->empty())
    *p1 = "h1";

下表所示是shared_ptr和unique_ptr都支持的操作：

效果图

如下表所示是shared_ptr特有的操作：

效果图

make_shared函数

最安全的分配和使用动态内存的方法就是调用名为make_shared的标准库函数，此函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr。头文件和share_ptr相同，在memory头文件中。

必须指定想要创建的对象类型，定义格式见下面例子：

shared_ptr<int> p3 = make_shared<int>(42);
shared_ptr<string> p4 = make_shared<string>(10, '9');
shared_ptr<int> p5 = make_shared<int>();

make_shared用其参数来构造给定类型的对象，如果我们不传递任意参数，对象只会对其分配相应的内存。

shared_ptr的拷贝和赋值

当进行拷贝和赋值时，每个shared_ptr都会记录有多少个其它shared_ptr指向相同的对象。

auto p = make_shared<int>(42);
auto q(p);
cout << "num:" << p.use_count() << endl;

我们可以认为每个shared_ptr都有一个关联的计数器，通常称其为引用计数器，无论何时我们拷贝一个shared_ptr，计数器都会递增。当我们给shared_ptr赋予一个新值或者是shared_ptr被销毁（例如一个局部的shared_ptr离开其作用域）时，计数器就会递减，一点一个shared_ptr的计数器变为0，他就会自动释放自己所管理的对象。

auto r = make_shared<int>(42);//r指向的int只有一个引用者
r=q;//给r赋值，令它指向另一个地址
	//递增q指向的对象的引用计数
	//递减r原来指向的对象的引用计数
	//r原来指向的对象如果已没有引用者，会自动释放

shared_ptr自动销毁所管理的对象

当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr类会自动销毁此对象，它是通过另外一个特殊的成员函数-析构函数完成销毁工作的，类似于构造函数，每个类都一个析构函数。析构函数控制对象销毁时做什么操作。析构函数一般用来释放对象所分配的资源。shared_ptr的析构函数会递减它所指向对象的引用计数。如果引用计数变为0，shared_ptr的析构函数就会销毁对象，并释放它所占的内存。

shared_ptr会自动释放其相关联的内存

当动态对象不再被使用时，shared_ptr类还会自动释放动态对象，这一特性使得动态内存的使用变得非常容易。如果你将shared_ptr存放于一个容器中，而后不再使用它，只需要将它删除即可。

shared_ptr和new结合使用

如果我们不初始化一个智能指针，它就会被初始化成为一个空指针，由于智能指针初始化函数定义为explicit，所以我们不能将一个内置指针隐式转换为一个智能指针，必须直接以初始化的形式来初始化一个智能指针。

TIPS：内置指针即直接通过new申请的内存。

shared_ptr<int> p5 = new int(1024);//错误，不能隐式转换
shared_ptr<int> p6(new int(1024));//正确，直接初始化

下表为shared_ptr的其他方法：

效果图

不要混合使用普通指针和智能指针

如果混合使用的话，智能指针自动释放之后，普通指针会变成悬空指针，当将一个shared_ptr绑定到一个普通指针时，我们就将内存的管理责任交付给了shared_ptr。一旦这样做，我们就不要再使用内置指针指向shared_ptr所指向的内存了。

同时也不要使用get初始化另外一个智能指针或者智能指针赋值。

 shared_ptr<int> p(new int(12));
 int* q = p.get();
 {
   shared_ptr<int> tmp(q);
 }//程序块结束后，q所指向的对象被释放
 int f = *p;//解指针p就会产生难以预料的结果
 cout << f << endl;

当q所在的程序块结束时，q被销毁，这会导致q指向的内存被释放，p这时候变成一个空悬指针，再次使用时，将发生未定义的行文，当p被释放的时候，这块空间就被二次释放。

其它shared_ptr的操作

可以使用reset来将一个新的指针赋予一个shared_ptr。

p = new int(1024);//错误：不能将一个指针赋予shared_ptr
p.reset(new int(1024));//正确。p指向一个新对象

与赋值类似，reset会更新引用计数，如果需要的话会释放p的对象。reset成员经常和unique一起使用，来控制多个shared_ptr共享的对象。在改变底层对象之前，我们检查自己是否是当前仅有的用户。如果不是，在改变之前要制作一份新的拷贝：

if(!p.unique())
	p.reset(new string(*p));//我们不是唯一用户，分配新的拷贝
*p+=newVal;//现在我们知道自己是唯一的用户，可以改变对象的值

智能指针和异常

void f(){
    shared_ptr<int> sp(new int(11));
    //假设抛出了异常，而且在f中未捕获
}//函数结束后shared_ptr自动释放内存
void f1(){
    int* ip = new int(12);
    //假设delete语句前抛出了异常，而且在f中未捕获
    delete ip;
}//函数结束后ip所指向的内存没有被释放。

智能指针的陷阱

不使用相同的内置指针初始化（或reset）多个智能指针。
不直接delete通过get返回的指针。
不适用get()初始化或reset另外一个智能指针。
如果你使用get()返回的指针，记住当最后一个对应的智能指针被销毁的时候，该指针就已经无效了。
如果使用智能指针管理的资源不是new分配的内存，请传递给它一个删除器。

unique_ptr类

某个时刻只能有一个unique_ptr指向一个给定对象，由于一个unique_ptr拥有它指向的对象，因此unique_ptr不支持普通的拷贝或赋值操作。

下表时unique_ptr的方法：

效果图

虽然我们不能拷贝或者赋值unique_ptr，但是可以通过调用release或者reset将指针所有权从一个（非const）unique_ptr转移给另外一个unique_ptr。

//将所有权从p1（指向string Stegosaurus）转移给p2
unique_ptr<string> p2(p1.release());//release将p1置为空
unique_ptr<string> p3(new string("Trex"));
//将所有权从p3转移到p2
p2.reset(p3.release());//reset释放了p2原来指向的内存

release成员返回unique_ptr当前保存的指针并将其置为空。因此，p2被初始化为p1原来保存的指针，而p1被置为空。

reset成员接受一个可选的指针参数，令unique_ptr重新指向给定的指针。

调用release会切断unique_ptr和它原来的对象间的联系。release返回的指针通常被用来初始化另外一个智能指针或给另外一个智能指针赋值。

不能拷贝unique_ptr有一个例外，我们可以拷贝或赋值一个将要被销毁的unique_ptr。最常见的例子是从函数返回一个unique_ptr。

unique_ptr<int> clone(int p)
{
	//正确：从int*创建一个unique_ptr<int>
	return unique_ptr<int>(new int(p));
}

还可以返回一个局部变量的拷贝：

unique_ptr<int> clone(int p)
{
	unique_ptr<int> ret(new int(p));
	return ret;
}

weak_ptr类

weak_ptr是一种不控制所指向对象生存期的智能指针，它指向一个由shared_ptr管理的对象，将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放，即使有weak_ptr指向对象，对象还是会被释放掉。

下表时weak_ptr的方法：

效果图