【C++11】常见智能指针总结

于 2024-05-06 10:12:41 发布
阅读量604 收藏 29
点赞数 17
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51064412/article/details/137394937
版权

文章目录

一. 内存泄漏

1. 什么是内存泄漏？

内存泄漏指因为疏忽或错误造成程序未释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理空间上的消失，而是我们的应用程序在分配到某块内存空间后，因为设计错误，失去了对该块内存的控制，因而造成了这块内存资源的浪费。

下面是两种常见的内存泄漏场景：

void MemoryLeaks()
{
	// 1、内存申请了，但是忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
	
	// 2、抛异常导致内存泄漏
	try
	{
		int* p3 = new int[10];
		throw "exception";
		delete[] p3; //上面抛出了异常，导致 delete[] 没有执行
	}
	catch(const char* a)
	{
		cout << "catch exception" << endl;
	}
}

内存泄漏分类

在 C/C++ 程序中，我们一般只关心两方面内存泄漏的情况：

  • 堆内存泄漏（Heap Leak）
    堆内存指的是程序执行中依据需求，通过 malloc、calloc、realloc、new 等从堆中分配得到一块内存空间，用完后必须调用相应的 free 或者 delete 把它们释放。假设因为程序的设计错误导致这部分内存没有被释放，那么这块空间就会被白白浪费出去了，消耗系统资源，产生 Heap Leak。
  • 系统资源泄漏（System Resources Leak）
    指程序使用系统分配的资源，比如套接字、文件描述符、管道等，后续没有使用对应的函数把它们释放掉，导致系统资源浪费，严重可导致系统效能减少，系统运行不稳定。

2. 如何检测内存泄漏？

3. 如何避免内存泄漏？

  1. 工程前期设定和遵守良好的程序设计规范，养成良好的编码风格和习惯，申请的内存空间记得要进行相应的释放。
  2. 采用 RAII 思想或者智能指针来管理资源。
  3. 有些公司内部规范使用自己实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  4. 出问题了使用内存泄漏工具检测。不过很多工具都不够靠谱，或者收费昂贵。

总结一下，内存泄漏非常常见，解决方案分为两种：

  • 事前预防型，如智能指针等
  • 事后查错型，如泄漏检测工具

二. 智能指针的使用及原理

下面我们实现一个最简单的智能指针，用它来管理我们所申请的系统资源。

1. RAII 机制

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来管理程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

实现方法：在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。本质上是把管理一份资源的责任交付给了一个对象。这种做法有两大好处：

  • 不需要我们显式地释放资源
  • 采用这种方式，被管理资源的生命周期和对象同步

RAII 机制的简单实现：

// 自定义一个智能指针模板
template<class T>
class SmartPtr
{
public:
	// 构造函数执行时把资源保存起来
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	// 析构函数执行时释放释放资源
	~SmartPtr()
	{
		delete _ptr;
		cout << "~SmartPtr() do delete" << endl;
	}
private:
	T* _ptr;
};

// 测试
int main()
{
	// 把申请到的堆空间交给 SmartPtr 类的对象来管理，后续不需要我们再手动释放
	SmartPtr<int> sp1(new int);
	SmartPtr<char> sp2(new char[30]);
	return 0;
}

//------输出结果------
~SmartPtr() do delete
~SmartPtr() do delete

2. 智能指针的原理

上述的 SmartPtr 还不能将其称为智能指针，因为这个类的对象还不具有以下两种指针的行为：

  • 指针可以通过 * 解引用获得它所指向的实体
  • 指针可以通过 -> 访问其内部的成员

因此，我们还需要在 SmartPtr 模板类中重载 * 、-> 这两个操作符：

template<class T>
class SmartPtr
{
public:
	// 构造函数执行时保存 ptr 的值
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	// 析构函数执行时释放 ptr 指向的内存空间
	~SmartPtr()
	{
		delete _ptr;
	}

	// 解引用操作符重载
	T& operator*()
	{
		return *_ptr;
	}

	// -> 操作符重载
	T* operator->()
	{
		return _ptr;
	}

private:
	T* _ptr;
};

