C++11——智能指针

已于 2025-05-29 16:13:10 修改
阅读量3.1k 收藏 25
点赞数 4
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： c++ 智能指针 auto_ptr unique_ptr shared_ptr
于 2021-10-30 13:01:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57023347/article/details/121042923

目录

前言

一.智能指针的原理

        1.1 RAII思想

        1.2 原理

二.智能指针的分类

        2.1 auto_ptr介绍

        2.2 unique_pt介绍

         2.3 shared_ptr介绍

前言

        由于C++没有GC(垃圾回收器)，程序员从堆上申请的资源，打开的文件，创建的套接字需要我们手动释放和关闭。

        但是可能会出现两个问题：

  1. 异常安全问题。申请完资源，由于异常需要捕捉，使得执行流不会按顺序进行，导致资源还没有释放和关闭，就跳到别的地方执行了。
  2. 由于需要程序员手动释放和关闭，可能会有忘记释放和关闭的问题。

        这样就会导致资源的泄漏。计算机的资源是有限的，导致我们可以使用的资源越来越少。

        智能指针是针对我们从堆上申请的空间，比如：new和malloc出来的空间。使得智能指针来帮我们释放空间，不需要我们来手动释放了。

一.智能指针的原理

        1.1 RAII思想

        RAII是一种了利用对象生命周期来控制程序资源(如：内存，文件，套接字，互斥量等)的技术。

        在对象构造时获得资源，使得堆资源的控制在对象的生命周期内都有效，最后在对象析构的时候释放资源。

        实际上我们是将资源的管理托管给了一个对象。这样做有两个好处：

  1. 不需要显示的释放资源。
  2. 资源的控制在对象生命周期内都有效。

利用RAII实现一个最简单的智能指针。

#pragma once

#include<iostream>

using namespace std;
template<class T>
class SmatrPrt{
private:
	T* _ptr;
public:
	//将外面申请的资源，托管给类的成员
	SmatrPrt(T* ptr = nullptr)
		:_ptr(ptr)
	{}

	//在对象析构时，自动释放资源
	~SmatrPrt(){
		if (_ptr){
			cout << "delete ptr" << endl;
			delete _ptr;
		}

	}
};
#include "SmartPtr.h"

void test(){
    //将申请的资源托管给了sp对象
    //当对象空间释放会调用析构函数，释放资源
	SmatrPrt<int> sp(new int);
}


int main(){

	test();

	system("pause");
	return 0;
}

        1.2 原理

        智能指针的原理利用了RAII思想，并且还需要让智能指针具有指针的功能。即，需要重载operator*和operator->的函数。

        之后在使用指针时，只需要像指针一样控制对象即可。

#pragma once

#include<iostream>

using namespace std;
template<class T>
class SmatrPrt{
private:
	T* _ptr;
public:
	//将外面申请的资源，托管给类的成员
	SmatrPrt(T* ptr = nullptr)
		:_ptr(ptr)
	{}

	T& operator*(){
		return *_ptr;
	}
	T* operator->(){
		return _ptr;
	}


	//在对象析构时，自动释放资源
	~SmatrPrt(){
		if (_ptr){
			cout << "delete ptr" << endl;
			delete _ptr;
		}

	}
};

#include "SmartPtr.h"

void test(){
	SmatrPrt<int> sp(new int);
    //像指针一样操作对象
	*sp = 20;
	cout << *sp << endl;
}


int main(){

	test();

	system("pause");
	return 0;
}

总结指针指针：

  1. 利用RAII思想，实现自动释放资源。
  2. 重载operator*和operator->，使其具有和指针一样的行为和功能。

二.智能指针的分类

        上面的代码有一个bug：

原因：

        用sp1拷贝构造sp2，由于是浅拷贝。会使得两个对象的成员变量指向同一块空间。两个对象在析构时，导致一块空间释放了两次。所以程序会奔溃。

随着C++的发展，有三个解决方案，一个方案对应着一种智能指针。

  1. 将指针的管理权转移给另外一个对象。对应C++98的auto_ptr。
  2. 防止拷贝。对应C++11的unique_ptr。
  3. 引用计数。对应C++11的shared_ptr。

