C++新特性17_智能指针的原理(智能指针引子；指出什么是智能指针；为使利用类构造析构管理资源释放更像指针，对运算符进行重载，但会因重复析构造成崩溃，提出禁止和拷贝移动方法，均有缺陷；推荐新指针方法)

已于 2024-03-10 11:25:10 修改
阅读量2k 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： # C++新特性37篇 文章标签： c++
于 2021-11-19 10:43:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Dasis/article/details/121415280
本文介绍了C++中智能指针的基本概念和发展历程，从手动资源管理到利用类的构造和析构机制自动管理资源。文章详细探讨了智能指针的设计原则，包括如何通过运算符重载让智能指针像普通指针一样使用，并讨论了浅拷贝带来的问题及解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

C++新特性17_智能指针的原理

1. 什么是智能指针？

  • (1)用起来像指针
  • (2) 会自己对资源进行释放

以下将会对智能指针的原理逐步进行演示。

2. 手动进行资源的释放形式

在没有智能指针之前，我们都是采用手动释放的方法。


#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

//智能指针
//1.用起来像指针
//2.会自己对资源进行释放

class CStudent
{
public:
	CStudent()
	{

	}

	void test()
	{
		cout << "CStudent" << endl;
	}

private:
	char* m_pszBuf;
	int   m_nSex;
};

int main(int argc, char* argv[])
{
	//对象为无参构造
	CStudent* pStu = new CStudent();
	
	//手动进行释放
	if (pStu!=nullptr) 
	{
		delete pStu;
		pStu = nullptr;
	}

	return 0;
}

3. 智能指针雏形：利用类的构造析构实现资源管理

创建一个类，利用该类的构造和析构（进出作用域自动被编译器调用）的机制，来解决资源自动释放的问题。


#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

//智能指针
//1.用起来像指针
//2.会自己对资源进行释放

class CStudent
{
public:
	CStudent()
	{

	}

	void test()
	{
		cout << "CStudent" << endl;
	}

private:
	char* m_pszBuf;
	int   m_nSex;
};
//创建一个类，利用该类的构造和析构（进出作用域自动被编译器调用）的机制
//来解决资源自动释放的问题

//智能指针雏形 用于管理资源
class CSmartPtr 
{
public:
	//一定要是一个堆对象，因为是利用构造析构管理资源
	CSmartPtr(CStudent* pObj) {
		m_pObj = pObj;
	}

	~CSmartPtr() {
		if (m_pObj != nullptr)
		{
			delete m_pObj;
			
		}
	}
private:
	CStudent* m_pObj;//将资源放入智能指针类中，管理起来
};


int main(int argc, char* argv[])
{
	//这里可以完成资源的自动释放，但是用起来不像是一个指针
	CSmartPtr sp(new CStudent());

	return 0;
}

4. 需要想办法让对象用起来像是一个指针

前面，我们学会了如何使用引用计数及写时拷贝，这是理解智能指针必不可少的方法。但是，在实际写代码中，我们其实更倾向于让程序员对于资源的管理没有任何的感知，也就是说，最好让程序员只需要考虑资源的何时申请，对于何时释放以及资源内部如何计数等问题，统统交给编译器内部自己处理。

4.1 “->”,"*"取内容，"bool"的运算符重载

智能指针另外一点就是在使用上要像真正的指针一样可以支持取内容, 指针访问成员->等操作，因此，就需要对这些运算符进行重载。


#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

//智能指针
//1.用起来像指针
//2.会自己对资源进行释放

class CStudent
{
public:
	CStudent()
	{

	}

	void test()
	{
		cout << "CStudent" << endl;
	}

private:
	char* m_pszBuf;
	int   m_nSex;
};
//创建一个类，利用该类的构造和析构（进出作用域自动被编译器调用）的机制
//来解决资源自动释放的问题

//智能指针雏形 用于管理资源
class CSmartPtr 
{
public:
	//一定要是一个堆对象，因为是利用构造析构管理资源
	CSmartPtr(CStudent* pObj) {
		m_pObj = pObj;
	}

	~CSmartPtr() {
		if (m_pObj != nullptr)
		{
			delete m_pObj;
			
		}
	}

	//需要想办法让对象用起来像是一个指针

	//为了使sp像一个指针的写法
	//将->进行运算符重载，返回内部的类的指针，指针类型为CStudent
	//这样的话sp可以利用返回的指针指向CStudent对象，并指向其内部成员函数，写法：
	//CSmartPtr sp(new CStudent()); sp->test();
	CStudent* operator->() {
		return m_pObj;
	}

