概述

c++效率较高的一个原因是我们可以自己定制策略手动申请和释放内存，当然，也伴随着开发效率降低和内存泄漏的风险。为了减少手动管理内存带来的困扰，c++提出了智能指针，可以帮助我们进行内存管理，有三种:

1. std::unique_ptr 是一种独占所有权的智能指针，它不允许多个指针指向同一个对象。 std::unique_ptr 是一种轻量级的智能指针，不需要额外的开销，因此在你不需要共享所有权的情况下，应优先使用 std::unique_ptr .

2. std::shared_ptr 是一种可以共享所有权的智能指针。多个 std::shared_ptr 可以指向同一个对象，该对象只有在最后一个指向它的 std::shared_ptr 被销毁时才会被删除。 std::shared_ptr 使用引用计数来跟踪有多少个智能指针指向同一个对象.

3. std::weak_ptr 是一种弱引用智能指针，它可以指向 std::shared_ptr 所管理的对象，但它不会增加该对象的引用计数。这对于解决 std::shared_ptr 的循环引用问题很有用.

智能指针的类型决定了何时销毁和释放内存。当智能指针的生命周期结束时，它会自动清理其所有权的内存。这就避免了内存泄漏，使代码更安全、更健壮。 但是智能指针的使用，也要注意一些问题:

• 智能指针并不能自动解决循环引用的问题，需要手动在合适的场合使用 std::weak_ptr 弱指针
• 智能指针的使用是“传染性”的，如果使用智能指针，要考虑好整个逻辑链条都使用智能指针而不是原生的指针
• 从实际项目使用上看，一些比较上层的模块使用智能指针，更加方便，而在底层模块更多的还是使用原生的指针，我想大概因为智能指针也是会带来一些开销而且可能和一些内存管理策略冲突（如某些优化内存策略可能不使用指针，而使用句柄来指向对象）

智能指针是一个对象，实现是非入侵式的。关于他们的大概的原理:

• std::unique_ptr 它包含一个原生指针，并在其析构函数中删除这个指针。 std::unique_ptr 还重载了 -> 和 * 运算符，所以可以像使用原生指针一样使用 std::unique_ptr
• std::shared_ptr 的实现则相对复杂一些。除了存储原生指针， std::shared_ptr 还需要存储一个引用计数。每次创建一个新的 std::shared_ptr 或者调用 std::shared_ptr 的拷贝构造函数或赋值运算符时，引用计数就会增加。每次销毁一个 std::shared_ptr 时，引用计数就会减少。只有当引用计数降到0时，才会删除原生指针。类似的还要处理若引用。此外，引用计数还要保证线程安全。

用法举例

参考测试项目代码 ModernCppTest/modrenc_smart_pointer.cpp 主要包含:

• 共享指针用法&声明方式
• 独占指针用法&声明方式
• 弱指针的用法

                        
                          #include "ModernCppTestHeader.h"
#include <memory>

#define LOG_UNIQUE_PTR_VALID(ptr) if(ptr) LOG(#ptr << " unique_ptr valid"); else LOG(#ptr << " unique_ptr invalid")
#define LOG_WEAK_PTR_IF_VALID(ptr, exp) if(auto tp = p2.lock()) exp else LOG(#ptr << " weak_ptr invalid")

namespace n_smart_pointer {
	class Obj {
	public:
		Obj(int ID) : ID(ID) { LOG("Obj addr " << this << " ID " << ID << " Create"); }
		~Obj() { LOG("Obj addr " << this << " ID " << ID << " Release"); }

		int ID;
	};

	class Item {};
}

using LocaObj = n_smart_pointer::Obj;

void smart_pointer_test()
{
	LOG_FUNC();


	LOG_TAG("std::shared_ptr 共享指针");
	{
		{
			std::shared_ptr<LocaObj> p1 = std::make_shared<LocaObj>(1);
			{
				std::shared_ptr<LocaObj> p2 = p1;
				LOG_VAR_DESC(p1->ID, " p1->ID");
				LOG_VAR_DESC(p2->ID, " p2->ID");
				LOG("p2 离开作用域");
			}
			LOG("p1 离开作用域");
		}
	}


	LOG_TAG("std::shared_ptr 共享指针的声明方式");
	{
		std::shared_ptr<LocaObj> p1(new LocaObj(1));
		std::shared_ptr<LocaObj> p2 = std::make_shared<LocaObj>(2);
		std::shared_ptr<LocaObj> p3(p2);
	}


	LOG_TAG("std::unique_ptr 唯一指针");
	{
		{
			std::unique_ptr<LocaObj> p1;
			{
				std::unique_ptr<LocaObj> p2 = std::make_unique<LocaObj>(1);
				LOG_VAR_DESC(p2->ID, " p2->ID");

				LOG("唯一指针转移控制权使用=运算符报错，须使用std::move()");
				// std::unique_ptr<LocaObj> p1 = p2;
				p1 = std::move(p2);
				LOG_VAR_DESC(p1->ID, " p1->ID");

				LOG("测试被std::move的p2是否还有效，可以看到 无效");
				LOG_UNIQUE_PTR_VALID(p2);
				LOG("p2 离开作用域, ID为1的Obj没有析构");
			}

			LOG("p1 离开作用域， ID为1的Obj析构");
		}
	}


	LOG_TAG("std::unique_ptr 唯一指针的声明方式");
	{
		std::unique_ptr<LocaObj> p1(new LocaObj(1));
		std::unique_ptr<LocaObj> p2 = std::make_unique<LocaObj>(2);
		std::unique_ptr<LocaObj> p3(std::move(p2));
	}


	LOG_TAG("std::weak_ptr 弱指针");
	{
		std::shared_ptr<LocaObj> p1 = std::make_shared<LocaObj>(1);
		std::weak_ptr<LocaObj> p2 = p1;

		LOG_VAR_DESC(p1->ID, " p1->ID");
		LOG_WEAK_PTR_IF_VALID(p2, LOG_VAR_DESC(tp->ID, " p2->ID"););

		LOG("p1 reset Obj对象被释放");
		p1.reset();

		LOG("p2 弱指针失效");
		LOG_WEAK_PTR_IF_VALID(p2, LOG_VAR_DESC(tp->ID, " p2->ID"););
	}
}

                        
                      

最后此篇关于现代C++（ModernC++）基本用法实践：五、智能指针的文章就讲到这里了,如果你想了解更多关于现代C++（ModernC++）基本用法实践：五、智能指针的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。