自学C++ day13 智能指针

最新推荐文章于 2024-08-12 16:55:46 发布
最新推荐文章于 2024-08-12 16:55:46 发布
阅读量225 收藏
点赞数
分类专栏： flag 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51262652/article/details/126196803
版权 
// 智能指针！
// 内存泄露：
// 堆内存泄露：
//		堆内存指的是程序执行中依据需要分配通过 malloc/calloc/new 等从堆中分配一块
// 内存，用完后必须通过调用相应的free或者delete 删掉。 假设程序的设计错误导致这部
// 分内存没有被释放，那么以后这部分内存将无法再次被使用，会产生 Heap Leak。

//  系统资源泄露：
//  指程序使用系统分配的资源，比如套接字，文件描述符，管道等没有使用对应的函数释放掉
// 导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。


// 避免内存泄漏的办法:
// 1. 采用RALL 思想或者智能指针来管理资源，(由对象的生命周期来管理内存！)；

// RALL（resource acquisition is initialization） 是一种利用对象生命周期来控制程序资源的简单技术。
# if 0
	在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。
	借此，我们实际上把管理一份资源的责任交给了一个对象。
好处：
	* 不需要显示的释放资源。
	* 采用这种方式，对象所需的资源在其生命周期内始终保持有效。
#endif 

#if 0
// 采用 RALL 的思想设计SmartPtr 类

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

		~SmartPtr() {
			if (_ptr) {
				delete _ptr;
			}
		}
	private:
		T* _ptr;
	};
#endif 

	
#if 0

	智能指针的原理，SmartPtr 还不能将其称为只能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过-> 去访问空间上的内容
	因此： 要重载一线 *, -> 才能像指针一样使用。
#endif 

#if 0
#include <iostream> 

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

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

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

		~SmartPtr() {
			if (_ptr) {
				delete _ptr;
			}
		}
	private:
		T* _ptr;
	};
	
	struct Date {
		int _year;
		int _month;
		int _day;
	};

	int main() {
		SmartPtr<int> sp1(new int);
		*sp1 = 10;
		std::cout << *sp1 << std::endl;

		SmartPtr<Date> sparr(new Date);

		sparr->_day = 10;
		sparr->_month = 7;
		sparr->_year = 2022;
		std::cout << " ";
		return 0;
	}
#endif 


#if 0
// C++ 98 提供 auto_ptr 的智能指针。(不好用，被拷贝的因该是调用了swap)
#include <iostream> 

	class Dat {
	public:
		Dat() {
			std::cout << "Dat()" << std::endl;
		}
		~Dat() {
			std::cout << "~Dat()" << std::endl;
		}
		int _year;
		int _month;
		int _day;
	};

	int main() {
		std::auto_ptr<Dat> ap(new Dat);
		std::auto_ptr<Dat> copy(ap);

		// auto_ptr 的问题，当对象拷贝或者赋值后，前面的对象就悬空了.
		// C++ 98 中auto_ptr 问题非常明显.
		copy->_year = 2023;
		ap->_year = 2022; // 悬空！== empty
		return 0;
	}

	// 模拟实现 C++98 中的Auto_ptr

	template<class T>
	class AutoPtr {
	public:
		AutoPtr(T* ptr):_ptr(ptr){}
		~AutoPtr() {
			if (_ptr) {
				delete _ptr;
			}
		}

		// 拷贝构造，一旦发生拷贝，就将ap中的资源转移到当前对象中，让后让ao与其管理的资源分手，这样就解决了一块内存被多个对象使用造成的程序崩溃问题！
		AutoPtr(AutoPtr<T>& ap):_ptr(ap) {
			ap._ptr = nullptr;
		}

		AutoPtr<T>& opeartor = (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;
		}
	};

#endif 

#if 0

	C++ 11 做了改进，为了防止一份内存再多个对象中使用造成程序崩溃的问题，直接来一个unique_ptr;
	// unique_ptr 直接简单粗暴的不允许拷贝和赋值操作，保证一个人只有一个老婆，而且不能再换老婆了！。

	// 下面简单的模拟实现一下：

	template<class T>
	class UniquePtr {
	private:
		T* _ptr;
	public:
		UniquePtr(T* ptr) :_ptr(ptr){}
		~UniquePtr() {
			if (_ptr) delete _ptr;
		}
		T& operator*() {
			return *_ptr;
		}

		T* operator->() {
			return _ptr;
		}
	private:
		// C++ 98 防止拷贝的方式：只声明不实现 + private 
		UniquePtr(const UniquePtr<T>& uq);
		UniquePtr& operator=(UniquePtr<T> const&);

		// C++ 11 防止拷贝的方式 == delete 
		UniquePtr(const UniquePtr<T>& uq) = delete;
		UniquePtr& operator=(UniquePtr<T> const&) = delete;
	};
#endif 

