当前位置： 首页 > news >正文

c++进阶之----智能指针

news 来源：原创 2025/5/26 9:05:24

1.概念

在 C++ 中，智能指针是一种特殊的指针类型，它封装了裸指针（raw pointer）的行为，并通过 RAII（Resource Acquisition Is Initialization，资源获取即初始化）机制自动管理动态分配的内存。智能指针的主要目的是简化内存管理，避免内存泄漏、悬空指针等问题。

2.执行机制

RAII在获取资源时把资源委托给一个对象，接着控制对资源的访问，资源在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源，这样保障了资源的正常释放，避免资源泄漏问题。
智能指针类除了满足RAII的设计思路，还要方便资源的访问，所以智能指针类还会想迭代器类一
样，重载 operator*/operator->/operator[] 等运算符，方便访问资源。

3.实现代码

实现过程就是前面类和对象的内容，只不过将其与异常处理杂糅起来了，具体细节见代码注释！

#include <iostream>
#include<functional>
using namespace std;
template <class T>
class SmartPtr
{
public:
	//RAII
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		cout << "delete[] " << _ptr << endl;
		delete[] _ptr;
	}

	// 重载运算符，模拟指针的行为，方便访问资源
	T& operator*()
	{
		return  *_ptr;
	}

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

	T& operator[](size_t i)
	{
		return _ptr[i];
	}
private:
	T* _ptr;
};

double Divide(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		throw "Divide by zero condition!";
	}
	else
	{
		return (double)a / (double)b;
	}
}

void func()
{
	// 这里使用RAII的智能指针类管理new出来的数组以后，程序简单多了
	SmartPtr<int> sp1 = new int[10];
	SmartPtr<int> sp2 = new int[10];

	//SmartPtr<int> sp3(sp1);     //通过sp1构造sp3      
	// 默认的拷贝构造函数和赋值运算符会进行浅拷贝，这会导致多个 SmartPtr 对象指向同一个资源。
	// 当这些对象被销毁时，多个析构函数会尝试释放同一个指针，导致未定义行为（通常是程序崩溃）。
	//所以记得把他注释掉，只是说可能怎么写，但是超级不建议

	for (size_t i = 0; i < 10; i++)
	{
		sp1[i] = sp2[i] = i;
	}

	int len, time;
	cin >> len >> time;
	cout << Divide(len, time) << endl;
}

int main()
{
	try
	{
		func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}
	return 0;
}

对比一下运行结果：

 

这是调试时的界面，抛出的异常会被这个catch捕捉 

4.智能指针的种类

C++ 标准库提供了几种常见的智能指针类型：

4.0 std::auto_ptr

auto_ptr 是C++98时设计出来的智能指针，他的特点是拷贝时把被拷贝对象的资源的管理权转移给
拷贝对象，这是一个非常糟糕的设计，因为他会到被拷贝对象悬空，访问报错的问题，C++11设计
出新的智能指针后，强烈建议不要使⽤auto_ptr。其他C++11出来之前很多公司也是明令禁止使用
这个智能指针的。

4.1 std::unique_ptr

std::unique_ptr 是一种独占所有权的智能指针，表示它所指向的资源只能被一个 unique_ptr 对象拥有。当 unique_ptr 被销毁时，它会自动释放所管理的资源。

  • 特点：

    • 不可复制（copy），但可以移动（move）。

    • 适合单所有权场景。

    • 性能开销极小，几乎和裸指针相当。

4.2 std::shared_ptr