	//重载*，返回一个CStudent的引用，使得(*sp).test();取内容成立
	CStudent& operator*() {
		return *m_pObj;
	}

	//重载bool类型,	if (sp) {}
	operator bool() {
		return m_pObj != nullptr;
	}
	//&取地址也是可以的

private:
	CStudent* m_pObj;//将资源放入智能指针类中，管理起来
};


int main(int argc, char* argv[])
{
	//默认浅拷贝，堆空间会重复析构，程序会崩溃掉
	CSmartPtr sp(new CStudent());
    CSmartPtr sp2=sp;

	return 0;
}

但是上述在碰到指针赋值等操作时默认浅拷贝，堆空间会重复析构，程序会崩溃掉，这个怎么解决呢？以下是解决问题的两种思路

4.1.1 不允许=号运算符重载和拷贝构造（不太建议，简单粗暴）


#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

//智能指针
//1.用起来像指针
//2.会自己对资源进行释放

class CStudent
{
public:
	CStudent()
	{

	}

	void test()
	{
		cout << "CStudent" << endl;
	}

private:
	char* m_pszBuf;
	int   m_nSex;
};
//创建一个类，利用该类的构造和析构（进出作用域自动被编译器调用）的机制
//来解决资源自动释放的问题

//智能指针雏形 用于管理资源
class CSmartPtr 
{
public:
	//一定要是一个堆对象，因为是利用构造析构管理资源
	CSmartPtr(CStudent* pObj) {
		m_pObj = pObj;
	}

	~CSmartPtr() {
		if (m_pObj != nullptr)
		{
			delete m_pObj;
			
		}
	}
    
    //禁止=号运算符重载
	CSmartPtr& operator=(CSmartPtr&) = delete;
    //禁止拷贝
	CSmartPtr(CSmartPtr&) = delete;

	//需要想办法让对象用起来像是一个指针

	//为了使sp像一个指针的写法
	//将->进行运算符重载，返回内部的类的指针，指针类型为CStudent
	//这样的话sp可以利用返回的指针指向CStudent对象，并指向其内部成员函数，写法：
	//CSmartPtr sp(new CStudent()); sp->test();
	CStudent* operator->() {
		return m_pObj;
	}

	//重载*，返回一个CStudent的引用，使得(*sp).test();成立
	CStudent& operator*() {
		return *m_pObj;
	}

	//重载bool类型,	if (sp) {}
	operator bool() {
		return m_pObj != nullptr;
	}
	//&取地址也是可以的

private:
	CStudent* m_pObj;//将资源放入智能指针类中，管理起来
};


int main(int argc, char* argv[])
{
	//放入块作用域进行调试
	{
		//这里可以完成资源的自动释放，是将对象放入对象中
		CSmartPtr sp(new CStudent());
		CSmartPtr sp3(new CStudent());
		
		//=号的运算符重载，会造成崩溃，防止崩溃
		//防崩溃写法：CSmartPtr& operator=(CSmartPtr&) = delete;
		//sp3 = sp;		

		//指针是可以进行赋值的，但是此处运行后会崩溃
		//防崩溃写法：CSmartPtr(CSmartPtr&) = delete;
		//CSmartPtr sp2 = sp;//拷贝构造，默认为浅拷贝
	}

	//解决上面拷贝构造引起的崩溃，方法：
	//1.不允许=号运算符重载，拷贝构造（不太建议）
	//2.使用拷贝移动的语法（防止资源多次释放）


	return 0;
}

正常情况下，不允许=号运算符重载和拷贝构造这是不合理的。
可以使用拷贝移动的写法

4.1.2 使用拷贝移动的语法（防止资源多次释放,但是可能造成原来的对象丢失，移动构造中被删除了）

将对象1的指针赋给对象2，但是对象1的就会丢失 auto_ptr 98中的，缺陷明显


#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

//智能指针
//1.用起来像指针
//2.会自己对资源进行释放

class CStudent
{
public:
	CStudent()
	{

	}

	void test()
	{
		cout << "CStudent" << endl;
	}

private:
	char* m_pszBuf;
	int   m_nSex;
};
//创建一个类，利用该类的构造和析构（进出作用域自动被编译器调用）的机制
//来解决资源自动释放的问题

