shellmad-17_C++新特性 智能指针的原理

最新推荐文章于 2024-05-12 22:09:14 发布
最新推荐文章于 2024-05-12 22:09:14 发布
阅读量217 收藏
点赞数 1
分类专栏： shellmad C++新特性
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/esjiang/article/details/114647417
版权

简单的介绍到底什么是智能指针
智能指针:

  1. 用起来像指针(注意, 这里用了“像”)
  2. 会自己对资源进行释放

自己对资源进行释放

先来写一个简单的例子

class CStudent
{
public:
  CStudent()
  {
  
  }

  void test()
  {
    cout << "CStudent" << endl;
  }
  
private:
  char* m_pszBuf;
  int   m_nSex;
};

所谓的智能指针是要解决什么问题呢
显然, 这个对象需要我们手动去释放

int main(){
	CStudent *pStu = new Student();

	if (pStu != nullptr){
		delete pStu;
		pStu = nullptr;
	}
}

我们想对象创建的时候, 自己去决定什么时候释放, 程序员不用去考虑
所以, 为了达到这个目的,
我们可以创建一个类, 利用该类的构造和析构(进出作用域自动被编译器调用)的机制
来解决资源自动释放的问题
这个类有构造和析构, 不用手动去调用, 编译器会自动调用
随便写一个

class CSmartPtr{
public:
	
private:
	CStudent* m_pObj; // 将资源放入智能指针类中, 管理起来
}

然后智能指针需要有构造函数, 析构函数
应该这样写
注意CSmartptr()传入的参数一定要是一个堆对象

因为我们要利用析构去释放它. 构造的时候进行赋值, 析构的时候进行释放
利用这样一个简单的功能, 去完成智能指针的简单功能

	// 一定要是一个堆对象, 因为我们要利用析构去释放它. 构造的时候进行赋值, 析构的时候进行释放
	CSmartPtr(CStudent* pObj){
		m_pObj = pObj;
	}
	~CSmartPtr(){
		if (m_pObj != nullptr){
			delete m_pObj;
		}
	}

main函数里这样用智能指针, 直接将new放到sp的构造函数里CSmartPtr sp(new CStudent());

#include <iostream>
using namespace std;

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(){
	CSmartPtr sp(new CStudent());

	// CStudent *pStu = new Student();

	// if (pStu != nullptr){
	// 	delete pStu;
	// 	pStu = nullptr;
	// }
}

代码运行:
sp对象对象里包含CStudent指针
什么时候sp里的指针会释放呢, 跟智能指针对象一样,智能指针释放, sp所带的堆对象会释放

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

在这里插入图片描述

完成了前面的第2个功能 ** 2. 会自己对资源进行释放**

看起来像指针的功能实现

虽然这里可以完成资源的自动释放CSmartPtr sp(new CStudent());
但是还有一个问题 用起来不像一个指针, 因为它是一个对象, 不能写sp->, 因为指针对象有->操作符
而且用起来不像原来的对象, 而只是把对象放到了sp这里来, 用起来也不是CStudent对象, 所以用起来感觉也不对

->运算符

所以我们需要怎么做呢
需要想办法让其对象用起来像是一个指针
为了用起来像一个指针, 而且模仿的效果一致
需要写运算符重载->, 像一个指针的写法
按道理应该这样写sp.m_pObj->test, 因为要使得m_pObj对象相当于是CStudent对象, 相当于是这么写sp->test(), 因为你不能让用户感知到智能指针内部的东西(m_pObj), 按道理, CStudent的指针相当于是sp了
相当于-> 返回了内部的指针(m_pObj)
但是如果CStudent* operator->返回值是CStudent* 那么sp->返回CStudent* 那又要写一个->才能找到CStudent*的test函数, 即这样写了sp->->test(), 但是C++里没有->->语法, 会编译器处理, 自动缩减成->

	CStudent* operator->(){
		return m_pObj;
	}

总代码

#include <iostream>
using namespace std;

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;
		}
	}
	CStudent* operator->(){
		return m_pObj;
	}
private:
	CStudent* m_pObj; // 将资源放入智能指针类中, 管理起来
};

