【C++】智能指针详解

一、智能指针简介

智能指针是C++标准库中的一个重要概念，主要用于管理动态分配内存的对象。与传统指针不同，智能指针能够自动管理内存的分配和释放，从而减少内存泄漏和其他内存相关错误的风险。C++中主要有三种智能指针：std::unique_ptr、std::shared_ptr和std::weak_ptr。

二、为什么要用智能指针

像前面抛异常的捕获try、catch就非常容易造成内存泄漏。

登录后复制

#include <iostream>
#include <stdexcept>

void causeMemoryLeak() {
    int* ptr = new int(42); // 动态分配内存

    // 模拟抛出异常
    throw std::runtime_error("Something went wrong!");

    // 此处如果异常未抛出，应该释放内存
    delete ptr;
}

int main() {
    try {
        causeMemoryLeak();
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
        // 这里 ptr 的内存没有被释放，造成内存泄漏
    }

    return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.

前面的C++异常中聊过，当throw执行时，throw后面的语句将不再被执行。所以当这里抛出runtime_error异常后，导致delete per被跳过。造成了内存泄漏。虽然我们可以通过对代码进行优化，以防止出现这种情况。但是如果用智能指针来对资源进行管理就会非常的方便。

C++98提供了std::auto_ptr C++11提供了std::unique_ptr 、std::shared_ptr、std::weak_ptr

三、 RAII和智能指针

RAII是Resource Acquisition Is Initialization(资源获取即初始化)的缩写，他是⼀种管理资源的类的设计思想，本质是⼀种利用对象生命周期来管理获取到的动态资源，避免资源泄漏，这里的资源可以是内存、文件指针、网络连接、互斥锁等等。RAII在获取资源时把资源委托给⼀个对象，接着控制对资源的访问，资源在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源，这样保障了资源的正常释放，避免资源泄漏问题。

登录后复制

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired." << std::endl; }
    ~Resource() { std::cout << "Resource released." << std::endl; }
};

void useResource() {
    std::unique_ptr<Resource> resPtr(new Resource()); // RAII
    // 可以在这里使用 resPtr
    
    // 当函数结束，resPtr 超出作用域时，Resource 的析构函数会被调用
}