//智能指针雏形 用于管理资源
class CSmartPtr 
{
public:
	//一定要是一个堆对象，因为是利用构造析构管理资源
	CSmartPtr(CStudent* pObj) {
		m_pObj = pObj;
	}

	~CSmartPtr() {
		if (m_pObj != nullptr)
		{
			delete m_pObj;
			
		}
	}
	
	//禁止=号运算符重载
	//CSmartPtr& operator=(CSmartPtr&) = delete;

	//使用拷贝移动的语法（防止资源多次释放）
	CSmartPtr& operator=(CSmartPtr& sp) {
	//m_pObj不为空就删除内容
		if (m_pObj!=nullptr)
		{
			delete m_pObj;
		}
		m_pObj = sp.m_pObj;//赋值
		sp.m_pObj = nullptr;//原有的就不需要了

		return *this;
	}

	//禁止拷贝构造
	CSmartPtr(CSmartPtr&) = delete;

	//需要想办法让对象用起来像是一个指针

	//为了使sp像一个指针的写法
	//将->进行运算符重载，返回内部的类的指针，指针类型为CStudent
	//这样的话sp可以利用返回的指针指向CStudent对象，并指向其内部成员函数，写法：
	//CSmartPtr sp(new CStudent()); sp->test();
	CStudent* operator->() {
		return m_pObj;
	}

	//重载*，返回一个CStudent的引用，使得(*sp).test();成立
	CStudent& operator*() {
		return *m_pObj;
	}

	//重载bool类型,	if (sp) {}
	operator bool() {
		return m_pObj != nullptr;
	}
	//&取地址也是可以的

private:
	CStudent* m_pObj;//将资源放入智能指针类中，管理起来
};


int main(int argc, char* argv[])
{
	//放入块作用域进行调试
	{
		//这里可以完成资源的自动释放，是将对象放入对象中
		CSmartPtr sp(new CStudent());
		CSmartPtr sp3(new CStudent());
		
		//=号的运算符重载，会造成崩溃，防止崩溃
		//防崩溃写法：CSmartPtr& operator=(CSmartPtr&) = delete;		
		sp3 = sp;

		//指针是可以进行赋值的，但是此处运行后会崩溃
		//防崩溃写法：CSmartPtr(CSmartPtr&) = delete;		
		//CSmartPtr sp2 = sp;//拷贝构造，默认为浅拷贝
	}

	//解决上面重复析构引起的崩溃，方法：
	//1.不允许=号运算符重载，拷贝构造（不太建议）
	//2.使用拷贝移动的语法（防止资源多次释放,但是可能造成原来的sp丢失，移动构造中被删除了）
	//将对象1的指针赋给对象2，但是对象1的就会丢失 auto_ptr 98中的，缺陷明显
	//3.结合前面的引用计数及写时拷贝

	return 0;
}

4.1.3 推荐的解法：结合前面两篇的引用计数及写时拷贝，新的智能指针的写法

且听下篇分解！

5. 智能指针的简要形式代码分析

以下是对智能指针内部实现原理进行简要分析及实现，涉及了指针运算符重载及编译器的优化。(来自C++全)

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{
public:
	Person(int age)
	{	
		cout << "Person的有参构造调用" << endl;
		this->m_Age = age;
	}

	void showAge()
	{
		cout << "年龄为： "<< this->m_Age << endl;
	}

	~Person()
	{
		cout << "Person的析构调用" << endl;
	}

	int m_Age;
};

class SmartPoint
{
public:
	SmartPoint(Person * person)
	{
		this->m_person = person;
	}

	//重载->运算符，使得sp->showAge()在编译器优化之后直接就可以调用Person的方法
	Person * operator->()
	{
		return this->m_person;
	}
	//重载 * 运算符
	Person& operator*()
	{
		return *m_person;
	}
	~SmartPoint()
	{
		if (this->m_person)
		{
			delete this->m_person;
			this->m_person = NULL;
		}
	}
private:
	Person * m_person;
};

void test01()
{
	//Person * p = new Person(18);
	//(*p).showAge();
	//p->showAge();
	//delete p;


	//利用智能指针(对象是在栈上，出作用域自动析构) 管理 new出来的person的释放操作
	SmartPoint sp(new Person(18));

	sp->showAge(); // 本质sp->->showAge(); 编译器简化为 sp->showAge();

	(*sp).showAge();

}