int main(){
	CSmartPtr sp(new CStudent());
	sp->test();
	// CStudent *pStu = new Student();

	// if (pStu != nullptr){
	// 	delete pStu;
	// 	pStu = nullptr;
	// }
}

在这里插入图片描述

*运算符

到这里, sp就类似于student形式的指针, 但是, 这显然还不够
指针还可以解引用, (*sp)
在这里插入图片描述
重载* (注意: 解引用后, 返回的是解引用对象的引用)

	CStudent& operator*(){
		return *m_pObj;
	}

总代码:

#include <iostream>
using namespace std;

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;
		}
	}
	CStudent* operator->(){
		return m_pObj;
	}
	CStudent& operator*(){
		return *m_pObj;
	}
private:
	CStudent* m_pObj; // 将资源放入智能指针类中, 管理起来
};

int main(){
	CSmartPtr sp(new CStudent());
	sp->test();
	(*sp).test();
	// CStudent *pStu = new Student();

	// if (pStu != nullptr){
	// 	delete pStu;
	// 	pStu = nullptr;
	// }
}

在这里插入图片描述

支持bool判断

当然还有哦, 还有指针可以当bool来用 if (sp), sp是否为空, 空的就是false

	operator bool(){
		return m_pObj != nullptr;
	}

编译通过
在这里插入图片描述

总代码:

#include <iostream>
using namespace std;

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;
		}
	}
	CStudent* operator->(){
		return m_pObj;
	}
	CStudent& operator*(){
		return *m_pObj;
	}
	operator bool(){
		return m_pObj != nullptr;
	}
private:
	CStudent* m_pObj; // 将资源放入智能指针类中, 管理起来
};

int main(){
	CSmartPtr sp(new CStudent());
	// sp->test();
	(*sp).test();
	if (sp){
		
	}
	// CStudent *pStu = new Student();

	// if (pStu != nullptr){
	// 	delete pStu;
	// 	pStu = nullptr;
	// }
}

还有还有, 指针, 可以取地址&, 就不再展开, 所以慢慢慢慢的就开始向一个指针了

崩溃

到了这里, 对象就完美了吗? 远远不够
还有一个问题, 出现以下的写法会怎么样
CSmartptr sp2 = sp;
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

崩溃代码:

#include <iostream>
using namespace std;

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;
		}
	}
	CStudent* operator->(){
		return m_pObj;
	}
	CStudent& operator*(){
		return *m_pObj;
	}
	operator bool(){
		return m_pObj != nullptr;
	}
private:
	CStudent* m_pObj; // 将资源放入智能指针类中, 管理起来
};

int main(){
	CSmartPtr sp(new CStudent());
	CSmartPtr sp2 = sp;
	// sp->test();
	// (*sp).test();
	// if (sp){

	// }
	// CStudent *pStu = new Student();

	// if (pStu != nullptr){
	// 	delete pStu;
	// 	pStu = nullptr;
	// }
}

分析崩溃原因:

CSmartptr sp2 = sp; 用的是拷贝构造, 而拷贝构造默认用的是浅拷贝, 会把指针赋值称为同一个值, 两个指针在析构的时候,都会释放同一个堆空间, 堆空间被重复释放了2次, 就会出问题
还有赋值构造也会导致奔溃

解决思路1(暴力删除delete)

  1. 不允许拷贝构造, 直接让CSmartptr sp2 = sp; 编译不通过.
	CSmartPtr(CSmartPtr&) = delete;
  1. 不允许赋值构造函数, 让CSmartPtr sp3(new CStudent()); sp3 = sp; 编译不通过
	CSmartPtr& operator = (CSmartPtr&) = delete;

下图(拷贝构造函数失效)
在这里插入图片描述
下图(赋值构造函数)失效
在这里插入图片描述

总代码(拷贝/赋值构造函数delete)

#include <iostream>
using namespace std;

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; // 赋值构造函数delete
	CSmartPtr(CSmartPtr&) = delete; // 拷贝构造函数delele
	CStudent* operator->(){
		return m_pObj;
	}
	CStudent& operator*(){
		return *m_pObj;
	}
	operator bool(){
		return m_pObj != nullptr;
	}