std::shared_ptr 是一种引用计数的智能指针，允许多个 shared_ptr 对象共享对同一资源的所有权。当最后一个 shared_ptr 被销毁时，资源会被自动释放。

  • 特点：

    • 支持复制（copy）。

    • 支持移动（move)

    • 适合共享所有权场景。

    • 性能开销稍高，因为需要维护引用计数(底层实现）。

4.3 std::weak_ptr

std::weak_ptr 是一种弱引用指针，通常与 std::shared_ptr 一起使用。它观察一个资源，但不增加引用计数。weak_ptr 主要用于打破 shared_ptr 的循环引用问题。

  • 特点：

    • 不增加引用计数。

    • 适合观察资源，但不希望影响资源的生命周期。

4.4 代码示例

我们先实现一个日期类

struct Date
{
	int _year;
	int _month;
	int _day;

	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

	~Date()
	{
		cout << "~Date()" << endl;
	}
};

 4.4.1 auto_ptr 

int main()
{
	//创建一个 auto_ptr<Date> 对象 ap1，它管理一个动态分配的 Date 对象
	auto_ptr<Date> ap1(new Date);
	// 拷贝时，管理权限转移，被拷贝对象ap1悬空
	//在 auto_ptr 的拷贝构造中，ap1 的所有权会被转移到 ap2，ap1 会变成一个悬空指针（即它不再管理任何资源）。
	auto_ptr<Date> ap2(ap1);
	//尝试通过 ap1 访问资源，但此时 ap1 已经是一个悬空指针，导致未定义行为（通常是程序崩溃或异常）
	ap1->_year++;
	return 0;
}

运行上述代码，触发报错：

4.4.2 unique_ptr

int main()
{
	unique_ptr<Date> up1 (new Date);
	// 不支持拷贝
	//unique_ptr<Date> up2(up1);
	// 支持移动，但是移动后up1也悬空，所以使用移动要谨慎
	unique_ptr<Date> up3(move(up1));

	return 0;
}

运行代码：触发报错 

4.4.3 shared_ptr

int main()
{
	shared_ptr<Date> sp1(new Date);
	// 支持拷贝
	shared_ptr<Date> sp2(sp1);
	shared_ptr<Date> sp3(sp2);
	//use_count() 返回一个整数值，表示当前资源的引用次数。
	cout << sp1.use_count() << endl;

	sp1->_year++;

	cout << sp1->_year << endl;
	cout << sp2->_year << endl;
	cout << sp3->_year << endl;

	return 0;
}

运行一下：

说明：

在 shared_ptr 的引用计数机制中，析构函数的调用次数与引用计数无关，只与资源是否被释放有关。当引用计数变为0时，资源被释放，析构函数被调用一次。因此，即使引用计数为3，析构函数也只会调用一次。

4.4.4 weak_ptr

这里我们要了解三个函数：

  • expired()：检查资源是否已过期。

  • use_count()：返回共享该资源的 shared_ptr 对象的数量。

  • lock()：获取一个 shared_ptr 对象，如果资源未过期。

int main()
{
	shared_ptr<string>  sp1(new string("11111111"));
	shared_ptr<string> sp2(sp1);// sp2与 sp1 共享同一个资源
	weak_ptr<string> wp = sp1;  //wp指向 sp1 的资源
	cout << wp.expired() << endl;    // 检查 wp 是否过期,输出 0（false），表示资源未过期
	cout << wp.use_count() << endl;  // 输出 2，表示 sp1 和 sp2 共享资源
	

	// sp1和sp2都指向了其他资源，则weak_ptr就过期了
	sp1 = make_shared<string>("222222");
	cout << wp.expired() << endl;// 输出 1（true），表示资源已过期
	cout << wp.use_count() << endl;// 输出 0，表示没有 shared_ptr 共享资源

	sp2 = make_shared<string>("333333");
	cout << wp.expired() << endl;    //同上
    cout << wp.use_count() << endl;

	wp = sp1;
	auto sp3 = wp.lock();  // 使用 wp.lock() 获取一个 shared_ptr 对象
	cout << wp.expired() << endl;   // 输出 0（false），表示资源未过期
	cout << wp.use_count() << endl;   // 输出 2，表示 sp1 和 sp3 共享资源

	*sp3 += "###";
	cout << *sp1 << endl;

	sp1 = sp2;
	return 0;
}

5. 手撕智能指针

由于我们要模拟引用计数，这里我们引入c++11的atomic，具体来说是atomic<int> ，是 C++11 中引入的一个模板类，用于支持原子操作。它确保对整数的操作是线程安全的，可以避免在多线程环境下出现数据竞争问题。 通常用于需要在多线程环境中进行原子操作的场景，比如计数器、标志位等。通过使用 atomic<int>，可以确保对变量的读取和写入操作是原子的，从而避免竞态条件

namespace rens
{
	template<class T>
	class my_shared_ptr
	{
	public:
		//在 C++ 中，explicit 是一个关键字，用于修饰构造函数，表示该构造函数只能通过直接初始化的方式调用，而不能通过隐式转换的方式调用。explicit 的主要目的是防止意外的隐式类型转换，从而提高代码的安全性和可读性。
		explicit my_shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			,_pcount(new std::atomic<int>(1))
		{}

		// 定制删除器，面试时手撕时，不要写删除器部分
		template<class D>
		my_shared_ptr(T* ptr, D del)
			: _ptr(ptr)
			, _pcount(new std::atomic<int>(1))
			, _del(del)
		{}

		//当一个 my_shared_ptr 对象被赋值为另一个对象时，先释放当前资源，
		// 然后复制新对象的资源，并增加引用计数。
		my_shared_ptr(const my_shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(*_pcount);
		}

		void release()
		{
			//如果引用计数为0，则释放资源。
			if (--(*_pcount) == 0)
			{
				//delete _ptr;
				_del(_ptr);// 定制删除器
				delete _pcount;
			}
		}

		// sp1 = sp3
		my_shared_ptr<T>& operator=(const my_shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				release();
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				++(*_pcount);
			}
			return *this;
		}

		~my_shared_ptr()
		{
			release();
		}

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		int use_count() const
		{
			return *_pcount;
		}
		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		atomic<int>* _pcount;
		function<void(T*)> _del = [](T* ptr) {delete ptr; };
	};

	template<class T>
	class my_weak_ptr
	{
	public:
		my_weak_ptr()
		{}

		my_weak_ptr(const my_shared_ptr<T>& sp)
			:_ptr(sp.get)
		{}

		my_weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}

	private:
		T* _ptr = nullptr;
	};
}