void TestSmartPtr()
{
	// 通过 SmartPtr 类去封装一个 new 出来的 pair<int, int> 键值对
	SmartPtr<pair<int, int>> sp(new pair<int, int>(1, 2));

	// 像原生指针一样，直接访问成员
	// （本来应该是 sp->->first 才对的，但编译器为了可读性，做了优化处理，只需要一个 -> 就够了）
	sp->first = 10; 
	sp->second = 20;

	// 像原生指针一样，解引用获得实体
	(*sp).first = 10;
	(*sp).second = 20;
}

总结：智能指针的原理

  1. 定义一个管理指针对象的类模板
  2. 具有 RAII 特性
  3. 重载 operator* 和 opertaor->，使它的实例化对象能够像指针一样去操作
  4. 最后还需要解决智能指针对象拷贝的问题（会在下文中说明，智能指针的分类和发展主要集中在这个问题的解决上）

3. 标准库中最早的智能指针（auto_ptr）

3.1 智能指针拷贝的问题

上面我们模拟实现的 SmartPtr 已经能够完成对资源的基本控制了：

  • 当 SmartPtr 对象的生命周期结束时，在其析构函数中自动释放资源。
  • 让 SmartPtr 对象能够像指针一样去解引用和使用 -> 访问指针所指向对象中的成员。

那这个智能指针对象能否拷贝和赋值呢？
在这里插入图片描述

可以看到，我们上面设计的智能指针还是有缺陷的：使用指针指针进行拷贝构造时，发生了浅（值）拷贝。最后析构时，同一块空间被 delete 了两次，导致程序崩溃。

3.2 auto_ptr 介绍

标准中最早的智能指针在 C++98 中被引入，叫做 auto_ptr ：auto_ptr 官方文档

在 auto_ptr 中，针对对象拷贝时的处理方式为：进行资源控制权的转移。其核心在于拷贝时把资源交给另外一个对象去管理，之前管理这块资源的原对象会悬空，即始终保持一个资源只会被一个对象所管理。

在这里插入图片描述

3.3 auto_ptr 模拟实现

为了学习和了解 auto_ptr 智能指针，下面我们简单的模拟实现一个自己的 AutoPtr：

// 模拟实现 std::auto_ptr
template<class T>
class AutoPtr
{
public:
	// 构造函数 和 析构函数
	AutoPtr(T* ptr) :_ptr = ptr {}
	~AutoPtr() { delete _ptr; }

	// 拷贝构造
	AutoPtr<T>(AutoPtr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = nullptr;
	}

	// 赋值运算符重载
	AutoPtr<T>& operator=(AutoPtr<T>& ap)
	{
		// 防止自己给自己赋值
		if (this != &ap)
		{
			// 先释放当前对象中的资源
			delete _ptr;
			// 获得 ap 资源的控制权
			_ptr = ap._ptr;
			// 把 ap 中的指针置为空
			ap._ptr = nullptr;
		}
		return *this;
	}

	// * 和 -> 重载
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }

private:
	T* _ptr;
};

用我们自己实现的 AutoPtr 来对比标准库中的 auto_ptr，看看它们拷贝构造时的效果如何：

在这里插入图片描述

再来看看它们的赋值时的效果如何：

在这里插入图片描述

总结：auto_ptr 被设计出来之后就遭到了很多吐槽，因为在工程中，指针变量的拷贝是在所难免的，比如传参或者其它赋值场景时都要拷贝地址。而 auto_ptr 的拷贝原理是转移资源的控制权。一块资源只能被一个智能指针对象所管理，而且拷贝完之后还会导致原对象悬空的问题，这时如果没有注意，对原对象进行解引用或者 -> 访问成员，都会导致程序崩溃。所以对于 auto_ptr 一般是不推荐使用或者直接就禁止使用。

注意：auto_ptr 拷贝构造和赋值重载函数的形参不能加 const 修饰

不论是拷贝构造还是赋值：

  • 对于等号左边的对象而言，它都是要接受和管理被转移过来的新的资源。
  • 对于等号右边的对象而言，它的资源需要被转移给等号左边的对象，然后自己悬空。

等号右边的值，经过拷贝和赋值后，无论如何都会被置空，所以它一定会被修改的，我们在设计时就不能加 const 了。

在这里插入图片描述

4. 简单粗暴的防拷贝（unique_ptr）

