[C++高级部分]--智能指针

最新推荐文章于 2024-07-25 09:47:19 发布
最新推荐文章于 2024-07-25 09:47:19 发布
阅读量674 收藏 4
点赞数 1
分类专栏： C++高级 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40559864/article/details/129122502
版权

智能指针

基础知识

堆上开辟的内存(new)，一定要人为地去进行释放（delete），使用裸指针去指向堆上开辟的内存，如果程序运行过程中发生异常情况，终止运行了，那么有可能出现，没有执行delete去释放堆上的内存，导致内存的泄漏，如果使用裸指针就需要考虑各种异常情况，并确保发生异常时能够顺利释放堆上的内存资源。

  • 智能指针----->保证做到资源的自然释放，具体是如何实现的呢？

    利用栈上的对象出作用域会自动调用析构函数来进行资源的自动释放

// 可以看到智能指针其实是对裸指针的一个封装
template<typename T>
class CSmartPtr 
{
public:
	CSmartPtr(T* ptr=nullptr) :mptr(ptr) { cout << "CSmartPtr(const T * ptr)" << endl; }
	~CSmartPtr() 
	{
		delete mptr;
	}
    // 为了保证智能指针使用起来和裸指针的表现是一致的，所以提供以下运算符重载函数
	T& operator*() { return *mptr; }
	T* operator->() { return mptr; }
private:
	T* mptr;
};

class Test
{
public:
	void test() { cout << "test()" << endl; }
};


int main() 
{
	CSmartPtr<int> ptr1(new int);
	//栈上的对象出作用域会自动调用析构函数来进行资源的自动释放
	*ptr1 = 20;

	CSmartPtr<Test> ptr2(new Test());
	//(ptr2.operator->())->test()
	ptr2->test();
    
	return 0;
}

不带引用计数的智能指针

  • auto_ptr（C++库自带）

C++11标准提供：

  • scoped_ptr

  • unique_ptr

auto_ptr:转移资源的“所有权”（不推荐使用）

auto_ptr<int> ptr1(new int);
auto_ptr<int> ptr2(ptr1); // 转移了资源的所有权，但是在代码层面没有体现出来，用户会认为现在ptr1和ptr2都指向一块堆内存
/*
拷贝构造时，会先调用ptr1的release方法，先记住堆内存的地址，然后将地址给ptr2,ptr1底层指针则置为nullptr;

一连串拷贝构造后只会让最后一个元素指向堆上的资源，之前的指针全部置空；

vector容器中如果使用了该智能指针 vector<auto_ptr<int>> vec1; vec2(vec1)如果发生容器的拷贝构造时vec1容器的所有底层指针将全部被置为nullptr 
*/

scoped_ptr

// 直接删除拷贝构造和赋值运算符重载函数,这种方法更加暴力
// 如果没有删除，也没有自定义拷贝构造或者赋值运算符重载函数，就会生成默认的函数去执行浅拷贝，删除后如果进行赋值或者拷贝构造是会报错的
scoped_ptr(const scoped_ptr<T>& src) = delete;
scoped_ptr<T>& operator=(const scoped_ptr<T>& src) = delete;
// =delete是C++11提供的新语法

unique_ptr

一块内存只由一个指针所指向

// 删除了带左值引用参数的拷贝构造和赋值运算符重载函数
unique_ptr(const unique_ptr<T>& src) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>& src) = delete;

// 定义了带右值引用的拷贝构造和赋值运算符重载函数(注意里面的操作都是关于指针指向的改变，即资源转移)
unique_ptr(unique_ptr<T>&& src);
unique_ptr<T>& operator=(unique_ptr<T>&& src);

unique_ptr<int> ptr1(new int);
// 使用时，用户可以直接明白代码用意是将ptr1的资源给ptr2，从而明白后续使用*ptr1也是没有意义的 
unique_ptr<int> ptr2(std::move(ptr1)); //显式把ptr1资源转移给ptr2，ptr1不持有资源

带引用计数的智能指针

和不带引用计数的智能指针相比起来，带引用计数的智能指针支持多个智能指针可以管理同一个资源

带引用计数的智能指针：

  • shared_ptr
  • weak_ptr

（这两个指针都是线程安全的，可以直接使用在多线程环境中）

为每一个对象资源，匹配一个引用计数，当智能指针获取资源的时候，引用计数+1，当智能指针不使用资源的时候，引用计数-1，如果减1后引用计数为0了，那么说明这是最后一个使用该资源的指针，可以对资源进行释放了。

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