注意：智能指针都包含在memory的库中，要使用智能指针必须包含这个库。

        2.1 auto_ptr介绍

        auto_ptr的原理是：将资源的管理权由一个对象转移给另外一个对象。

         但是这样会有一个问题，如果重新访问ap1，就会出现问题。这种方式在实际在编程中用得少。

模拟实现auto_ptr：

注意：赋值防止自己给自己赋值，还需要释放当前对象以前的资源。

template<class T>
class AutoPtr{
private:
	T* _ptr;
public:
	
	AutoPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}

	//拷贝构造
	//将ap资源的管理权交当前对象
	AutoPtr(const AutoPtr<T>& ap){
		_ptr = ap._ptr;
		ap._ptr = nullptr;
	}

	AutoPtr<T>& operator=(const AutoPtr<T>& ap){
		//防止自己给自己赋值
		if (this != &ap){
			//释放之前的资源
			if (_ptr){
				delete _ptr;
			}

			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}
		return *this;
	}

	T& operator*(){
		return *_ptr;
	}
	T* operator->(){
		return _ptr;
	}


	//在对象析构时，自动释放资源
	~AutoPtr(){
		if (_ptr){
			cout << "delete ptr" << endl;
			delete _ptr;
		}

	}
};

        2.2 unique_pt介绍

        针对auto_ptr的不足，C++11根据自己的一些语法，设计了一种更靠谱的智能指针，unique_ptr。

        原理：直接简单粗暴，将构造和拷贝构造直接禁止编译器默认生成。

 unique_ptr模拟实现： 

#pragma once

#include<iostream>

using namespace std;

template<class T>
class UniquePtr{
private:
	//C++98，将拷贝构造和赋值，显示声明，设为私有
	//外部无法调用
	UniquePtr(UniquePtr<T>& up);
	UniquePtr<T>& operator=(UniquePtr<T>& up);


	T* _ptr;
public:
	//将外面申请的资源，托管给类的成员
	UniquePtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}

	//利用C++11语法，禁止编译器默认生成
	UniquePtr(UniquePtr<T>& up) = delete;
	UniquePtr<T>& operator=(UniquePtr<T>& up) = delete;


	T& operator*(){
		return *_ptr;
	}
	T* operator->(){
		return _ptr;
	}


	//在对象析构时，自动释放资源
	~UniquePtr(){
		if (_ptr){
			cout << "delete ptr" << endl;
			delete _ptr;
		}

	}
};

         2.3 shared_ptr介绍

        shared_ptr原理：在类中增加一个成员变量用来计数。每次调用一次拷贝构造和赋值重载函数，即每增加一个管理者，计数加1。没析构一个管理者对象，计数器减1，直到减为0，才真正释放资源。

  • shared_ptr内部，给每一份资源维护了一个计数器，用来记录该份资源被几个对象共享。
  • 在对象被销毁，也就是调用析构时，说明不在管理该资源，计数器减1。
  • 如果引用计数等于0，说明当前对象是最后一个使用该资源的对象，必须释放资源。
  • 当引用计数不等于0，说明还有对象在管理资源，不能释放资源。

注意：

       shared_ptr只有在构造和赋值的时候计数才会加1。

计数器如何设置：

        由于当前计数器属于同一资源的对象，可以将计数器设计成一个指针。

        不能设计成引用，引用要引用外部变量，需要外部管理。也不能设计成静态成员变量，静态成员变量，属于整个类，如果当前类要同时管理其它资源计数器就乱了。

线程安全问题：

        由于引用了一个计数器。计数器自增(++)，自减(--)和判断的行为不是原子的。当多个线程进入，会导致线程安全问题。从而导致资源没有释放，造成内存泄漏。

        为了保证线程安全，可以在shared_ptr类中，再增加一把锁。由于同一份资源的对象要看到同意把锁，所以，锁也需要声明成指针类型。