int main(){
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

5.学习视频地址：智能指针的原理
6. 学习笔记：智能指针的原理笔记

17 C++ 高级之智能指针
a136447572的专栏
08-02 543
Android Ndk 学习笔记（目录） #include <iostream> #include <memory> // 智能指针的头文件引入 using namespace std; class Person{ public: ~Person(){ cout << "Person 析构函数" <<endl ; } }; // 智能指针 void usePerson(){ Person * person1
【C/C++】由指针强制转换看结构体和类的内存布局
C++，存储，模糊测试，Linux
09-12 3034
【C/C++】由指针强制转换看结构体和类的内存布局 引子 最近在使用Linux C进行网络编程，发现用户都是对 struct sockaddr_in 这个结构体进行操作，但是调用库函数时都是强制转换为 struct sockaddr 作为参数。 一、sockaddr sockaddr在头文件#include <sys/socket.h>中定义，sockaddr的缺陷是：sa_data把目标地址和端口信息混在一起了，如下： struct sockaddr { sa_family_t
c++基础：17.智能指针
m0_49024067的博客
07-12 285
不控制所指对象的生存期，指向由一个shared_ptr所管理的对象，将weak_ptr绑定到一个shared_ptr不会改变shared_ptr引用计数，当最后一个指向对象的shared_ptr被销毁，对象会被释放。共享智能指针，多个shared_ptr可以指向同一个对象。当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr类会通过析构函数自动销毁此对象。某个时刻只能有一个unique_ptr指向一个给定对象，当unique_ptr被销毁时，它所指对象也被销毁。
C++17新特性 智能指针
最新发布
laziji的专栏
05-31 145
摘要： RAII（资源获取即初始化）和引用计数是两种重要的内存管理技术。RAII通过构造函数分配资源、析构函数释放资源的方式确保资源安全；引用计数则通过跟踪对象引用数来自动管理内存。C++11引入智能指针（shared_ptr/unique_ptr/weak_ptr）实现引用计数，解决了传统C++手动管理内存的问题。与垃圾回收不同，引用计数能及时回收资源且不影响性能，明确控制资源生命周期。（150字）
C++（17）——智能指针初步及弃用auto_ptr的原因
qq_44824574的博客
03-09 3230
RAII 使用局部对象来管理资源的技术 RAII的原理 RAII的四个步骤 裸指针存在的问题： delete后的指针变量就变成了一个失效指针（也叫作悬空指针）。 对于下面的代码： void Destroy(Object *op) { delete op; delete[] op; } Object *op = new Object(10); Object *arop = new Object[10]; Destroy(op); Destroy(arop); 因此： 智能指针 智能指针的引入
《C++》-智能指针
WeiMengXS的博客
07-31 253
一、 为什么需要智能指针? malloc出来的空间，没有进行释放，存在内存泄漏的问题。 异常安全问题。如果在malloc和free之间如果存在抛异常，那么还是有内存泄漏。这种问题就叫异常安 全。 二、内存泄漏 2.1 什么是内存泄漏，内存泄漏的危害 什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不 是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而 造成了内存的浪费。 内存泄漏的危害:长期运行的程序出现内存泄漏，影
【C++】《C++ 17 入门经典》读书笔记 11 ---- 智能指针：unique_ptr、shared_ptr、weak_ptr
风语留痕
06-29 590
介绍 C++17 中的智能指针：unique_ptr、shared_ptr、weak_ptr。
C++智能指针详解：自动内存管理的正确打开方式
本文首先概述了智能指针的基本概念及其工作原理，包括内存管理的基础知识、智能指针的类型和特点以及内存管理机制。接着，文章深入探讨了智能指针在实践中的使用，包括不同智能指针的深入使用技巧、高级技巧和应用...
C++中的四种类型转换
12-26
1 引子 这篇笔记是根据StackOverflow上面的一个问题整理而成，主要内容是对C/C++当中四种类型转换操作进行举例说明。在之前其实对它们都是有所了解的，而随着自己在进行总结，并敲了一些测试示例代码进行验证之后，...
大一数据结构_源代码，就当作一个引子好了，按照对应的内容和关键词在网上找更多的相关项目和代码_-.zip
09-09
这些技能有助于学生在未来的工作中更快地适应新的编程语言和开发环境，提升自身的竞争力。 数据结构的学习不仅仅是为了掌握特定的数据组织方式和算法，更重要的是培养解决问题的能力和逻辑思维。通过源代码的编写和...
C语言-二级指针应用场景
gopher9511的博客
06-26 1574
使用二级指针的主要目的是为了安全地管理和修改指针，避免悬挂指针问题。在函数内部，能够直接修改调用者的指针，使其指向 NULL，从而提升代码的健壮性。
C++(17)——泛型算法绑定器和智能指针
青布衫白少年的博客
08-14 497
泛型算法 将用代码和注释进行讲解 /* 泛型算法 特点一、泛型算法的参数接受的都是迭代器 特点二、泛型算法还可以接受函数对象 绑定器 + 二元函数对象 =》一元函数对象 bind1st：把二元函数对象的operator的第一个形参绑定起来 bind2nd：把二元函数对象的operator的第二个形参绑定起来 取反器 not1 一元函数取反 not2 二元函数取反 */ int main() { int arr[] = { 12,644,9,11,16,116,49,79,64 }; vector&l
【C++】智能指针
m0_62714628的博客
04-20 862
【C++】智能指针
c++智能指针
笔记
05-07 210
转载地址：c++智能指针 - 知乎 C++关键字之static C++关键字之explicit C++关键字之auto、decltype c++智能指针 new[]为什么不能用delete去释放 使用VS查看内存模型 简单对象的内存模型 单继承关系的对象模型 多继承下的内存模型 虚继承 ...... 敬请关注，未完待续~ 概念 智能指针不是一个指针，它其实是一个对象。它是通过C++的RAII机制实现的。主要是利用C++中对象在释放的时候，会自动调用析构函数这一特性。 所以，当智.
C++ 智能指针详解
Tyler_Zx的博客
09-03 2431
简介 智能指针仅用于存储在堆中分配的内存的对象，智能指针做的工作比原始指针多得多。智能指针最重要的是特性是不必使用delete 和 delete[] 运算符释放内存，只要不再需要智能指针，它们就会自动释放。这样就可以避免多次释放、分配/释放不匹配、指针悬挂和内存泄露的可能性。 智能指针特别适合用于管理动态创建的类对象，但智能指针不能完成原始指针的所有操作，智能指针不能递增或递减，也不能执行其他算术操作。智能指针由标准库memory 头文件中的模版定义，所以必须在源文件中包含这个头文件，才能使用智能指..
C++智能指针
aaron19890330的专栏
10-17 404
原文链接https://www.bogotobogo.com/cplusplus/boost.php 智能指针是一个对大多数意图和目的像指针一样起作用的对象，但它避免了C++指针固有的大多数问题。最简单来说，智能指针包含作为数据成员的原始指针，并提供一组重载操作符，这些操作符使它在大多数情况下都像指针一样工作。指针可以被撤销，因此，*和-&gt;运算符重载以返回预期的地址。  指针可以进行指针算...
2024年C C++最全C++(17)——泛型算法绑定器和智能指针_c+，2024年最新C C++开发手册
2401_84975923的博客
05-12 285
(img-3ynGO8hN-1715522931984)]//带标志位的智能指针:新的智能指针指向后获得释放权，旧指针失去释放权。class Auto_ptr//赋值或者拷贝构造后先定义的对象会出错。
释放智能指针 make_shared_看完这篇，别再说不会智能指针了
weixin_39861905的博客
11-25 6131
C++智能指针一、智能指针的作用上一篇介绍了内存池的原理和实现，详情请见内存池设计与实现；内存池可以帮助我们有效的对内存进行管理，智能指针可以很方便的管理指针，避免出现内存泄漏；智能指针的作用智能指针的作用：智能指针可以帮助我们避免在申请空间后忘记释放造成内存泄漏的问题；因为智能指针本身是一个类（后面也会自己实现一下），当出了类的作用域的时候，类会调用析构函数进行释放资源。所以智能指针的作用原理就...
（17）C++ 指针
illlllllli的博客
07-29 259
C++ 指针什么是指针？指针的本质是变量指针包括两部分C++ 中使用指针C++ 指针详解应用有关字符数组及写法值传递，指针传递，引用传递函数指针C++ 中指针分配与释放一个空间 学习 C++ 的指针既简单又有趣。通过指针，可以简化一些 C++ 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。所以，想要成为一名优秀的 C++ 程序员，学习指针是很有必要的。 正如所知道的，每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

十月旧城

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

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

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

打赏作者

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

抵扣说明：

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

余额充值