// 定义引用计数类模板
template<typename T>
class RefCnt 
{
public:
	RefCnt(T* ptr = nullptr) 
		:mptr(ptr)
		,_mount(0)
	{
		// 注意引用的资源要不为空，_mount才初始为1
		if (nullptr != mptr)
			_mount = 1;
	}

	void addRef() { ++_mount; }
	int delRef() { return --_mount; }
private:		
	T* mptr;	// 指向内存资源
	int _mount;	// shared_ptr和weak_ptr中引用计数都设置为atomic_int，原子整型，线程安全
};

// 定义带引用计数的智能指针类模板
template<typename T>
class CSmartPtr 
{
public:
	CSmartPtr(T* ptr = nullptr) 
		:mptr(ptr)
		,mpRefCnt(new RefCnt<T>(mptr))
	{}

	CSmartPtr(const CSmartPtr<T>& src) 
		:mptr(src.mptr)
		,mpRefCnt(src.mpRefCnt)
	{
		if (nullptr != mptr)
			mpRefCnt->addRef();// 引用计数+1
	}

	CSmartPtr<T>& operator=(const CSmartPtr<T>& src) 
	{
		if (this == &src)
			return *this;
		
        // 当前引用资源的引用计数要减一，然后判断当前资源引用计数是否为0
		if (0 == mpRefCnt->delRef()) 
		{
			delete mptr;
		}

		mptr = src.mptr;
		mpRefCnt = src.mpRefCnt;
		mpRefCnt->addRef();

		return *this;

	}

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

	~CSmartPtr() 
	{
		// 对原来资源的引用计数为0时，由最后一个指针进行释放
        if (mpRefCnt->delRef() == 0)
		{
			delete mptr;
			delete mpRefCnt;
			mptr = nullptr;
			mpRefCnt = nullptr;
		}
	}
private:
	T* mptr;
	RefCnt<T>* mpRefCnt;
};

int main()
{
    // 智能指针要在栈上定义
	CSmartPtr<int> ptr1(new int);
	CSmartPtr<int> ptr2(ptr1);

	CSmartPtr<int> ptr3;
	ptr3 = ptr2;
	// ptr1, ptr2, ptr3通过引用计数管理同一块资源

	*ptr1 = 20;
	cout << *ptr2 << " " << *ptr3 << endl;
	return 0;
}

在这里插入图片描述

我们自定义的带引用计数的智能指针不是线程安全的，无法用于多线程环境下，而对于shared_ptr和weak_ptr这两个C++所提供的智能指针，它们的引用计数中mount是实现成atomic_int，即原子类型的，对于mount的加减操作具有原子性，所以这两个指针是线程安全的，可以用于多线程环境中。

shared_ptr的交叉引用问题

  • shared_ptr: 强智能指针 可以改变资源的引用计数

  • weak_ptr: 弱智能指针 不会改变资源的引用计数，只是观察者
    只观察资源
    不提供operator*(), operator->()方法

强智能指针循环引用(交叉引用 )是什么问题? 什么结果? 怎么解决？
new出来的资源无法释放，造成资源泄漏问题
解决: 定义对象的时候用强智能指针，引用对象的时候用弱智能指针

强智能指针循环引用(交叉引用 )问题：

class B;
class A
{
public:
	A() { cout << "A()" << endl; }
	~A() { cout << "~A()" << endl; }
	void testA() { cout << "testA()" << endl; }
	shared_ptr<B> _ptrb;
private:

};

class B
{
public:
	B() { cout << "B()" << endl; }
	~B() { cout << "~B()" << endl; }
	shared_ptr<A> _ptra;
private:
};

int main()
{
	// 栈定义对象的时候用强智能指针
	shared_ptr<A> pa(new A());
	shared_ptr<B> pb(new B());


	pa->_ptrb = pb;
	pb->_ptra = pa;
	// 查看资源的引用计数
	cout << pa.use_count() << endl;
	cout << pb.use_count() << endl;
	return 0;
}

在这里插入图片描述

A,B对象的引用计数都为2，出作用域后，引用计数都减1后都为1，不为0，所以A,B对象无法析构，资源无法释放，导致内存的非法泄漏

在这里插入图片描述

（引用计数在资源那，表示一块资源被几个指针所指向）

在定义对象的时候用强智能指针，引用对象的时候用弱智能指针：