private:
	CStudent* m_pObj; // 将资源放入智能指针类中, 管理起来
};

int main(){
	CSmartPtr sp(new CStudent());
	CSmartPtr sp3(new CStudent());
	sp3 = sp;
	// sp->test();
	// (*sp).test();
	// if (sp){

	// }
	// CStudent *pStu = new Student();

	// if (pStu != nullptr){
	// 	delete pStu;
	// 	pStu = nullptr;
	// }
}

但是这样写太粗暴了, 有一个指针, 凭什么不让我拷贝, 凭什么不让我赋值, 没道理

解决思路2:使用拷贝移动(auto_ptr 98的原型)

什么叫拷贝移动

	CSmartPtr& operator= (CSmartPtr& sp) {
		if (m_pObj != nullptr){
			delete m_pObj;
		}
		m_pObj = sp.m_pObj;
		sp.m_pObj = nullptr;

		return *this;
	}

总代码

#include <iostream>
using namespace std;

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& sp) {
		if (m_pObj != nullptr){
			delete m_pObj;
		}
		m_pObj = sp.m_pObj;
		sp.m_pObj = nullptr;

		return *this;
	}

	CSmartPtr(CSmartPtr&) = delete;
	CStudent* operator->(){
		return m_pObj;
	}
	CStudent& operator*(){
		return *m_pObj;
	}
	operator bool(){
		return m_pObj != nullptr;
	}
private:
	CStudent* m_pObj; // 将资源放入智能指针类中, 管理起来
};

int main(){
	CSmartPtr sp(new CStudent());
	CSmartPtr sp3(new CStudent());
	sp3 = sp;
	// sp->test();
	// (*sp).test();
	// if (sp){

	// }
	// CStudent *pStu = new Student();

	// if (pStu != nullptr){
	// 	delete pStu;
	// 	pStu = nullptr;
	// }
}

在这里插入图片描述
不会再出现崩溃问题, 这样做是可以的, 但是要时时刻刻注意, 赋值完后, 谁没有了, 相当于上述代码, 赋值完后sp对象就没了
在这里插入图片描述
注意: 如果sp是空指针, 且类里函数没有调用赋值操作等, 只是输出操作, 仍然可以调用该函数

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

代码:(核心: sp->test())

#include <iostream>
using namespace std;

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& sp) {
		if (m_pObj != nullptr){
			delete m_pObj;
		}
		m_pObj = sp.m_pObj;
		sp.m_pObj = nullptr;

		return *this;
	}

	CSmartPtr(CSmartPtr&) = delete;
	CStudent* operator->(){
		return m_pObj;
	}
	CStudent& operator*(){
		return *m_pObj;
	}
	operator bool(){
		return m_pObj != nullptr;
	}
private:
	CStudent* m_pObj; // 将资源放入智能指针类中, 管理起来
};

int main(){
	CSmartPtr sp(new CStudent());
	CSmartPtr sp3(new CStudent());
	sp3 = sp;

	sp->test();
	// sp->test();
	// (*sp).test();
	// if (sp){

	// }
	// CStudent *pStu = new Student();

	// if (pStu != nullptr){
	// 	delete pStu;
	// 	pStu = nullptr;
	// }
}

成功运行:
在这里插入图片描述
但是对test函数修改

class CStudent
{
public:
...

  void test()
  {
    cout << "CStudent" << endl;
    m_nSex = 1;
  }
  
...
};

总代码:

#include <iostream>
using namespace std;

class CStudent
{
public:
  CStudent()
  {
  
  }

  void test()
  {
    cout << "CStudent" << endl;
    m_nSex = 1;
  }
  
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& sp) {
		if (m_pObj != nullptr){
			delete m_pObj;
		}
		m_pObj = sp.m_pObj;
		sp.m_pObj = nullptr;

		return *this;
	}

	CSmartPtr(CSmartPtr&) = delete;
	CStudent* operator->(){
		return m_pObj;
	}
	CStudent& operator*(){
		return *m_pObj;
	}
	operator bool(){
		return m_pObj != nullptr;
	}
private:
	CStudent* m_pObj; // 将资源放入智能指针类中, 管理起来
};