C++98 标准之后，C++11 出来之前，boost 库中新设计出了一批智能指针，其中的几个智能指针后来被吸收到的 C++11 当中。首先就是比 auto_ptr 供更靠谱的 unique_ptr。

unique_ptr 原型为 boost 库中的 scoped_ptr，其针对拷贝场景的处理方式为：简单粗暴的禁止拷贝（内部直接把拷贝和赋值给禁了）。即这个智能指针对象所管理的资源不能被拷贝和转移给其他对象，自己牢牢把握资源的控制权。

下面简单模拟实现一下 unique_ptr：

// 模拟实现 std::unique_ptr
template<class T>
class UniquePtr
{
public:
	// 构造函数 和 析构函数
	UniquePtr<T>(T* ptr) :_ptr = ptr{}
	~UniquePtr<T>() { delete _ptr; }

	// 禁用拷贝构造、赋值运算符重载
	UniquePtr<T>(UniquePtr<T>&) = delete;
	UniquePtr<T>& operator=(UniquePtr<T>&) = delete;

	// * 和 -> 重载
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }

private:
	T* _ptr;
};

测试看看我们自己的 UniquePtr 和标准库中的 unique_ptr 各自进行拷贝时的效果如何：
在这里插入图片描述

总结：如果明确了我们申请的资源只需要短暂的使用或者它仅仅只需要被一个对象所管理时，可以考虑用 unique_ptr。

5. 让资源和引用计数绑定（shared_ptr）

5.1 shared_ptr 介绍

shared_ptr 也是 C++11从 boost 库中引入的一个智能指针，其原型在 boost 库中也叫 shared_ptr。

shared_ptr 针对拷贝的处理方式为：通过引用计数来统计一块资源被多少个智能指针对象所管理。

具体管理资源的方式如下：

  1. shared_ptr 在其内部，给每个资源都维护了一份计数，用来记录该份资源被几个对象所控制。
  2. 在对象被销毁时（也就是析构函数调用时），就说明该对象不再使用这个资源了，这时让引用计数减一。
    • 如果检测到引用计数变为0，就说明自己是最后一个使用该资源的对象，此时需要释放这块资源。
    • 如果不是0，就说明除了自己之外，还有其他对象在使用该资源，注意此时不能释放该资源，否则其他智能指针对象就变成野指针了。

5.1 关于引用计数

接下来我们模拟实现一个 shared_ptr。它的的核心在于引用计数，应该如何来设置这个引用计数呢？

把它设为普通成员变量行不行？
在这里插入图片描述

上面方式，不同的实例化对象没有共享引用计数，那我们把引用计数设为静态成员行不行？
在这里插入图片描述

还是不对，复盘一下，我们真正想要的是什么？是希望一个资源能够和一个特定的引用计数绑定在一起，然后这个引用计数可以被一起管理这块资源的所有对象所看到（注意不是类的所有对象）。

所以我们可以考虑在初次智能指针对象去接收一块资源时，顺便也到堆上动态申请一个 int 类型的引用计数对象。后续如果还有其它智能指针对象去指向这块空间的话（通过拷贝或复赋值），我们就让这块空间所绑定的引用计数加一：

在这里插入图片描述

5.2 share_ptr 模拟实现

  • 引入一个 int* 类型的成员变量 _count，作为引用计数
  • 把自增引用计数的操作单独封装成为一个方法AddRef()
  • 把自减引用计数的操作单独封装成为一个方法ReleaseRef()
// 模拟实现 std::sgare_ptr
template<typename T>
class SharePtr
{
public:
	// 构造函数
	SharePtr(T* ptr)
		:_ptr(ptr)
		,_count(new int(1))
	{}

	// 析构函数
	~SharePtr()
	{
		ReleaseRef();
	}

	// 拷贝构造
	SharePtr(SharePtr& sp)
		:_ptr(sp._ptr)
		,_count(sp._count)
	{
		AddRef(); //引用计数加一
	}

	// 赋值运算符重载
	SharePtr& operator=(SharePtr& sp)
	{
		if (_ptr != sp._ptr)
		{
			ReleaseRef();
			_ptr = sp._ptr;
			_count = sp._count;
			AddRef();
		}
		return *this;
	}