class B;
class A
{
public:
	A() { cout << "A()" << endl; }
	~A() { cout << "~A()" << endl; }
	void testA() { cout << "testA()" << endl; }
	weak_ptr<B> _ptrb; // 引用对象的时候用弱智能指针,观察资源是否存在，不增加引用计数
private:

};

class B
{
public:
	B() { cout << "B()" << endl; }
	~B() { cout << "~B()" << endl; }
	//shared_ptr<A> _ptra;

	//void func() 
	//{
	//	_ptra->testA();//弱智能指针只是观察者
	//}

	// 如何使用弱智能指针
	void func()
	{// 判断观察的资源是否存在，如果存在就将弱智能指针提升为强智能指针
		shared_ptr<A> ps = _ptra.lock(); // 提升方法
		if (ps != nullptr)
		{
			ps->testA();
		}
	}
	weak_ptr<A> _ptra;
private:
};

int main()
{
	// 栈定义对象的时候用强智能指针
	shared_ptr<A> pa(new A());
	shared_ptr<B> pb(new B());


	pa->_ptrb = pb;
	pb->_ptra = pa;
	// 查看资源的引用计数
	cout << pa.use_count() << endl;
	cout << pb.use_count() << endl;
	return 0;
}

在这里插入图片描述

weak_ptr只是一个观察者，观察资源是否存在，并不会增加资源的引用计数，并且***weak_ptr没有提供像裸指针一样的*和->运算符重载函数，也就是说并不能通过它访问资源的具体内容 **；

weak_ptr可以通过lock()方法提升成为强智能指针，如果资源已经被释放了，那么提升就会失败，如果提升成为shared_ptr，那么资源的引用计数也要加1，当然shared_ptr提供了*和->运算符重载函数。在上面的代码中，我们在B中定义的func方法中可以通过提升weak_ptr，如果提升成功，就可以通过其调用A中的testA()方法（shared_ptr和wea_ptr都是线程安全的，可以使用在多线程环境中）

多线程访问共享对象的线程安全问题

多线程访问共享对象的线程安全问题

class B;
class A
{
public:
	A() { cout << "A()" << endl; }
	~A() { cout << "~A()" << endl; }
	void testA() { cout << "testA()" << endl; }
	weak_ptr<B> _ptrb; // 引用对象的时候用弱智能指针,观察资源是否存在，不增加引用计数
private:

};

class B
{
public:
	B() { cout << "B()" << endl; }
	~B() { cout << "~B()" << endl; }
    
	// 如何使用弱智能指针
	void func()
	{// 判断观察的资源是否存在，如果存在就将弱智能指针提升为强智能指针
		shared_ptr<A> ps = _ptra.lock(); // 提升方法
		if (ps != nullptr)
		{
			ps->testA();
		}
	}
	weak_ptr<A> _ptra;
private:
};

// 子线程
void handler01(A* q) 
{
	std::this_thread::sleep_for(std::chrono::seconds(2));
	q->testA();
}

// 主线程
int main()
{
	A* p = new A();
	thread t1(handler01, p);
	delete p;
	t1.join();
	return 0;
}

在这里插入图片描述

可以看到，主线程启动子线程后，马上去析构A对象，但是在子线程中依然调用了对象A的testA方法，这显然是不安全的，我们应该在调用前添加资源是否存在的判断！！

强弱智能指针的应用

void handler01(weak_ptr<A> ptr) 
{
    std::this_thread::sleep_for(std::chrono::seconds(2));
	shared_ptr<A> q = ptr.lock();
	if (q != nullptr) 
	{
		q->testA();
	}
	else 
	{
		cout << "对象已经析构了,无法访问...." << endl;
	}
}

int main()
{
	{
		shared_ptr<A> ptr1(new A());
		thread t1(handler01, weak_ptr<A>(ptr1)); 
		t1.detach();//分离线程
	}// 出作用域，ptr1自动执行析构函数，所引用的资源的引用计数-1
	 
	std::this_thread::sleep_for(std::chrono::seconds(20));
	return 0;
}

在这里插入图片描述

可以看到通过使用强弱指针，在主线程中，出{}作用域后，ptr1要调用析构函数，先是对A资源的引用计数减1，由于资源A的引用计数减为0了，所以ptr1还要负责对资源A进行析构，然后在子线程中weak_ptr作为资源A的观察者，提升为强指针失败，说明资源已经不存在了，所以无法再调用A的方法。

多个线程访问共享对象，如果某个线程中由于对象的引用计数为0，对其进行析构了，通过强弱指针，可以避免其他线程在资源被释放后，再去访问对象的成员