int main()
{
	rens::my_shared_ptr<Date> sp1(new Date);
	rens::my_shared_ptr<Date> sp2(sp1);

	rens::my_shared_ptr<Date> sp3(new Date);

	sp1 = sp1;
	sp1 = sp2;
	sp1 = sp3;
	sp2 = sp3;
	return 0;
}

补充：带删除器版本附加

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

class Fclose
{
public:
	void operator()(FILE* ptr)
	{
		cout << "fclose:" << ptr << endl;
		fclose(ptr);
	}
};
int main()
{
	/*std::shared_ptr<Date[]> sp1(new Date[10]);
	std::unique_ptr<Date[]> up1(new Date[10]);*/

	// 定制删除器  函数指针/仿函数/lambda
	rens::my_shared_ptr<Date> sp2(new Date[5], DeleteArray<Date>());
	rens::my_shared_ptr<Date> sp3(new Date[5], DeleteArrayFunc<Date>);

	auto delArrOBJ = [](Date* ptr) {delete[] ptr; };
	rens::my_shared_ptr<Date> sp4(new Date[5], delArrOBJ);
	// 实现其他资源管理的删除器
	rens::my_shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), Fclose());
	rens::my_shared_ptr<FILE> sp6(fopen("Test.cpp", "r"), [](FILE* ptr) {
		cout << "fclose:" << ptr << endl;
		fclose(ptr);
		});

	rens::my_shared_ptr<Date> sp7(new Date);

	//unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);
	//unique_ptr<Date, void(*)(Date*)> up3(new Date[5], DeleteArrayFunc<Date>);
	 decltype对象的类型
	//unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);

	return 0;
}

 6.内存泄漏

6.1 定义

内存泄漏是指程序在申请内存后，无法释放已申请的内存，导致可使用的内存越来越少。随着时间的推移，内存泄漏会导致系统性能下降，甚至可能导致程序崩溃或系统不稳定。

6.2 内存泄漏的危害

6.2.1 系统性能下降：