#if 0
#include <iostream>

	class Dat {
	public:
		Dat() {
			std::cout << "Dat()" << std::endl;
		}
		~Dat() {
			std::cout << "~Dat()" << std::endl;
		}
		int _year;
		int _month;
		int _day;
	};

	// C++ 11 提供类支持拷贝且靠谱的shared_ptr 
	int main() {
		// shared_ptr 通过引用计数支持智能指针对象的拷贝！
		std::shared_ptr<Dat> sp(new Dat);
		std::shared_ptr<Dat> copy(sp);

		std::cout << "ref count : " << sp.use_count() << std::endl;
		std::cout << "ref count : " << copy.use_count() << std::endl;
		return 0;
	}

	1. shared_ptr 在其内部，给每个资源都维护这一份计数器，用来记录该份资源被几个对象共享了。
	2. 在对象被销毁时（调用析构函数），就说明自己不使用该资源了，对象引用计数减一。
	3. 如果引用计数是 0 ，就说明自己是最后一个使用该资源的对象，必须释放该资源。
	4. 如果引用计数不是0，就说明出了自己还有其他对象在使用改分资源，不能释放该资源。

#endif 

#if 0
// 模拟实现一份 SharedPtr
#include <iostream> 
#include <mutex> 

template<class T>
	class SharedPtr {
	public:
		SharedPtr(T* ptr = nullptr):_ptr(ptr),_pRefCount(new int(1)),_pMutex(new mutex){}

		~SharedPtr() {
			Release();
		}

		SharedPtr(const SharedPtr<T>& sp) :_ptr(ptr), _pRefCount(new int(1)), _pMutex(new mutex) {
			AddRefCount();
		}

		SharedPtr<T>& operator=(const SharedPtr<T>& sp) {
			if (this != &sp) {
				// 释放管理的旧资源！
				Release();

				// 共享管理新对象的资源.
				_ptr = sp._ptr;
				_pRefCount = sp.__pRefCount;
				_pMutex = sp._pMutex;

				AddRefCount();
			}
			return *this;
		}

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

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

		int UseCount(){ return *_pRefCount; }
		T* Get() { return _ptr; }

		void AddRefCount() {
			_pMutex->lock();
			++(*pRefCount);
			_pMutex->unlock();
		}
	private:
		void Release() {
			bool = deleteflag = false;

			// 引用计数 - 1
			_pMutex->lock();
			if (--(*pRefCount) == 0) {
				delete _ptr;
				delete _pRefCount;
				deleteflag = true;
			}
			_pMutex->unlock();
			if (deleteflag) {
				delete _pMutex;
			}
		}
	private:
		int* _pRefCount; // 引用计数.
		T* _ptr; // 指向管理资源的指针.
		mutex* _pMutex; // 互斥锁
	};

#endif

#if 0
	智能指针（shared_ptr）的线程安全问题：
		1.shared_ptr 对象通过引用计数来实现多个智能指针对象共享，所以引用计数的过程一定要是原子的。
		2.shared_ptr 管理的对象存放在堆上，两个线程中同时去访问，会造线程安全问题！

		智能指针（shared_ptr）的循环引用问题：
#include <iostream> 

	using namespace std;
	struct ListNode {
		int _data;
		shared_ptr<ListNode> _prev;
		shared_ptr<ListNode> _next;
		~ListNode() { cout << " ~ListNode" << endl; }
	};

	int main() {
		shared_ptr<ListNode> node1(new ListNode);
		shared_ptr<ListNode> node2(new ListNode);

		cout << node1.use_count() << endl;
		cout << node2.use_count() << endl;

		node1->_next = node2;
		node2->_prev = node1;
		cout << node1.use_count() << endl;
		cout << node2.use_count() << endl;
		return 0;
	}

	1. node1 和 node2 两个智能指针对象指向两个点，引用计数变成1，我们不需要手动delete
    2. node1 的 _next 指向node2 ,node2 的_prev 指向 node1,引用计数变成2.
	3. node1和node2 析构，引用计数减到1，但是_next 还指向下一个节点._prev还指向上一个节点。
	   也就是说_next析构了node2就释放了。
	   也就是说_prev 析构了 node1 就释放了。
	4. 但是_next 属于node成员变量，node1释放了_next才会析构，而node1由_prev管理，_prev属于node2成员，
	   所以说真就叫循环引用.
	
	注意： 解决循环引用的方案，在引用计数的场景下，将_prev,_next, 改成weak_ptr就行了！
		// 原理上就是，node1->_next = node2; 和 node2 -> _prev = node1 ; 是weak_ptr 的_next 和 _prev 不会增加node1 和node2的引用计数。

#endif 

#if 0
		如果不是new 出来的对象如何通过智能指针管理呢？ 其实shared_ptr 设计了一个删除器来解决问题！
		// 仿函数的删除器
	template <class T>
	struct FreeFunc {
		void operator()(T* ptr) {
			cout << "free : " << ptr << endl;
			free(ptr);
		}
	};

	template <class T>
	struct DeleteArrayFunc {
		void operator()(T* ptr) {
			cout << "free : " << ptr << endl;
			delete[] ptr;
		}
	};

	int main() {
		FreeFunc<int> freeFunc;
		shared_ptr<int> sp1((int*)malloc(4), freeFunc);

		DeleteArrayFunc<int> deleteArrayFunc;
		shared_ptr<int> sp2((int*)malloc(4), deleteArrayRunc);
		return 0;

	}