	// 重载 * 和 ->
	T* operator->() { return _ptr; }
	T& operator*() { return *_ptr; }

private:
	// 引用计数加一
	void AddRef() 
	{
		++*_count; 
	}

	// 引用计数减一
	void ReleaseRef()
	{
		if (--*_count == 0)
		{
			delete _ptr;
			delete _count;
		}
	}

	T* _ptr;    //指向一块空间
	int* _count;//对应空间的引用计数
};

注意：关于赋值运算符重载

在这里插入图片描述

5.3 shared_ptr 中的线程安全问题

在使用 shared_ptr 时涉及到的线程安全问题体现在以下两个方面：

  1. 智能指针对象中引用计数是参与管理这块资源的多个智能指针对象所共享的。如果两个线程中的不同智能指针对象同时同一个引用计数进行 ++ 或 --，这个操作不是原子的，在多线程、高并发的情况下 count 的值可能会出现混乱，进而导致资源未释放或者程序崩溃的问题。也就是说目前我们写的 SharedPtr 对引用计数的操作是线程不安全的，后续我们需要加锁。
  2. 智能指针负责保证内部引用计数的线程安全，但是不保证它所管理的这块资源的线程安全。因为如何使用资源是外部逻辑的事，这并不归智能指针所管理。

为了解决多线程高并发情况下，引用计数可能导致的线程不安全的问题，我们针对每个特定的空间和引用计数去专门配套一把互斥锁，后续所有对引用计数的加减操作都需要在加锁的情况下完成。

PS：互斥锁、资源、引用计数，它们三个的生命周期是同步的，在构造函数中一起初始化，到最后释放时也是同步的一起释放。

下面是引入互斥锁后的 shared_ptr 的模拟实现：

// 模拟实现 std::sgare_ptr
template<typename T>
class SharePtr
{
public:
	// 构造函数
	SharePtr(T* ptr)
		:_ptr(ptr)
		,_count(new int(1))
		,_mtx(new std::mutex)
	{}

	// 析构函数
	~SharePtr()
	{
		ReleaseRef();
	}

	// 拷贝构造
	SharePtr(SharePtr& sp)
		:_ptr(sp._ptr)
		,_count(sp._count)
		,_mtx(sp._mtx)
	{
		AddRef(); //引用计数加一
	}

	// 赋值运算符重载
	SharePtr& operator=(SharePtr& sp)
	{
		if (_ptr != sp._ptr)
		{
			ReleaseRef();
			_ptr = sp._ptr;
			_count = sp._count;
			_mtx = sp._mtx;
			AddRef();
		}
		return *this;
	}

	// 重载 * 和 ->
	T* operator->() { return _ptr; }
	T& operator*() { return *_ptr; }

private:
	// 引用计数加一
	void AddRef() 
	{
		_mtx->lock();
		++*_count; 
		_mtx->unlock();
	}

	// 引用计数减一
	void ReleaseRef()
	{
		bool deleteFlag = false;

		_mtx->lock();
		if (--*_count == 0)
		{
			deleteFlag = true;
			delete _ptr;
			delete _count;
		}
		_mtx->unlock();
		
		if (deleteFlag)
		{
			delete _mtx;
			_mtx = nullptr;
		}
	}

	T* _ptr;	//指向一块空间
	int* _count;//对应空间的引用计数
	std::mutex* _mtx; //每块空间对应一把锁（锁也在堆上创建）
};

注意：析构函数中释放互斥锁时的注意事项

在一个 SharedPtr 对象析构时，加锁后执行 count–，如果发现它的值变为0了，此时就要它释放所管理资源和引用计数，这些动作都是在加锁情况下完成的，释放完成之后我们最后还需要把互斥锁也给释放了，所以我们还需要一个标志位去检测释放需要释放互斥锁：
在这里插入图片描述

5.4 shared_ptr 中的循环引用问题

循环引用就是互相引用。下面是一个双向链表的节点结构的定义，我们把指向前后节点的 _prev 和 _next 指针变量用我们自己实现的 SharedPtr 封装：

struct ListNode
{
	SharePtr<ListNode> _prev = nullptr;
	SharePtr<ListNode> _next = nullptr;
};