内存泄漏会导致可用内存逐渐减少，系统需要频繁地进行内存交换（swap），从而增加磁盘I/O操作，降低系统响应速度。随着时间的推移，系统可能会变得越来越慢，最终可能导致系统崩溃。

6.2.2 程序崩溃：

当内存泄漏严重时，系统可能无法为其他程序或进程分配足够的内存，导致程序崩溃或无法启动。在多线程环境中，内存泄漏可能导致线程无法正常运行，从而影响整个程序的稳定性。

6.2.3 资源浪费：

内存泄漏会导致系统资源的浪费，因为已分配的内存无法被其他程序或进程使用。长期的内存泄漏会导致系统资源的严重浪费，影响系统的整体性能。

6.2.4 安全性问题：

在某些情况下，内存泄漏可能导致敏感数据（如密码、密钥等）驻留在内存中，增加数据泄露的风险。内存泄漏可能导致系统不稳定，从而影响系统的安全性。

6.3 内存泄漏的常见原因

  1. 未释放的动态内存：在 C 和 C++ 中，使用 malloc 或 new 分配的内存如果没有对应的 free 或 delete，就会导致内存泄漏。

  2. 循环引用：在使用引用计数的智能指针（如 std::shared_ptr）时，如果两个对象互相引用，可能会导致引用计数无法减到零，从而引发内存泄漏。

  3. 全局变量和静态变量：全局变量和静态变量在程序结束时才会被释放，如果程序运行时间较长，可能会导致内存泄漏。

  4. 异常处理不当：在异常处理中，如果未正确释放资源，可能会导致内存泄漏。

6.4 如何避免内存泄漏

  1. 使用智能指针：在 C++ 中，使用 std::unique_ptr 和 std::shared_ptr 等智能指针可以自动管理内存，避免手动释放内存。

  2. 代码审查：定期进行代码审查，检查是否有未释放的内存。

  3. 使用内存检测工具：使用内存检测工具（如 Valgrind、LeakSanitizer 等）可以帮助发现内存泄漏问题。

  4. 避免循环引用：在使用引用计数的智能指针时，避免循环引用，可以使用 std::weak_ptr 来打破循环引用。

  5. 良好的编程习惯：

    • 确保每个 malloc 或 new 都有对应的 free 或 delete。

    • 在异常处理中，确保资源被正确释放。

到此，我们c++主线课程内容结束！后续可能会更新c++ 副线内容，下一阶段将主要是linux以及算法课博客的更新！

相关文章：

  • 《Vue Router实战教程》2.入门
  • idea在线离线安装插件教程
  • SQL：Constraint（约束）
  • [VTK] 四元素实现旋转平移
  • 2025年危化品安全员考试题库及答案
  • Java基础：浅析Java中的XML文件处理
  • JavaScript 中的 if (object) 语句解释
  • Java基础：集合List、Map、Set(超详细版)
  • 电子处方+在线问诊系统源码：打造智能诊疗闭环“黄金搭档”方案
  • KingbaseES JSON全解析：记录操作与高级表格处理
  • 机器学习 第一章
  • SSM废品买卖回收管理系统的设计与实现
  • Java中的wait( )和sleep( )方法的区别
  • AI大模型技术之RAG、模型微调、知识蒸馏
  • 从零搭建微服务项目Pro（第0章——微服务项目脚手架搭建）
  • 【langchain4j系列教程-05】一文读懂：人工智能如何实现会话记忆
  • 基于EfficientNet的自闭症诊断辅助系统揭秘
  • Maven工具学习使用（十）——生成项目站点
  • Python及C++中的字典
  • 【玩泰山派】5、点灯，驱动led-（2）ubuntu18.04 升级python3.6到python3.7，安装pip3
  • 定制一个网站多少钱/关键词热度分析工具
  • 免费在线建站/市场调研报告怎么写
  • 网站源码下载教程/关键词查询工具软件
  • 广州网站排名优化价格/2022今日最新军事新闻
  • 第一次和别人女友做网站/wordpress建站
  • 开发多语言网站/成都seo优化