#endif 

#if 0
	C++11 和 boost中智能指针的关系。
		1. C++ 98 中产生了第一个智能指针 auto_ptr;
	2. C++ boost 给出了更实用的scoped_ptr和 shared_ptr 和 weak_ptr;
	3. C++11 TR1 ,引入了shared_ptr等。不过注意的是TR1并不是标准版的.
	4. C++11 引入了unique_ptr和shared_ptr 和 weak_ptr. 需要注意的是unique_ptr 对应boost的scoped_ptr.
		这些智能指针的实现原理都是参考boost中实现的.
#endif 


#if 0
		RALL 的思除了设计只能指针，还可以用来设计守卫锁，防止异常安全导致死锁问题！

#include <thread>
#include <mutex>
		// C++ 11 库中有一个 lock_guard 下面模仿一下！
	template<class Mutex>
	class LockGuard {
		LockGuard(Mutex& mtx):_mutex(mtx) {
			_mutex.lock();
		}
		~LockGuard() {
			_mutex.unlock();
		}
	private:
		Mutex& _mutex; // 注意这里必须使用引用，否则搜就不是一个互斥量对象。
	};
	mutex mtx;
	static int n = 0;
	void Func() {
		for (size_t i = 0; i < 10000; i++) {
			LockGuard<mutex> lock(mtx);
			++n;
		}
	}

	int main() {
		int begin = clock();

		thread t1(Func);
		thread t2(Func);

		t1.join();
		t2.join();

		int end = clock();

		count << n << endl;
		count << "cost time: " << end - begin << endl;
		return 0;
	}
#endif
未尽余火
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自学考试C++
09-04
自学考试C++,助你考试成功,学习知识,运用知识,应付考试
C++自学笔记.pdf
11-16
C++自学笔记.pdf
C++深度解析 智能指针分析 --- 重载指针特征操作符->和*（36）
Tim的嵌入式之旅
01-01 482
C++深度解析 智能指针分析 --- 重载指针特征操作符-&gt;和*（36）       智能指针解决内存泄漏的问题。 内存泄漏（臭名昭著的Bug） 动态申请堆空间，用完后不归还 C++语言中没有垃圾回收的机制 指针无法控制所指堆空间的生命周期 示例程序： #include &lt;iostream&gt; #include &lt;string&gt; using nam...
scoped_ptr解析
liuzhi1218的专栏
05-01 600
scoped_ptr解析 《超越C++标准库-Boost库导论》 头文件: "boost/scoped_ptr.hpp" boost::scoped_ptr 用于确保动态分配的对象能够被正确地删除。scoped_ptr有着与std::auto_ptr类似的特性，而最大的区别在于它不能转让所有权，然而auto_ptr却可以。事实上，scoped_ptr永远不能被复制或被赋值！scoped_
STL 智能指针
weixin_30843605的博客
12-09 177
转自： https://blog.csdn.net/k346k346/article/details/81478223 STL一共给我们提供了四种智能指针：auto_ptr、unique_ptr、shared_ptr和weak_ptr，auto_ptr是C++98提供的解决方案，C+11已将其摒弃，并提出了unique_ptr作为auto_ptr替代方案。虽然auto_ptr已被摒弃...
自学 C++ day11 C++11特性
m0_51262652的博客
08-05 154
C++11 部分特性
自学C++ day01
m0_51262652的博客
07-05 288
自学C++
自学C++ day06 string & list
m0_51262652的博客
07-18 702
c++
自学C++ day12 thread 库
m0_51262652的博客
08-05 135
C++thread 库
自学C++ day09 引用
m0_51262652的博客
08-05 89
C++ 引用
C++自学课程
05-30
C++面向对象程序设计课程的实践教学质量最 终体现出来的是学生使用 C++进行程序设计的能力。 在作者多年的 C++实践教学经验总结基础上，本文提 出的三点一线式教学方法可以有效提高学生的 C++ 课程的实践操作能力
超适合自学c++基础视频part5
03-15
超适合自学c++基础视频part5
Visual C++自学手册 代码13上
07-10
《Visual C++自学手册 代码13上》是针对初学者和进阶者设计的一本教程，主要聚焦在使用Microsoft的Visual C++开发环境进行编程的学习。这本书的第13部分，可能是对C++编程语言的关键概念和技术进行深入探讨的一部分...
自学C++ day 05 vector
m0_51262652的博客
07-17 279
C++
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 393
STL中的迭代器失效（vector为例）
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 921
内存管理
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 495
c++ error: ‘*’ does not name a type； did you mean ‘**’?
C++自学：数组、指针与数组指针详解
"这篇资料是关于C++自学的，主要探讨了数组的指针和指向数组的指针变量的概念，适合计算机科学与技术专业的本科生学习，旨在帮助学生掌握C/C++语言基础，培养编程技巧和良好编程习惯。课程强调理论与实践结合，包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值