int main() {
    try {
        useResource();
    } catch (const std::exception& e) {
        std::cout << "Exception caught: " << e.what() << std::endl;
    }
    return 0; // 此时 Resource 的内存已经被释放，无需手动 delete
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.

auto_ptr

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

登录后复制

int main()
{
	auto_ptr<int> p1(new int(1));
	auto_ptr<int> p2(p1);
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.

auto_ptr的简单模拟实现

登录后复制

namespace hbx
{
	template<class T>
	class auto_ptr
	{
	public:
		//构造
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		//拷贝构造
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr=nullptr;//指针置为空，管理权转换
		}
		//赋值重载
		auto_ptr<T>& operator=(const auto_ptr<T>& ap)
		{
			if (this != &ap)
			{
				if (_ptr)
				{
					delete _ptr;//释放被赋值对象的资源，这个对象是已经存在的被new出来的。
				}
				_ptr = ap._ptr;
				ap._ptr == nullptr;//赋完值把赋值对象的指针置为空
			}
			return *this;
		}

		~auto_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
			}
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.
• 47.
• 48.
• 49.
• 50.
• 51.

unique_ptr

unique_ptr是C++11设计出来的智能指针，他的名字翻译出来是唯一指针，他的特点的不支持拷贝，只支持移动。如果不需要拷贝的场景就非常建议使用他。不允许左值赋值操作，可以通过move使左值转化为右值。移动后，移动的对象的指针也悬空，要谨慎使用。

登录后复制

int main()
{
	unique_ptr<Date> u1(new Date(1, 1, 1));
	unique_ptr<Date> u2(move(u1));//不支持拷贝，支持移动。但是也要谨慎使用u1照样悬空。
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.

跟auto_ptr主要区别是，用unique_ptr那么程序员是知道移动对象是悬空的情况下使用。

unique_ptr的简单模拟实现

登录后复制

namespace hbx
{
	template<class T>
	class unique_ptr
	{
	public:
		//构造
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
		//析构
		~unique_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
			}
		}
		//拷贝构造
		unique_ptr(const unique_ptr<T>& up) = delete;
		//复制重载
		unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
		//移动构造
		unique_ptr(unique_ptr<T>&& up)
			:_ptr(up._ptr)
		{
			up._ptr = nullptr;
		}
		//移动赋值
		unique_ptr<T>& operator=(unique_ptr<T>&& up)
		{
			if (_ptr)
			{
				delete _ptr;
			}
			_ptr = up.ptr;
			up.ptr = nullptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

int main()
{
	hbx::unique_ptr<Date> u1(new Date(1, 1, 1));
	hbx::unique_ptr<Date> u2(move(u1));
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.
• 47.
• 48.
• 49.
• 50.
• 51.
• 52.
• 53.
• 54.
• 55.
• 56.
• 57.

shared_ptr

shared_ptr是C++11设计出来的智能指针，他的名字翻译出来是共享指针，他的特点是支持拷贝，也支持移动。如果需要拷贝的场景就需要使用他了。底层是用引用计数的方式实现的。

shared_ptr当复制或则拷贝的时候，引用计数+1，当智能指针析构的时候引用计数-1。如果引用计数为0，那么这块内存就没有资源了就释放它。

登录后复制

int main()
{
	shared_ptr<Date> sp1(new Date(1, 1, 1));
	shared_ptr<Date> sp2(sp1);
	//use_count()：引用计数
	cout << sp2.use_count() << endl;

	shared_ptr<Date> sp3(new Date(2, 2, 2));
	cout << sp3.use_count() << endl;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.

shared_ptr的简单模拟实现

登录后复制

namespace hbx
{
	template<class T>
	class shared_ptr
	{
	public:
		//构造
		shared_ptr(T* ptr)
			:_ptr(ptr)
			,_pcount(new int(1))
		{}
		//析构
		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;
			}
		}
		//拷贝构造
		shared_ptr(const shared_ptr<T>& ps)
			:_ptr(ps._ptr)
			, _pcount(ps._pcount)
		{
			++(*_pcount);
		}
		//赋值重载
		shared_ptr<T>& operator=(const shared_ptr<T>& ps)
		{
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;
			}

			_ptr = ps._ptr;
			_pcount = ps._pcount;
			++(*_pcount);
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
	};
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.
• 47.
• 48.
• 49.
• 50.
• 51.
• 52.
• 53.
• 54.
• 55.

shared_ptr 除了支持用指向资源的指针构造，还支持 make_shared 用初始化资源对象的值直接构造。

登录后复制

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int num) : data(num) {
        std::cout << "MyClass constructor called" << std::endl;
    }
    void printData() const {
        std::cout << "Data: " << data << std::endl;
    }
private:
    int data;
};

int main() {
    // 使用make_shared直接初始化资源对象的值来构造shared_ptr
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>(10);
    ptr->printData();
    return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.

shared_ptr 和 unique_ptr 都支持了operator bool的类型转换，如果智能指针对象是⼀个空对象没有管理资源，则返回false，否则返回true，意味着我们可以直接把智能指针对象给if判断是否为空。

登录后复制

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int num) : data(num) {}
    void printData() const 
    {
        std::cout << "Data: " << data << std::endl;
    }
private:
    int data;
};

int main() {
    // shared_ptr使用示例
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(20);
    if (ptr1) 
    {
        ptr1->printData();
    } 
    else 
    {
        std::cout << "ptr1 is empty" << std::endl;
    }

    std::shared_ptr<MyClass> ptr2;
    if (ptr2) 
    {
        ptr2->printData();
    } 
    else 
    {
        std::cout << "ptr2 is empty" << std::endl;
    }

    // unique_ptr使用示例
    std::unique_ptr<MyClass> uptr1 = std::make_unique<MyClass>(30);
    if (uptr1)
    {
        uptr1->printData();
    }
     else 
    {
        std::cout << "uptr1 is empty" << std::endl;
    }

    std::unique_ptr<MyClass> uptr2;
    if (uptr2) 
    {
        uptr2->printData();
    } 
    else 
    {
        std::cout << "uptr2 is empty" << std::endl;
    }

    return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.
• 47.
• 48.
• 49.
• 50.
• 51.
• 52.
• 53.
• 54.
• 55.
• 56.
• 57.
• 58.
• 59.

shared_ptr 和 unique_ptr 都得构造函数都使用explicit 修饰，防止普通指针隐式类型转换成智能指针对象。

登录后复制

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int num) : data(num) {}
    void printData() const {
        std::cout << "Data: " << data << std::endl;
    }
private:
    int data;
};

int main() {
    // shared_ptr使用示例
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(20);
    if (ptr1) {
        ptr1->printData();
    } else {
        std::cout << "ptr1 is empty" << std::endl;
    }

    std::shared_ptr<MyClass> ptr2;
    if (ptr2) {
        ptr2->printData();
    } else {
        std::cout << "ptr2 is empty" << std::endl;
    }

    // unique_ptr使用示例
    std::unique_ptr<MyClass> uptr1 = std::make_unique<MyClass>(30);
    if (uptr1) {
        uptr1->printData();
    } else {
        std::cout << "uptr1 is empty" << std::endl;
    }

    std::unique_ptr<MyClass> uptr2;
    if (uptr2) {
        uptr2->printData();
    } else {
        std::cout << "uptr2 is empty" << std::endl;
    }

    return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.

shared_ptr的循环引用与weak_ptr

weak_ptr是C++11设计出来的智能指针，他的名字翻译出来是弱指针，他完全不同于上面的智能指针，他不支持RAII，也就意味着不能用它直接管理资源，weak_ptr的产生本质是要解决shared_ptr的⼀个循环引用导致内存泄漏的问题

hared_ptr大多数情况下管理资源非常合适，支持RAII，也支持拷贝。但是在循环引用的场景下会导致资源没得到释放内存泄漏，所以我们要认识循环引用的场景和资源没释放的原因，并且学会使用weak_ptr解决这种问题。

右边的节点什么时候释放呢，左边节点中的_next管着呢，_next析构后，右边的节点就释放了。 _next什么时候析构呢，_next是左边节点的的成员，左边节点释放，_next就析构了。 左边节点什么时候释放呢，左边节点由右边节点中的_prev管着呢，_prev析构后，左边的节点就释放了。 _prev什么时候析构呢，_prev是右边节点的成员，右边节点释放，_prev就析构了。 • 至此逻辑上成功形成回旋镖似的循环引用，谁都不会释放就形成了循环引用，导致内存泄漏 • 把ListNode结构体中的_next和_prev改成weak_ptr，weak_ptr绑定到shared_ptr时不会增加它的引用计数，_next和_prev不参与资源释放管理逻辑，就成功打破了循环引用，解决了这里的问题

登录后复制

struct ListNode
{
	int _data;
	std::shared_ptr<ListNode> _next;
	std::shared_ptr<ListNode> _prev;
	// 这里改成weak_ptr，当n1->_next = n2;绑定shared_ptr时
	// 不增加n2的引用计数，不参与资源释放的管理，就不会形成循环引用了
	/*std::weak_ptr<ListNode> _next;
	std::weak_ptr<ListNode> _prev;*/
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};

int main()
{
	// 循环引用 -- 内存泄露
	std::shared_ptr<ListNode> n1(new ListNode);
	std::shared_ptr<ListNode> n2(new ListNode);
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	n1->_next = n2;
	n2->_prev = n1;
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	// weak_ptr不支持管理资源，不支持RAII
	// weak_ptr是专⻔绑定shared_ptr，不增加他的引用计数，作为⼀些场景的辅助管理
	//std::weak_ptr<ListNode> wp(new ListNode);
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.

weak_ptr不支持RAII，也不支持访问资源，所以我们看文档发现weak_ptr构造时不支持绑定到资源，只支绑定到shared_ptr，绑定到shared_ptr时，不增加shared_ptr的引用计数，那么就可以解决上述的循环引用问题。

weak_ptr也没有重载operator*和operator->等，因为他不参与资源管理，那么如果它绑定的shared_ptr已经释放了资源，那么他去访问资源就是很危险的。weak_ptr支持expired检查指向的资源是否过期，use_count也可获取shared_ptr的引用计数，weak_ptr想访问资源时，可以调用lock返回⼀个管理资源的shared_ptr，如果资源已经被释放，返回的shared_ptr是⼀个空对象，如果资源没有释放，则通过返回的shared_ptr访问资源是安全的。

---

当weak_ptr的expired函数返回值为 0(在 C++ 中，0 通常代表false)时，这意味着weak_ptr所关联shared_ptr仍然有效，即对应的对象尚未被销毁。打印出来引用计数是2，weak_pt不增加计数但是不代表不指向计数。

weak_ptr所关联的share_ptr过期了

调用lock返回⼀个管理资源的shared_ptr，如果资源已经被释放，返回的shared_ptr是⼀个空对象，如果资源没有释放，则通过返回的shared_ptr访问资源是安全的。

四、删除器

智能指针析构时默认是进行delete释放资源，这也就意味着如果不是new出来的资源，交给智能指针管理，析构时就会崩溃。智能指针支持在构造时给⼀个删除器，所谓删除器本质就是⼀个可调用对象，这个可调用对象中实现你想要的释放资源的方式，当构造智能指针时，给了定制的删除器，在智能指针析构时就会调用删除器去释放资源。

因为new[]经常使用，所以为了简洁⼀点，unique_ptr和shared_ptr都特化了⼀份[]的版本，管理new []的资源。

登录后复制

unique_ptr<Date[]> up1(newDate[5]);
shared_ptr<Date[]> sp1(new Date[5]);

• 1.
• 2.

定制删除器还有lambda版本和仿函数版本

在shared_ptr下建议使用lambda版本

登录后复制

class Fclose
{
public:
    void operator()(FILE* ptr)
    {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    }
};

template<class T>
void DeleteArrayFunc(T* ptr)
{
    delete[] ptr;
}
int main()
{
std::shared_ptr<Date> sp1(new Date);
std::shared_ptr<Date[]> sp2(new Date[10]);

//lambda版本
 bit::shared_ptr<Date> sp3(new Date[10], [](Date* ptr) {delete[] ptr; });
 //仿函数版本
 std::shared_ptr<Date> sp4(new Date[5], DeleteArrayFunc<Date>);

//文件操作

//lambda版本
shared_ptr<FILE> sp6(fopen("Test.cpp", "r"), [](FILE* ptr) {fclose(ptr);});
//仿函数版本
std::shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), Fclose());
 }

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.

在unique_ptr下建议使用仿函数版本

登录后复制

class Fclose
{
public:
    void operator()(FILE* ptr)
    {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    }
};

std::unique_ptr<Date> up1(new Date);
std::unique_ptr<Date[]> up2(new Date[10]);

//lambda版本
auto fcloseFunc = [](FILE* ptr) {fclose(ptr); };
std::unique_ptr<FILE, decltype(fcloseFunc)> up4(fopen("Test.cpp", "r"), fcloseFunc);

//仿函数版本
std::unique_ptr<FILE, Fclose> up3(fopen("Test.cpp", "r"));

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.