int main(){
	CSmartPtr sp(new CStudent());
	CSmartPtr sp3(new CStudent());
	sp3 = sp;

	sp->test();
	// sp->test();
	// (*sp).test();
	// if (sp){

	// }
	// CStudent *pStu = new Student();

	// if (pStu != nullptr){
	// 	delete pStu;
	// 	pStu = nullptr;
	// }
}

就会Segment Fault

在这里插入图片描述
所以第2种解决方法, 要时刻注意后面的对象被释放了, 不能再使用了, 这样又加重了程序员的烦恼, 程序员又要记住左边的能用, 右边的不能用
但是这样写是auto ptr的原型

解决思路3: 结合引用技术, 写时拷贝

结合前面的引用技术 以及写时拷贝, 结合后

int main(){
	CSmartPtr sp(new CStudent());
	CSmartPtr sp3(new CStudent());
	sp3 = sp;
	...
}

表示sp和sp3, 在sp, sp3不修改的情况下, 二者指的都是同一个指针, 就不存在后面的使用的问题了
新的智能指针写法

打雷要下雨，雷欧
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 智能指针
CR7lmz的博客
11-17 348
智能指针 智能指针的使用以及原理： 智能指针的思想：RAll RAll是一种利用对象声明周期来控制程序资源的一种技术。它可以在对象构造时获取资源，在对象析构时候释放资源，完全不用用户自己释放，当然也解决了用原生态指针的缺陷。 RAll思想的好处： 1.不用自己显示释放申请的资源，用户不用考虑什么术后该释放资源，将这些交给编译器即可。 2.用这种方法，对象所需的资源在其生命周期内始终保持有效。 下面...
17 C++ 高级之智能指针
a136447572的专栏
08-02 470
Android Ndk 学习笔记（目录） #include <iostream> #include <memory> // 智能指针的头文件引入 using namespace std; class Person{ public: ~Person(){ cout << "Person 析构函数" <<endl ; } }; // 智能指针 void usePerson(){ Person * person1
2024年C C++最全C++(17)——泛型算法绑定器和智能指针_c+，2024年最新C C++开发手册
最新发布
2401_84975923的博客
05-12 231
(img-3ynGO8hN-1715522931984)]//带标志位的智能指针:新的智能指针指向后获得释放权，旧指针失去释放权。class Auto_ptr//赋值或者拷贝构造后先定义的对象会出错。
【C++】《C++ 17 入门经典》读书笔记 11 ---- 智能指针：unique_ptr、shared_ptr、weak_ptr
风语留痕
06-29 519
介绍 C++17 中的智能指针：unique_ptr、shared_ptr、weak_ptr。
C++智能指针
冷月
08-17 223
智能指针是用模板实现，创建对象后，对象管理了资源，然后通过析构函数释放掉该资源，以防内存泄漏。auto_ptr（空间管理权限的转移，永远只有一个指针指向动态开辟的空间）#include <iostream> using namespace std;template<class T> class AutoPtr { public: AutoPtr(T* p = NULL) :_
C++(17)——泛型算法绑定器和智能指针
青布衫白少年的博客
08-14 427
泛型算法 将用代码和注释进行讲解 /* 泛型算法 特点一、泛型算法的参数接受的都是迭代器 特点二、泛型算法还可以接受函数对象 绑定器 + 二元函数对象 =》一元函数对象 bind1st：把二元函数对象的operator的第一个形参绑定起来 bind2nd：把二元函数对象的operator的第二个形参绑定起来 取反器 not1 一元函数取反 not2 二元函数取反 */ int main() { int arr[] = { 12,644,9,11,16,116,49,79,64 }; vector&l
cpp-pro_c++book_
10-01
6. **内存管理**：包括指针操作、动态内存分配与释放，以及智能指针的使用，这些都是C++程序员必须掌握的重要技能。 7. **C++11及更高版本的新特性**：自C++11标准发布以来，C++经历了多次更新，引入了lambda表达式...
STM32L-Discovery.zip_C++_STM32L-DISCOVERY _native9ev
09-21
在这个过程中，会涉及到STM32L系列微控制器的特点、C++在嵌入式系统中的应用以及STM32L-DISCOVERY开发板的工作原理。 STM32L系列是意法半导体（STMicroelectronics）推出的一款超低功耗的32位微控制器，基于ARM ...
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
C++11引入了智能指针作为现代C++编程的重要特性，极大地改善了内存管理的复杂性。智能指针是具有自动内存管理功能的对象，它们在适当的时候自动释放所指向的对象，防止内存泄漏。本文主要讨论了三种智能指针：`...
C++11新特性之智能指针
12-22
这是C++11新特性介绍的第五部分，涉及到智能指针的相关内容（shared_ptr， unique_ptr， weak_ptr)。 　不想看toy code的读者可以直接拉到文章后看这部分的总结。 　shared_ptr 　shared_ptr 基本用法 　shared_...
eclipse-jee-mars-R-win32-x86_64位官方绿色版.zip
06-30
1. **Java开发工具**：Eclipse Mars提供了强大的Java开发工具集，包括代码编辑器、调试器、构建工具等，支持Java 8的新特性，如lambda表达式和默认方法。 2. **Web和Java EE支持**：该版本强化了对Web和Java EE应用...
c++学习笔记十七(函数指针与智能指针)
qq_41827817的博客
03-15 334
1.auto_ptr 作用：对作用域内的动态分配对象的自动释放 基本类型： #include <iostream> #include <memory> using namespace std; int main(){ int* pn = new int(10); auto_ptr<int> ap(pn); cout << *a...
c并非所有的代码路径都返回值_C++核心指南(17) I.11 禁止使用指针(T*)或引用(T&)来转移所有权...
weixin_39938522的博客
11-28 135
I.11: 永远不要使用原始指针(T*)或引用(T&)来转移所有权原因如果对调用者或被调用者是否拥有对象有任何疑问，就会发生泄漏或过早析构。示例考虑: X* compute(args) // 不要这样做 { X* res = new X{}; // ... return res; }谁来删除返回的X？当compute返回一个引用时，则更难发现问题。考虑按值返回结果(如果结果很大，使用mov...
shellmad-右值引用
esjiang的博客
03-17 145
七大爷的备课的内容, 转载过来 右值引用 右值引用是 C++11 引入的与 Lambda 表达式齐名的重要特性之一。它的引入解决了 C++ 中大量的历史遗留问题，消除了诸如 std::vector、std::string 之类的额外开销，也才使得函数对象容器 std::function 成为了可能。 （1）左值、右值的纯右值、将亡值、右值 要弄明白右值引用到底是怎么一回事，必须要对左值和右值做一个明确的理解。 左值(lvalue, left value)，顾名思义就是赋值符号左边的值。准确来说，左值是表达式
C++ 11/14/17 智能指针
yaoming168的专栏
02-06 372
为了更加容易（更加安全）的使用动态内存，引入了智能指针的概念。智能指针的行为类似常规指针，重要的区别是它负责自动释放所指向的对象。
C++（17）——智能指针初步及弃用auto_ptr的原因
qq_44824574的博客
03-09 2775
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++ 智能指针详解
Tyler_Zx的博客
09-03 2321
简介 智能指针仅用于存储在堆中分配的内存的对象，智能指针做的工作比原始指针多得多。智能指针最重要的是特性是不必使用delete 和 delete[] 运算符释放内存，只要不再需要智能指针，它们就会自动释放。这样就可以避免多次释放、分配/释放不匹配、指针悬挂和内存泄露的可能性。 智能指针特别适合用于管理动态创建的类对象，但智能指针不能完成原始指针的所有操作，智能指针不能递增或递减，也不能执行其他算术操作。智能指针由标准库memory 头文件中的模版定义，所以必须在源文件中包含这个头文件，才能使用智能指..
c++智能指针详解
热门推荐
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
c++11新特性智能指针
07-29
C++11引入了智能指针（smart pointers），它们是一些用于管理动态分配的内存的类模板。C++11中引入的主要智能指针有： 1. `std::shared_ptr<T>`：共享指针，用于共享资源的所有权。它使用引用计数来跟踪指针的引用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值