shared_ptr模拟实现：

        注意：

  1. 在赋值重载函数中，首先需要判断是否是自己给自己赋值；
  2. 其次，不能直接释放被赋值对象的资源，需要先将计数器减1(当前对象不管理了)，当计数器等于0，说明没有其它对象管理当前资源，才将资源释放。
  3. 在析构函数中，也是需要将计数器减为0 了，才能将资源释放。
  4. 释放资源时注意，需要先解锁了，再释放锁的资源。
  5. 在计数器自增，自减和判断前需要加锁。
namespace zl
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr=nullptr)
			:_ptr(ptr)
			,_pcount(new int(1))
			,_pmtx(new mutex)
		{}

		template<class D>
		shared_ptr(T* ptr ,D del)
			:_ptr(ptr)
			, _pcount(new int(1))
			, _pmtx(new mutex)
			,_del(del)
		{}

		~shared_ptr()
		{
			Release();
		}

		void Release()
		{
			_pmtx->lock();

			bool deleteFlag = false;

			if (--(*_pcount) == 0)
			{
				if (_ptr)
				{
					//cout << "delete:" << _ptr << endl;
					//delete _ptr;

					//删除器进行删除
					_del(_ptr);
				}
				
				delete _pcount;

				deleteFlag=true;

				//delete _pmtx;       //如何解决？
			}
			_pmtx->unlock();

			if (deleteFlag)
			{
				delete _pmtx;
			}
		}

		void AddCount()
		{
			_pmtx->lock();
			++(*_pcount);
			_pmtx->unlock();
		}

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
			,_pmtx(sp._pmtx)
		{
			AddCount();
		}

		//sp1=sp4
		//sp1=sp1
		//sp1=sp2
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (--(*_pcount) == 0)
			{
				/*cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pcount;*/

				Release();
			}

			_ptr = sp._ptr;
			_pcount = sp._pcount;
			_pmtx = sp._pmtx;

			AddCount();

			return *this;
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		T* get() const
		{
			return _ptr;
		}

		int use_count()
		{
			return *_pcount;
		}

	private:
		T* _ptr;
		//static int* _count;    //静态这种方案是不行的，因为属于所有对象，多个对象可能多个资源，每个资源应该配对一个引用计数
		int* _pcount;
		mutex* _pmtx;

		//包装器
		function<void(T*)> _del = [](T* ptr) {
			cout << "lambda delete:" << ptr << endl;
			delete ptr;
		};
	};
}

shared_ptr缺陷：

循环引用问题：

一种情况：

         当循环引用时，shared_ptr会出现资源没有释放的问题。

解决方案：

        C++11增加了一个weak_ptr专门来解决shared_ptr循环引用的问题。

        原理是：weak_ptr的成员变量是shared_ptr，不在具有RAII的思想，只是具有指针的功能，也就是，不会释放资源，也不会将计数器计数。

        使用weak_ptr前提是，知道是循环引用了。

template<class T>
class WeakPtr{
private:
	T* _wptr;
public:

	WeakPtr(T* wptr = nullptr){
		_wptr = wptr;
	}
	//用shared_ptr构造
	WeakPtr(const SharedPtr<T>& sp){
		_wptr = sp.GetPtr();
	}

	WeakPtr<T>& operator=(const SharedPtr<T>& sp){
		_wptr = sp.GetPtr();
		return *this;
	}
	//具有指针的功能
	T* operator->(){
		return &_wptr
	}

	T& operator*(){
		return *_wptr;
	}
};

 上面问题的改造：

  删除器：

        shared_ptr类里默认的在析构函数里释放资源使用的是delete。但是当我们申请出来的不是一个对象，而是多个对象时：

 于是C++11增加了一个删除器，可以根据申请对象的不同，设计删除动作，传入shared_ptr中。

实际用法是，写一个仿函数类(写一个类，从在operator()函数，函数实现是需要删除资源的动作)，实例化对象，传入shared_ptr中。

template<class T>
class Del{
public:
	void operator()(T* ptr){
		delete[] ptr;
	}
};