下面这种情况就会发生循环引用问题：

void TestListNode()
{
	ListNode* p1 = new ListNode;
	ListNode* p2 = new ListNode;
	SharePtr<ListNode> node1(p1);
	SharePtr<ListNode> node2(p2);
	// 循环引用
	node1->_next = node2;
	node2->_prev = node1;
}

循环引用会导致智能指针所管理的空间得不到正确的释放，分析循环引用形成的原因：

在这里插入图片描述

分析发现：导致循环引用的根本原因在于节点内部的 _prev 和 _next 这两个成员变量它们类型也是 SharePtr。我们在对 _prev 和 _next 赋值时发生了智能指针的拷贝，导致引用计数在逻辑上不必要地自增了一次，相当于把这个智能指针的生命给延长了。

在这里插入图片描述

关于 _prev 和 _next 我们需要的仅仅是让它们起到一个指向的作用，不需要画蛇添足的再去给智能指针的count++。但是又不能把它们设置为原生指针，因为在类外使用节点指针时，我们是把这个节点指针让share_ptr 去管理的，即 shared_ptr< ListNode >，此时 _next 和 _prev 的类型也只能是 shared_ptr< ListNode >。

针对类似场景下的循环引用的问题，我们可以使用 weak_ptr，它 同样也是 C++11 从 boost 库中引入的。weak_prt 也是一种智能指针，同样具有 RAII 的功能，但是它没有引用计数：

在这里插入图片描述

使用 weak_prt< ListNode > 来代替 shared_ptr< ListNode > 可以解决 _prev 和 _next 在拷贝 shared_ptr< ListNode > 类型的指针对象时不必要地增加引用计数的问题：

struct ListNode
{
	std::weak_prt<ListNode> _prev = nullptr;
	std::weak_prt<ListNode> _next = nullptr;
};

void TestListNode()
{
	ListNode* p1 = new ListNode;
	ListNode* p2 = new ListNode;
	SharePtr<ListNode> node1(p1);
	SharePtr<ListNode> node2(p2);
	// _next和_prev的类型为 std::weak_prt
	// 赋值也不会再有循环引用的问题了
	node1->_next = node2;
	node2->_prev = node1;
}

5.5 shared_ptr 中的定制删除器

智能指针管理的资源不仅仅是一个 new 出来的空间，还可以是一个文件、数组等，这些不同类型的资源在释放时有不同的释放方式。我们在构造智能指针对象时，可以把资源和如何清理这块资源的方法一起传到构造函数中。清理资源的方法就是定制删除器，它可以是如下可调用对象：

  • 函数指针
  • 仿函数
  • lambda表达式
  • 包装器

在 shared_ptr 的构造函数列表中可以看到（4）是带有定制删除器的构造函数：
在这里插入图片描述
使用示例

// 定制删除器 - 控制资源的释放方式
template<class T>
struct DelArr
{
	void operator()(const T* ptr)
	{
		cout << "delete[]: " << ptr << endl;
		delete[] ptr;
	}
};

void TestSharedPtrDeletor()
{
	// 带定制删除器的构造函数：template <class U, class D> shared_ptr(U * p, D del);
	// 1、仿函数写的定制删除器 - 删除一段连续空间
	std::shared_ptr<int> spArr(new int[10], DelArr<int>()); 
	// 2、lambda表达式写的定制删除器 - 删除FILE*文件
	std::shared_ptr<FILE> spfl(fopen("Test.cpp", "r"), [](FILE* ptr) {
		cout << "fclose: " << ptr << endl;
		fclose(ptr);
	});		
}

//------输出结果------
fclose: 000002154CE08760
delete[]: 000002154CE16B60

补充：在自己模拟实现的 SharePtr 中引入删除器

思路：在模板参数中再引入一个删除器类型的参数，并在类中增加一个删除器类型的成员变量。在构造时完成赋值，析构时调用它来释放资源：

template<class T, class D>
class SharePtr
{
public:
	// 这里要求构造函数必须传资源+删除器
	SharePtr(T* ptr, D del)
		:_ptr(ptr)
		,_del(del)
		, _pcount(new int(1))
		, _pmutex(new std::mutex)
	{}