自定义删除器

智能指针的删除器 deletor
智能指针: 保证资源的绝对释放

  • 自定义删除器类模板，控制资源的释放
template<typename T>
class MyDeletor 
{
public:
    // 小括号运算符重载
	void operator()(T* ptr)const 
	{
		cout << "call MyDeletor::operator()(T* )" << endl;
		delete[]ptr;
	}
};

template<typename T>
class MyFileDeletor
{
public:
    // 小括号运算符重载
	void operator()(T* ptr)const
	{
		cout << "call MyFileDeletor::operator()(T* )" << endl;
		fclose(ptr);
	}
};


int main() 
{
    // 传入我们自定义的删除器类型
	unique_ptr<int, MyDeletor<int>> ptr1(new int[100]);
	// unique_ptr<FILE, MyFileDeletor<FILE>> ptr2(fopen("data.txt", "w"));
	return 0;
}

但是这种自定义删除器类模板的方式比较复杂，不同的资源(比如数组，文件等)释放的方式不一样，这样就需要去定义多个类模板了

  • 使用C++11提供的lambda表达式（lambda表达式是一个函数对象），并且使用c++11提供的function函数对象类，来实例化智能指针类

    通过function函数对象以及lambda表达式自定义智能指针对资源的释放方式

int main() 
{//function<返回值 参数类型> -->函数对象类型
	unique_ptr<int, function<void (int*)>> ptr1(new int[100],
		[](int* p)->void {
			cout << "call lambda release" << endl;
			delete[]p;
		}
	);

	unique_ptr<FILE, function<void (FILE*)>> ptr2(fopen("data.txt", "w"),
		[](FILE* p)->void {
			cout << "call lambda FILE close" << endl;
			fclose(p);
		}
	);
	return 0;
}

既然自定义删除器，是为了自己实现对指针所指向的资源的释放方式，那么lambda形参列表的参数肯定是相应类型的指针变量