class DelFle{
public:
	void operator()(FILE* ptr){
		fclose(ptr);
	}
};

void test(){
	Del<int> d;
	shared_ptr<int> sp1(new int[10], d);
	
	DelFle df;
	shared_ptr<FILE> sp2(fopen("text.txt", "w"), df);

	
}

C++ 11 _智能指针
weixin_44387482的博客
04-23 1097
C++11_智能指针
C++ 11 -智能指针
cat_fish_rain的博客
06-18 2589
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
C++智能指针
最新发布
2302_80208047的博客
07-06 1109
如果。
C++11：智能指针
苦逼的程序猿☺
08-19 752
RAII RAII，全称资源获取即初始化（英语：Resource Acquisition Is Initialization）。 RAII要求，资源的有效期与持有资源的对象的生命期严格绑定，即由对象的构造函数完成资源的分配（获取），同时由析构函数完成资源的释放。在这种要求下，只要对象能正确地析构，就不会出现资源泄露问题。 传统 C++ 中，『记得』手动释放资源，总不是最佳实践。因为我们很有可能就忘记了去释放资源而导致泄露。 而 C++11 引入了智能指针的概念，使用了引用计数的想法，让程序员不再需要关心手动
c++11之智能指针
热门推荐
qq_56673429的博客
05-18 2万+
前言：面试的时候被问到智能指针了，答的很糟糕，这几天重新学习了智能指针。下面是我对c++智能指针的理解与总结，希望能帮到大家，同时提升自己。 一，什么是智能指针 在C++中没有垃圾回收机制，必须自己释放分配的内存，否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针（smart pointer）。智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。智能指针的核心实现技术是引用计数，每使用它一次，内部引用计数加1.
【C++】————智能指针
bhbcdxb123的博客
08-20 2634
在C++中没有垃圾回收机制，必须自己释放分配的内存，否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针（smart pointer）。智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。智能指针的核心实现技术是引用计数，每使用它一次，内部引用计数加1，每析构一次内部的引用计数减1，减为0时，删除所指向的堆内存。c++中用的最多的是下面三种智能指针。
C++——智能指针
2303_78442132的博客
08-05 1288
C++、智能指针
c++面试——智能指针
weixin_42059276的博客
08-10 772
为什么使用智能指针（什么是智能指针）？ 使用指针申请的空间，很可能在函数结束时忘记释放，或还没有执行到释放空间的代码就已经跳出函数，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题， 智能指针定义了类似指针的对象，可以将new获得的地址赋给这种对象，管理在堆上分配的内存；当智能指针过期时，其析构函数将使用delete来释放内存，这些内存将自动被释放。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。 使用时需包含memory头文件，在std命名空间中。 智能指针有哪些？
c++11智能指针
01-06
智能指针     智能指针是行为类似于指针的类对象。可以帮助管理动态内存分配。普通指针分配内存后都必须释放内存 new 之后需要使用 delete 否则内存泄漏。智能指针类对象封装了自动释放内存的功能 从而避免内存泄漏 例如 void remodel(std::string & str) { std::string * ps = new std::string(str); //str = ps; return; //内存泄漏 } void remodel1(std::string & str1) { std::shared_ptr ps(new std::string(str1))
奇妙的C++——智能指针
03-18
在C++11及其后续标准中，智能指针已经成为标准库的一部分，为程序员提供了强大的工具。 智能指针主要有三种类型： 1. **std::unique_ptr**：这是独占所有权的智能指针，一旦一个对象被std::unique_ptr拥有，其他...
C++11之智能指针
君莫笑的博客
03-30 1224
C++11之智能指针
C++ 智能指针 C++11
a956365775的博客
07-22 136
一、缘起 C++ 语言没有自动内存回收机制，每次 new 出来的内存都要手动 delete。 程序员忘记 delete，流程太复杂，最终导致没有 delete； 异常导致程序过早退出，没有执行 delete 的情况并不罕见。 用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。 包括：std::auto_ptr、std::shared_ptr、std::weak...
C++11中的智能指针
liyucheng777的博客
12-14 1211
无
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值