	~SharePtr()
	{
		ReleaseRef();
	}

private:
	void ReleaseRef()
	{
		bool flag = false;
		_pmutex->lock();
		if (--(*_pcount) == 0)
		{
			if (_ptr)
			{
				// 使用定制删除器来清理资源
				_del(_ptr);
			}
			delete _pcount;
			flag = true;
		}
		_pmutex->unlock();

		if (flag == true)
		{
			delete _pmutex;
		}
	}

	T* _ptr;
	D _del;
	int* _pcount;
	mutex* _pmutex;
};

6. 弱指针（weak_ptr）

weak_ptr 有如下几个特点：

  • 不支持通过原生指针直接构造对象
  • 支持自身类型和 shared_ptr 类型的构造、拷贝构造、赋值
  • 不增加 shared_ptr 所管理资源的引用计数
  • 不参与所管理资源的释放
  • 重载了 *、-> 这两个操作符

下面是 weak_ptr 的简单模拟实现：

template<class T>
class WeakPtr
{
public:
	// 默认构造函数
	WeakPtr()
		:_ptr(nullptr)
	{}

	// 通过 shared_ptr 对象构造
	WeakPtr(const shared_ptr<T>& sp)
		:_ptr(sp.get()) //get方法用来获取原生指针
	{}

	// 通过 shared_ptr 对象赋值
	WeakPtr<T>& operator=(const shared_ptr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}