下酒番陪绅士
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
释放智能指针 make_shared_看完这篇，别再说不会智能指针了
weixin_39861905的博客
11-25 5860
C++智能指针一、智能指针的作用上一篇介绍了内存池的原理和实现，详情请见内存池设计与实现；内存池可以帮助我们有效的对内存进行管理，智能指针可以很方便的管理指针，避免出现内存泄漏；智能指针的作用智能指针的作用：智能指针可以帮助我们避免在申请空间后忘记释放造成内存泄漏的问题；因为智能指针本身是一个类（后面也会自己实现一下），当出了类的作用域的时候，类会调用析构函数进行释放资源。所以智能指针的作用原理就...
[C++] 智能指针
jiang_T的博客
10-24 125
智能指针智能指针shared_ptr——共享的智能指针shared_ptr 的使用方法4种初始化方式获取原始指针管理动态数组时指定删除器需要特别注意的问题unique_ptr——独占的智能指针unique_ptr 的使用方法unique_ptr 的特性weak_ptr——弱引用的智能指针weak_ptr 的使用方法智能指针的多线程安全问题 智能指针 C++11之前我们必须自己通过调用new和delete来管理堆内存的申请和释放，但是一些情况下很容易忘记调用delete导致出现内存泄漏问题，亦或是出现二次释放
【C++】智能指针
m0_69597277的博客
05-21 1250
智能指针可以帮助我们避免在申请空间后忘记释放造成内存泄漏的问题。实际上智能指针是一个类，而我们知道，类中的析构函数会在对象出了类作用域时调用析构函数进行资源的释放，所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。编译环境：vs20131 在最终的实现的shared_ptr，智能指针是线程安全的吗？
学习open62541 --- [76] 使用智能指针处理内存释放问题
爱就是是恒久忍耐的专栏
05-20 1499
使用智能指针处理内存释放问题
掌握C++新特性中智能指针的综合指南
Lion_Long的博客
10-08 826
本文是一篇关于C++中智能指针的综合指南，旨在深入探讨现代内存管理的核心概念和技术。智能指针是C++中一种强大的工具，可以帮助开发人员更安全、高效地管理内存资源。通过详细解析各种类型的智能指针，包括unique_ptr、shared_ptr和weak_ptr，读者将了解它们的原理、用法和适用场景。本文将重点介绍智能指针的优势，如自动内存释放、避免内存泄漏和循环引用等问题。此外，还将讨论智能指针与传统指针的区别，并提供一些最佳实践和实用技巧，帮助读者在实际项目中正确、高效地使用智能指针。
还在因为指针的释放问题而烦恼吗？快来看下C++11智能指针shared_ptr
再努力一点点就好了
04-30 2306
本文主要记录了关于C++中智能指针的概念，以及其中shared_ptr的原理，实现，作用以及相关问题
[C++]智能指针的实现
jiang_T的博客
12-21 577
注：源码来源为 llvm/llvm-project 使用智能指针时我们所包含的头文件为<memory>，而关于shared_ptr<T>的类定义实际上在shared_ptr.h中，为了便于理解，此处仅从源码中截取出其部分构造函数、成员变量以及重载的赋值运算符： template<class _Tp> class shared_ptr { private: element_type* __ptr_; // 所管理的对象内存的指针 __shared
Android C++高级编程-使用NDK_源码
04-16
《Android C++高级编程-使用NDK》是深入探索Android平台下C++开发的一本教程，结合源码学习可以极大地提升对Android NDK的理解和应用能力。NDK（Native Development Kit）是Google提供的一个工具集，它允许开发者...
c++的学习-与-总结
02-28
3. 内存管理：C++提供了动态内存分配（new、delete）和智能指针（auto_ptr, shared_ptr, unique_ptr）来管理内存，防止内存泄漏。 4. STL（Standard Template Library）：标准模板库，包括容器（如vector、list、map...
C++ 备忘单-.pdf
02-27
1. **智能指针**： - `std::unique_ptr`, `std::shared_ptr` 2. **模板**： - 函数模板：`template<typename T> T functionName(T param);` - 类模板：`template<typename T> class ClassName { ... };` 3. **...
C++如何用智能指针管理内存资源
12-16
1.简介 ...智能指针是C++程序员们一件管理内存的利器，使用智能指针管理内存资源，实际上就是将申请的内存资源交由智能指针来管理，是RAII技术的一种实现。RAII是C++的之父Bjarne Stroustrup教授提
高质量C++编程指南-林锐
04-15
书中强调了智能指针的使用，如shared_ptr、unique_ptr，以及何时使用new和delete。 7. **RAII（资源获取即初始化）**：RAII是C++中一种重要的编程策略，用于确保资源在生命周期内的正确管理。书中通过实例解释了...
【c++】：智能指针
leijie1123的博客
11-29 724
c++智能指针的内容，auto_ptr,unique_ptr,shared_ptr,weak_ptr
C++：智能指针
qq_45481606的博客
10-16 120
内存泄漏： 指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。 内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。 危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。 采用RAII思想或者智
C++智能指针
分享学习的知识，记录我的技术成长道路
10-03 863
在C++中，动态内存的使用时有一定的风险的，因为它没有垃圾回收机制，很容易导致忘记释放内存的问题，具体体现在异常的处理上。想要释放掉抛异常的程序的一些内存，往往需要多次抛异常，这种处理方式是十分麻烦的。智能指针的本质就是使用一个对象来接管一段开辟的空间，在该对象在销毁的时候，自动调用析构函数来释放这段内存。因此智能指针的本质是一个类，类中最主要的对象是一个指针，该类的析构函数就是销毁该指针指向的空间，使用智能指针的本质就是将一个指向动态开辟空间的指针赋给该类中的指针。
C++11动态内存与智能指针
灰太狼的小秘密
01-10 3659
一、动态内存 二、智能指针
智能指针的原理和常用的智能指针及其实现
qq_52399817的博客
04-10 330
智能指针的原理和常用的智能指针及其实现，shared_ptr、weak_ptr、auto_ptr、unique_ptr
c++动态申请指针数组
weixin_45465323的博客
10-27 2367
c++中动态申请指针数组遇到的问题 当动态申请指针数组时需要用到二级指针，比如 int** a = new int*[n]; 这个时候，指针数组中的每一个单指针还没有申请空间，因此需要用一个循环来为单指针分配空间 for(int i = 0;i < n;i ++) { a[i] = new int; } ...
【C++】C++中的find方法介绍
最新发布
qq_35902025的博客
07-25 408
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
C++高级专题：cast运算符、智能指针与异常处理详解
本篇C++高级专题讲解了C++中的关键知识点，包括类型转换、cast运算符以及特定的C++特性。首先，文章强调了C++对类型转换的改进，相较于C语言，C++的cast运算符旨在解决类型转换中的语义模糊和潜在危险，提供四种cast...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

下酒番陪绅士

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值