关于智能指针,你想要的都在这里

最新推荐文章于 2022-12-29 15:08:36 发布
最新推荐文章于 2022-12-29 15:08:36 发布
阅读量298 收藏 1
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FDk_LCL/article/details/108543578
版权

智能指针介绍

什么是智能指针，智能指针相比于传统的裸指针而言，其智能之处在哪里？关于这个问题的解释，首先我们来看一下传统的裸指针在使用的时候常常会 出现的几种问题：

1、通过malloc/new开辟的内存，在函数执行到某处的时候return掉了，以至于没有执行相应的free/delete语句，造成了内存泄漏；

2、通过malloc/new开辟的内存，忘记写free/delete语句，导致内存泄漏；

3、对同一个资源多次释放，导致释放野指针，程序发生崩溃错误；

智能指针的智能之处就在于写程序的人不用关心资源的释放，利用了栈上的对象出作用域自动析构的特性，自动释放指针所指向的资源，避免内存泄漏。关于他的底层实现其实就是对裸指针的封装，提供了运算符重载函数而言。下面我们将实现一个智能指针。

实现不带引用计数的智能指针

#include<iostream>
using namespace std;

template<typename T>
class Smart {
public:
	Smart(T* ptr = T()) :_ptr(ptr) {
	}
	T& operator*(){return *_ptr; }
	T* operator->(){return _ptr; }
	~Smart() { delete _ptr; }
private:
	T* _ptr;
};

int main() {
	Smart<int> p1(new int);
	Smart<int> p2(p1);
	return 0;
}

 可以看到，正如上述所说，智能指针实际上就是将裸指针进行了一次面向对象的封装，利用了栈上对象出作用域自动析构的特点实现其智能之处。分析一下main函数的执行结果是什么，没错程序最终会崩溃，原因是p1和p2都指向同一块资源，在对象出作用域析构的时候，一块资源被释放两次，发生了浅拷贝问题。下面我们来看看C++库里所提供的智能指针是如何解决这个问题的？

不带引用计数的智能指针

不带引用计数的智能指针主要有auto_ptr，scoped_ptr，unique_ptr关于上述问题，我们将一个一个进行分析：