	// 通过 WeakPtr 对象赋值
	WeakPtr<T>& operator=(const WeakPtr<T>& wp)
	{
		if(this != &wp)
			_ptr = wp._ptr;
		return *this;
	}

private:
	T* _ptr;
};
帝国无伤
关注
  • 17
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11，智能指针详解，以及面试常见问题
goodgood_UP的博客
01-14 1038
四种智能指针详解，含面试常见问题
使用C++11智能指针时要避开的10大错误
12-22
我很喜欢新的C++11的智能指针。在很多时候，对很多讨厌自己管理内存的人来说是天赐的礼物。在我看来，C++11的智能指针能使得C++新手教学更简单。 　其实，我已经使用C++11两年多了，我无意中发现多种错误使用C++11...
C++ STL 四种智能指针
热门推荐
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
C++11：智能指针
Man9o
03-09 1372
全局对象：程序启动时分配，在程序结束时销毁。局部对象：当我们进入其定义所在的程序块时被创建，在离开块时销毁。局部static对象：在第一次使用前分配，在程序结束时销毁。静态内存：保存局部static对象、类static数据成员以及定义在任何函数之外的变量。栈内存：保存定义在函数内的非static对象。分配在静态或栈内存中的对象由编译器自动创建和销毁。对于栈对象，仅在其定义的程序块运行时才存在；static对象在使用之前分配，在程序结束时销毁。除了静态内存和栈内存，每个程序还拥有一个内存池。
【C++11】智能指针详解
枫叶先生的博客
05-13 1417
为何需要智能指针 | C++的智能指针 | C++11和boost中智能指针的关系详解
【C++11】智能指针
智子的博客
09-23 481
智能指针是行为类似于指针的类对象，可以帮助管理动态分配的内存。其支持解引用和箭头运算符等基本操作。C++11引入了3种智能指针，shared_ptr，unique_ptr和weak_ptr。
【C++】智能指针详解
就爱摆烂
05-04 9558
今天我们来讲一下c++11中的智能指针。
C++11【智能指针详解】
smf12138的博客
11-12 992
C++11中的智能指针
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++常见面试题 ——智能指针
weixin_44438755的博客
02-22 1860
智能指针是类模板，指针是C/C++中一个变量类型，存放的是内存地址。在使用上，智能指针和裸指针都支持解引用*，->等操作，但智能指针提供包含许多额外的函数。智能指针使用指向堆分配对象的原始指针进行初始化，初始化后，智能指针拥有原始指针。智能指针负责对原始指针的释放。智能指针使用RAII机制，管理堆内存中的数据。当智能指针超过其作用域，或者抛出异常时，就会调用智能指针的析构函数，自动释放堆上的内存数据。
C++ 智能指针
Cdreamfly的博客
02-23 2537
shared_ptr 智能指针也是模板类，因此当我们创建一个智能指针是要提供额外的信息——指针可以指向的类型。默认初始化的智能指针保存着一个空指针。shared_ptr允许多个指针指向同一对象。 shared_ptr<string> p1; //可指向string shared_ptr<list<int>> p2; //可指向int的list make_shared 最安全的分配和使用动态内存的方法是调用一一个名为make_shared 的标准库函数。此函数在动态内存
c++指针常见坑经验总结.rar
01-04
在C++编程中，指针是其核心特性之一，它为程序员提供了对内存直接操作的能力...通过理解指针的工作原理、正确管理内存、使用引用和智能指针，以及避免常见的陷阱，我们可以有效地利用指针，编写出高效而稳定的C++程序。
C++中智能指针如何设计和使用
09-05
在C++11及以后的版本中，标准库提供了内置的智能指针实现，如`std::unique_ptr`、`std::shared_ptr`和`std::weak_ptr`，它们具有高度优化的性能和良好的兼容性。开发者应优先考虑使用这些标准库的智能指针，而非...
C++智能指针详解abc
08-24
C++11 引入了四种智能指针：unique_ptr、shared_ptr、weak_ptr 和 auto_ptr（C++17 中已经被弃用），每种智能指针都有其特点和使用方法。 unique_ptr unique_ptr 是一种独占式智能指针，它确保了只有一个指针可以...
C++_智能指针详解
04-20
然而，随着C++11的发布，更加强大和灵活的智能指针如`std::unique_ptr`和`std::shared_ptr`被引入标准库，它们提供了更多的功能并且减少了潜在的风险。尽管如此，了解`std::auto_ptr`的工作原理和使用方式对于理解...
【C++】C++基础知识
m0_51064412的博客
05-23 2587
目录一.命名空间1.命名空间的定义2.命名空间使用3.说明二.C++输入&输出三.缺省参数1.缺省参数的概念2.缺省参数分类3.说明 一.命名空间 1.命名空间的定义 namespace关键字 + 命名空间的名字 + {}。{}中即为命名 空间的成员。 命名空间中的内容，既可以定义变量，也可以定义函数 命名空间可以嵌套 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中 //定义命名空间 namespace N { int a; int b; int Add(in
【C++】深入理解浅拷贝问题
m0_51064412的博客
08-05 1717
文章目录一. 浅层浅拷贝问题二. 深层浅拷贝问题三. 类型萃取 一. 浅层浅拷贝问题 问题分析 我们在学C语言的结构体的时候知道，可以用一个结构体对象去拷贝出另外一个结构体对象，其原理是通过memcpy来实现的，当时我们看到的结果确实是拷贝出了另一个值相同的结构体对象。 我们来看看memcpy的拷贝原理，其实就是逐个字节的来完成拷贝。 void* memcpy(void* dest, const void* src, size_t num)//传入数据可能是各种类型的，所以用void*接收 {
【C++】vector 模拟实现
m0_51064412的博客
08-05 1424
文章目录一.vector介绍二. vector的模拟实现1. private成员变量及迭代器2. 容量操作接口2.1 size和capacity2.2 reserve2.2 resize3. 默认成员函数3.1 构造函数3.2 拷贝构造3.3 赋值重载4. 修改操作接口4.1 insert4.2 erase 一.vector介绍 vector是表示可变大小数组的序列容器 就像数组一样，vector也采用连续的存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不
【C++11】lambda 表达式
最新发布
m0_51064412的博客
03-10 913
捕捉列表。该列表总是出现在 lambda 表达式的开始位置，它是 lambda 表达式的标识。编译器根据 [ ] 来判断接下来的代码是否为 lambda 表达式，捕捉列表能够捕捉上文作用区中的变量供 lambda 表达式使用。：参数列表。与普通函数的参数列表一致（可以指定参数是传值还是传引用，或者是否是 const），如果不需要参数传递，则可以连同括号一起省略。mutable。
c++11智能指针使用注意事项
05-22
C++11引入了智能指针，它们提供了一种自动管理动态分配内存的方式，以避免常见的内存泄漏和悬挂指针问题。使用智能指针时，需要注意以下几点： 1. 尽量使用 unique_ptr：unique_ptr 是一种独占式智能指针，它不能被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值