<1>auto_ptr,首先我们看一下auto_ptr的底层实现：

 auto_ptr(auto_ptr<_Other>& _Right) noexcept
        : _Myptr(_Right.release()) { // construct by assuming pointer from _Right

在其构造函数下，调用了release方法，再来看一下release方法的具体实现是什么？

_Ty* release() noexcept { // return wrapped pointer and give up ownership
        _Ty* _Tmp = _Myptr;
        _Myptr    = nullptr;
        return _Tmp;
    }

看到这里我们明白了auto_ptr是如何解决浅拷贝问题了，它实际上是进行了资源的转移，简单来说，就是只有最后一个对象拥有该资源，前面的对象都不在拥有（将自己置nullptr）。所以一定不能对进行资源转移过的对象进行操作。

说到这里，试问auto_ptr能在容器中使用吗？答案肯定是不行的，当容器之间进行拷贝构造时，相当于容器的元素进行拷贝构造，那么原来容器中的元素都被置nullptr，再次访问会出现程序崩溃错误，所以切记容器中不可使用auto_ptr。

<2>scoped_ptr,一样我们来看一下其底层实现：

template<class T> class scoped_ptr // noncopyable
{
private:
    T * px;
	
	/*
	私有化拷贝构造函数和赋值函数，这样scoped_ptr的智能指针
	对象就不支持这两种操作，从根本上杜绝浅拷贝的发生
	*/
    scoped_ptr(scoped_ptr const &);
    scoped_ptr & operator=(scoped_ptr const &);

};

 scoped_ptr直接将拷贝构造函数和赋值运算符重载函数私有化，从根本上杜绝了浅拷贝的发生，对于容器而言，scoped_ptr也是不能使用在其中的，原因就在于当容器之间进行拷贝构造时，其元素之间之间也会进行拷贝构造，由于将拷贝构造函数私有化，因此会发生编译错误。

<3>unique_ptr,首先观察一下其底层实现

template <class _Ty,class _Dx> // = default_delete<_Ty>
class unique_ptr { 
public:
    //提供右值引用的拷贝构造函数
    unique_ptr(unique_ptr&& _Right) noexcept
        : _Mypair(_One_then_variadic_args_t(), _STD forward<_Dx>(_Right.get_deleter()), _Right.release()) {}
    //提供右值引用的赋值运算符重载
    unique_ptr& operator=(unique_ptr&& _Right) noexcept {
        if (this != _STD addressof(_Right)) {
            reset(_Right.release());
            _Mypair._Get_first() = _STD forward<_Dx>(_Right._Mypair._Get_first());
        }
        return *this;
    }
    //删除左值引用的拷贝构造函数和赋值运算符重载函数
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;

private:
    template <class, class>
    friend class unique_ptr;
    _Compressed_pair<_Dx, pointer> _Mypair;
};

从上面看到，unique_ptr有一点和scoped_ptr做的一样，就是去掉了拷贝构造函数和operator=赋值重载函数，禁止用户对unique_ptr进行显示的拷贝构造和赋值，防止智能指针浅拷贝问题的发生。

但是unique_ptr提供了带右值引用参数的拷贝构造和赋值，也就是说，unique_ptr智能指针可以通过右值引用进行拷贝构造和赋值操作，或者在产生unique_ptr临时对象的地方，如把unique_ptr作为函数的返回值时进行拷贝构造和赋值操作。

带引用计数的智能指针shared_ptr、weak_ptr

 什么是带引用计数的智能指针，通俗来说当允许多个智能指针指向同一个资源的时候，每一个智能指针都会给资源的引用计数加1，当一个智能指针析构时，同样会使资源的引用计数减1，这样最后一个智能指针把资源的引用计数从1减到0时，就说明该资源可以释放了，由最后一个智能指针的析构函数来处理资源的释放问题，这就是引用计数的概念。

要对资源的引用个数进行计数，我们知道i++，i--操作在多线程环境下不是线程安全的操作，带引用计数的的智能指针底层的引用计数已经通过了CAS操作保证了其原子性，因此shared_ptr和weak_ptr本身就是线程安全的带引用计数的智能指针。

实现带引用计数智能指针

template<typename T>
class Share_ptr {
public:
	//构造函数
	Share_ptr(T *ptr = T()) :_ptr(ptr) {
		if (_ptr != nullptr) {
			_cnt = new int(1);
		}
		else {
			_cnt = new int(0);
		}
	}
    //*号运算符重载函数
	T& operator*() {
		if (this->_ptr) {
			return *this->_ptr;
		}
	}

	T* operator->() {
		if (this->_ptr) {
			return this->_ptr;
		}
	}
	const T& operator*()const {
		if (this->_ptr) {
			return *this->_ptr;
		}
	}
	const T* operator->() const{
		if (this->_ptr) {
			return this->_ptr;
		}
	}
	//拷贝构造函数
	Share_ptr(const Share_ptr& src) {
		if (this != &src) {
			this->_ptr = src._ptr;
			this->_cnt = src._cnt;
			(*this->_cnt)++;
		}
	}
	//赋值运算符重载函数
	Share_ptr& operator=(const Share_ptr& src) {
		if (this->_ptr == src._ptr) {
			return *this;
		}
		if (this->_ptr) {
			(*this->_cnt)--;
			if ((*this->_cnt) == 0) {
				delete this->_ptr;
				this->_ptr = nullptr;
				delete this->_cnt;
				this->_cnt = nullptr;
			}
		}
		this->_ptr = src._ptr;
		this->_cnt = src._cnt;
		(*this->_cnt)++;
		return *this;
	}
	//析构函数
	~Share_ptr() {
		(*this->_cnt)--;
		if ((*this->_cnt) == 0) {
			delete _ptr;
			_ptr = nullptr;
			delete _cnt;
			_cnt = nullptr;
		}
	}
    //获得引用计数
	int getCnt() {
		return (*this->_cnt);
	}
private:
	T* _ptr;
	int* _cnt;
};

int main() {
	Share_ptr<int> ptr(new int());
	cout << ptr.getCnt() << endl;
	Share_ptr<int> ptr1(ptr);
	cout << ptr1.getCnt() << endl;
	Share_ptr<int> ptr2;
	ptr2 = ptr;
	cout << ptr2.getCnt() << endl;
	return 0;

智能指针的交叉引用（循环引用）问题

什么是指针指针的交叉引用问题：首先列出一下代码：

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

class B;
class A {
public:
	A() {cout << "constructA!" << endl;}
	~A() {cout << "deleteA" << endl;}
	shared_ptr<B> _ptrb;
};
class B{
public:
	B() { cout << "constructB!" << endl; }
	~B() { cout << "deleteB" << endl; }
	shared_ptr<A> _ptra;
};

int main(){
	shared_ptr<A> _ptr1(new A);
	shared_ptr<B> _ptr2(new B);

	_ptr1->_ptrb = _ptr2;
	_ptr2->_ptra = _ptr1;

	cout << _ptr1.use_count() << endl;
	cout << _ptr2.use_count() << endl;
	return 0;
}

观察其结果：

可以看到，A和B对象并没有进行析构，通过上面的代码示例，能够看出来“交叉引用”的问题所在，就是对象无法析构，资源无法释放，如图所示：

那怎么解决这个问题呢？请注意强弱智能指针的一个重要应用规则：定义对象时，用强智能指针shared_ptr，在其它地方引用对象时，使用弱智能指针weak_ptr。

弱智能指针weak_ptr区别于shared_ptr之处在于：

  1. weak_ptr不会改变资源的引用计数，只是一个观察者的角色，通过观察shared_ptr来判定资源是否存在
  2. weak_ptr持有的引用计数，不是资源的引用计数，而是同一个资源的观察者的计数
  3. weak_ptr没有提供常用的指针操作，无法直接访问资源，需要先通过lock方法提升为shared_ptr强智能指针，才能访问资源

 对上述代码进行修改：

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

class B;
class A {
public:
	A() {cout << "constructA!" << endl;}
	~A() {cout << "deleteA" << endl;}
	weak_ptr<B> _ptrb;
};
class B{
public:
	B() { cout << "constructB!" << endl; }
	~B() { cout << "deleteB" << endl; }
	weak_ptr<A> _ptra;
};

int main(){
	shared_ptr<A> _ptr1(new A);
	shared_ptr<B> _ptr2(new B);

	_ptr1->_ptrb = _ptr2;
	_ptr2->_ptra = _ptr1;

	cout << _ptr1.use_count() << endl;
	cout << _ptr2.use_count() << endl;
	return 0;
}

观察其结果：

这下我们发现资源成功进行释放，其原理如下图所示：

多线程访问共享对象问题

什么是多线程访问共享对象问题呢？解释如下：线程A和线程B访问一个共享的对象，如果线程A正在析构这个对象的时候，线程B又要调用该共享对象的成员方法，此时可能线程A已经把对象析构完了，线程B再去访问该对象，就会发生不可预期的错误。

代码如下：

#include<iostream>
#include<memory>
#include<thread>
using namespace std;

class test {
public:
	test() {}
	~test() {}
	void func() {cout << "this is good function!" << endl;}
};

void threadworker(test *p) {
	this_thread::sleep_for(std::chrono::seconds(2));
	p->func();
}

int main(){
	test* ptr = new test();
	thread t1(threadworker,ptr);
	delete ptr; //析构这个对象
	t1.join();
	return 0;
}

程序运行结果如下：

 按照正常逻辑而言，子线程睡眠两秒，那么主线程在析构对象后，子线程不应该能访问到该对象的资源，这可能会导致不可预期的错误。可以借助share_ptr和weak_ptr来解决这个问题，代码如下：

#include<iostream>
#include<memory>
#include<thread>
using namespace std;

class test {
public:
	test() {}
	~test() {}
	void func() {cout << "this is good function!" << endl;}
};

void threadworker(weak_ptr<test> p) { //引用处用弱智能指针
	this_thread::sleep_for(std::chrono::seconds(2));
	/*
	如果想访问对象的方法，先通过p的lock方法进行提升操作，把weak_ptr提升为
	shared_ptr强智能指针，提升过程中，是通过检测它所观察的强智能指针保存
	的Test对象的引用计数，来判定Test对象是否存活，ps如果为nullptr，说明Test对象
	已经析构，不能再访问；如果ps!=nullptr，则可以正常访问Test对象的方法。
	*/
	if (shared_ptr<test> ptr =  p.lock()) {
		ptr->func();
	}
}

int main(){
	shared_ptr<test> ptr(new test()); //定义处用强智能指针
	thread t1(threadworker,ptr);
	t1.join();
	return 0;
}

代码可以正常的输出结果，因为主线程调用join方法等待子线程结束，子线程中p调用lock方法提升成功。 

那么思考一下如果将子线程处理为分离线程结果会是怎样呢？注意处理为分离线程，那么主线程先于子线程结束，析构了对象的资源，p调用lock方法提升失败，无法执行成员方法。

自定义删除器

 关于智能智能指针的删除器我自己认为他是一个极其强大的功能。对于正常情况下，我们常常管理的是堆资源，当智能指针出作用域的时候，会调用析构函数释放资源。那么删除一个文件资源，或者希望资源按照我们所希望的方式进行回收等等操作，该如何处理呢？自定义智能指针的删除器就可以实现。

我们来看一下unique_ptr的类声明:

template <class _Ty,
    class _Dx> // = default_delete<_Ty>
//除了传入所开辟资源的类型_ty外,还能传入一个函数对象类型删除删除_ty类型的资源

 再来看一下unique_ptr的析构函数:

 ~unique_ptr() noexcept {
        if (_Mypair._Myval2 != pointer()) {
            _Mypair._Get_first()(_Mypair._Myval2);
        }
    }
    //返回用于析构被管理对象的删除器
    _NODISCARD _Dx& get_deleter() noexcept {
        return _Mypair._Get_first();
    //返回指向被管理对象的指针
    _NODISCARD pointer get() const noexcept {
        return _Mypair._Myval2;
    }

可以看出来实现智能指针的删除器需要定义一个函数对象：

下面看一个删除文件资源的例子:

class FileDeleter
{
public:
	// 删除器负责删除资源的函数
	void operator()(FILE *pf)
	{
		fclose(pf);
	}
};
int main()
{
    // 由于用智能指针管理文件资源，因此传入自定义的删除器类型FileDeleter
	unique_ptr<FILE, FileDeleter> filePtr(fopen("data.txt", "w"));
	return 0;
}

上述方法虽然可行，但是需要创建额外的类，我并不热衷于此做法。function和lambda表达式可以更好的实现了智能指针的删除器。

// 自定义智能指针删除器，关闭文件资源
	unique_ptr<FILE, function<void(FILE*)>> 
		filePtr(fopen("data.txt", "w"), [](FILE *pf)->void{fclose(pf);});

 

FDk_LCL
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
智能指针
qq_41078889的博客
07-09 768
智能指针是为了方便管理动态内存，防止产生内存泄漏，而对指针进行的一层封装，可以通过析构函数，构造函数，赋值运算符重载的处理，而实现的可以自动管理指针所指向的动态内存，防止产生内存泄漏。定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。智能指针：主要有Boost库中的智能指针和STL标准库中的智能指针构成。 所有智能指针编写代码时都需要注意的事： 智能指针编写的时候，因为不知道指向的是何种类型的堆内存，所以都写成模板形式 注
关于智能指针！
bin_4545的博客
11-05 165
智能指针的发展史： 先从RAII说起：      RAII(Resource Acquisition Is Initialization) 资源分配即初始化，定义一个类来封装资源的分配和释放，在构造函数完成资源 的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释 放。 auto_ptr： 实际上，为了正确地管理资源，人们进行了包括但不仅限于flag
关于智能指针
wran621104的博客
04-11 147
http://en.cppreference.com/w/cpp/memory/shared_ptr
关于智能指针（上）
是蛋筒啊的博客
06-29 136
关于智能指针（上） 引入智能指针的目的是为了避免我们在申请量空间之后忘记delete ，或是当程序出现异常时，程序会直接从一个模块跳出来，导致后面的delete语句不能被执行，因此存在内存泄漏问题。 如何让我们在使用完资源后，使系统自动为我们释放这些资源呢？ 我们知道析构函数具有这样的功能。 因此，我们将需要将基本类型指针封装为类对象指针，该类一定是模板类，以适应不同类型指针的需求。在构造...
关于智能指针的总结
Minminera
08-09 252
对于普通指针在日常使用的时候会面临一个释放问题，一种可以保证释放不会出错的方式就是谁申请谁释放 但是这种方式实际使用的时候局限性太大，比如说某个函数的功能就是去释放内存，很明显它不能够去释放自己申请的内存 指针释放经常会出现两方面的问题： 1、内存泄漏 2、重复释放 因此引入智能指针，智能指针分为强智能指针和弱智能指针 强智能指针： 智能指针的实现都是对普通指针的一个封装，在封装的时...
C++11智能指针中的 unique_ptr实例详解
12-17
在C++11中，智能指针是一种管理动态分配对象生命周期的工具，它们负责在不再需要对象时自动释放内存。本篇文章重点讲解的是`unique_ptr`，它是C++11新引入的一种智能指针，强调对对象的唯一所有权。 1. **unique_...
Smart-Pointer:基于 C++ 的智能指针
07-11
智能指针介绍SmartPointer 是 C++ 项目，其目的是确保在初始化对象的同时进行资源获取，从而在一行代码中创建并准备好对象的所有资源。 一般来说，主要目标是将任何堆分配的资源（例如动态分配的内存或系统对象句柄...
C++中的auto_ptr智能指针的作用及使用方法详解
09-02
C++中的`auto_ptr`是旧版C++标准库中的一种智能指针，它主要用于管理动态分配的内存，确保在适当的时候自动释放内存，从而防止内存泄漏。在C++11之后，`auto_ptr`已被`unique_ptr`取代，因为`auto_ptr`有一些限制和...
nptr:Nim Lang智能指针
04-10
在这里，我们将深入探讨Nim Lang中的智能指针——`nptr`。 首先，了解Nim的基本内存管理机制至关重要。Nim采用了垃圾回收（GC）来自动管理内存，这意味着程序员通常不必手动释放内存。然而，在某些情况下，如处理C...
C++ 中boost::share_ptr智能指针的使用方法
08-29
使用 boost::shared_ptr 智能指针需要首先编译 Boost 库，然后在代码中包含头文件 。 1. 创建智能指针 使用 boost::shared_ptr 智能指针可以创建一个对象，例如： ```cpp boost::shared_ptr<CTest> pTemp(new ...
C++类的静态成员的初始化出现访问冲突、myhead nullptr错误
10-20 670
感觉静态成员要么是简单类型要么是指针比较好，不要是复杂类本身。
C++校招常见问题汇总
长期更新自学笔记
09-10 993
文章目录1. this指针干什么用的？2. new和delete，什么时候用new[]申请，可以用delete释放？3. static关键字的作用（从elf结构、链接过程回答）？4. C++的继承有什么好处？5. 讲一下C++的多态6. 空间配置器allocator？7. vector和list的区别？8. map和multimap的区别？9. C++如何防止内存泄漏？智能指针详述10. C++如何调用C语言函数接口？11. 那些情况下可能出现访问越界12. C++中类的初始化列表13. C和C++的区别以
关于std::vector<bool>类型使用下标运算符取值出错的研究
jianminfly的博客
08-20 2090
问题提出 std::vectorv(1,true); void* p = &v[0];// 此时p指向的内存转成bool类型是false 但是 std::vector v2(2,1); void* p3 = &v2[0];// 此时p指向的内存转成int类型时，值正常 分析 1.一般类型的vector使用下标运算符时 _NODISCARD _Ty& operator[...
list容器
Nopoduct的博客
02-24 557
list容器 此节大致讲解LIst的底层实现，依旧使用VS STL List容器内部也存在一个```_Mypair```，而不像vector，里面的```_Scary_val```是很长的一段，List的```_Scary_val```很简单。 using _Scary_val = _List_val<_Val_types>; 让我们进入到```_List_val```里面看看一个List都有什么 ... _Nodeptr _Myhead; size_type _Mysize; ..
解决：引发了异常: 读取访问权限冲突。
热门推荐
weixin_45902201的博客
05-09 3万+
C++报错： 引发了未经处理的异常:读取访问权限冲突
libtorch 异常处理汇总
一千零一夜的博客
10-20 3191
libtorch 异常处理汇总
跟我学C++中级篇——STL的容器vector
fpcc的专栏
02-22 1020
一、顺序容器vector C++程序员中，如果用到过STL，那么一定肯定用过vector，这个是最常见，最初步的一个数据类型。上一篇提到的array远远比不上它。毕竟那玩意儿相对vector是很久远后才提出来的。在这之前，std::vector承担了多少小菜鸟处理 数组各种问题的最优选方法。不用处理内存，可以删除，任意增加不考虑越界。那简直是一种最单纯质朴的快乐。 如果单纯的只考虑开发目标，而不考虑对内存占用和再分配导致的性能下降，不用考虑删除时迭代器的问题，那么几乎这玩意儿就可以能抵挡住大多数情况...
跟我学C++中级篇——STL的容器List
fpcc的专栏
03-07 352
一、顺序容器list 学过数据结构或者说学习过基础的C语言的人都接触过链表。链，同学们都知道，铁链，锁链…，表，一排排的小格子；那么组合在一起呢，就是这些小格子用链条一个个串起来，通过第一个入口的链条就可以不断的迭代查找到所有的小格子。把这些小格子换成数据，把链条换成指针，就是链表。链表有很多种，有单向链表，只能朝着一个方向前进；有双向链表，既可以向前查找，也可以向后查找；还有循环链表，链表整体构成一个环，诸如此等等。 循环链表就是把首尾连接起来，它更多的适用于环形缓冲区。 那么STL中...
stl vector 源码分析
weixin_42038860的博客
12-29 174
stl 源码分析
父类是非智能指针，如何指向智能指针的子类
最新发布
06-12
在C++中，如果父类不是智能指针，但想要指向智能指针的子类，通常会通过使用`dynamic_cast`或者`static_cast`来实现向下转换。这是因为C++不支持直接将非智能指针类型赋值给智能指针，但可以通过强制类型转换来处理这种情况。 假设我们有一个基类`BaseClass`，它不是一个智能指针，而有一个派生类`DerivedClass`是智能指针`std::unique_ptr`或`std::shared_ptr`的实例： ```cpp class BaseClass { public: // ... }; class DerivedClass : public std::unique_ptr<SomeType> { // ... }; ``` 如果你想让`BaseClass`类型的指针指向`DerivedClass`实例，你可以这样做： ```cpp BaseClass* basePtr = new DerivedClass(new SomeType()); // 或者用智能指针初始化 BaseClass* basePtr = dynamic_cast<BaseClass*>(new DerivedClass(someObject)); ``` 这里`dynamic_cast`用于确保安全的类型转换，因为`DerivedClass`实际上是`std::unique_ptr`的别名，可能包含实际的`SomeType`指针。 然而，值得注意的是，如果你打算在生命周期结束后释放资源，通常不需要手动管理内存，因为智能指针会自动处理。在使用这种方式时，你需要确保`DerivedClass`对象的生命周期比`BaseClass`的生命周期长，或者在适当的时候进行解引用和删除。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值