C++11 智能指针

C++11智能指针详解

在 C++编程中，内存管理是一个至关重要的问题。手动管理内存容易导致内存泄漏、悬空指针等问题。为了更安全、高效地管理内存，C++11引入了智能指针。本文将详细介绍 C++11中的智能指针，包括unique_ptr、shared_ptr和weak_ptr。

一、为什么需要智能指针

在分析下面的程序时，我们需要注意MergeSort函数中的问题：

int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}

void Func()
{
    // 1.如果p1这里new抛异常会如何？
    // 2.如果p2这里new抛异常会如何？
    // 3.如果div调用这里又会抛异常会如何？
    int* p1 = new int;
    int* p2 = new int;
    cout << div() << endl;
    delete p1;
    delete p2;
}

int main()
{
    try
    {
        {
            Func();
        }
        catch (exception& e)
        {
            cout << e.what() << endl;
        }
    }
    catch (...)
    {
    }
    return 0;
}

从上面的问题分析中，我们可以发现手动管理内存存在以下问题：

1. 内存泄漏：如果在new操作后或在使用资源的过程中发生异常，可能导致内存泄漏，因为没有相应的代码来释放已分配的内存。
2. 异常安全问题：当多个操作连续进行时，如分配内存、使用资源和释放内存，如果其中某个操作抛出异常，可能会导致后续的资源释放操作无法执行，从而引发资源泄漏或其他问题。

为了解决这些问题，我们需要智能指针来自动管理内存，确保资源在不再使用时被正确释放。

二、内存泄漏

什么是内存泄漏及危害

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

长期运行的程序出现内存泄漏，会导致响应越来越慢，最终卡死，特别是对于操作系统、后台服务等程序，内存泄漏的影响更大。

内存泄漏最噩梦的就是例如在游戏中每有一个玩家购买一个皮肤就会导致内存泄露，而且因为每次泄露的内存少不易察觉，但是时间以长就会让游戏的服务器产生卡顿这就会发生大问题。

如何避免内存泄漏

• 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。但如果碰上异常时，就算注意释放了，还是可能会出问题，需要使用智能指针来管理才有保证。
• 采用RAII思想或者智能指针来管理资源。
• 有些公司内部规范使用内部实现的私有内存管理库，这套库自带内存泄漏检测的功能选项。
• 出问题了使用内存泄漏工具检测。

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

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

三、智能指针的使用及原理

RAII

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

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

• 不需要显式地释放资源。
• 采用这种方式，对象所需的资源在其生命期内始终保持有效。

以下是使用RAII思想设计的SmartPtr类：

template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}

    ~SmartPtr()
    {
        if (_ptr)
            delete _ptr;
    }

private:
    T* _ptr;
};

智能指针的原理

上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此，需要在模板类中重载*和->运算符，使其像指针一样使用。

template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}

    ~SmartPtr()
    {
        if (_ptr)
            delete _ptr;
    }

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

private:
    T* _ptr;
};

总结一下智能指针的原理：

1. RAII特性。
2. 重载operator*和operator->，具有像指针一样的行为。

std::unique_ptr

C++11中开始提供更靠谱的unique_ptr。
unique_ptr的实现原理是简单粗暴的防拷贝

std::unique_ptr的使用方法

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass object created" << std::endl; }
    ~MyClass() { std::cout << "MyClass object destroyed" << std::endl; }
    void doSomething() { std::cout << "Doing something in MyClass" << std::endl; }
};

int main() {
    // 使用 std::make_unique 创建 unique_ptr 来管理 MyClass 对象
    std::unique_ptr<MyClass> uniquePtr1 = std::make_unique<MyClass>();

    // 可以通过 unique_ptr 来调用对象的方法
    uniquePtr1->doSomething();

    // 移动 unique_ptr，将所有权转移给另一个 unique_ptr
    std::unique_ptr<MyClass> uniquePtr2 = std::move(uniquePtr1);

    // 此时 uniquePtr1 不再拥有对象的所有权，不能再使用它
    if (uniquePtr1 == nullptr) {
        std::cout << "uniquePtr1 is no longer the owner" << std::endl;
    }

    // 通过 uniquePtr2 来调用对象的方法
    if (uniquePtr2) {
        uniquePtr2->doSomething();
    }

    return 0;
}

std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr。

shared_ptr的原理是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

1. shared_ptr在其内部，给每个资源都维护了一份计数，用来记录该份资源被几个对象共享。
2. 在对象被销毁时（也就是析构函数调用），就说明自己不使用该资源了，对象的引用计数减1。
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

std::shared_ptr的使用方法

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource created" << std::endl; }
    ~Resource() { std::cout << "Resource destroyed" << std::endl; }
    void use() { std::cout << "Using Resource" << std::endl; }
};

int main() {
    // 创建一个 shared_ptr 来管理 Resource 对象
    std::shared_ptr<Resource> sharedPtr1 = std::make_shared<Resource>();

    // 共享指针的使用
    sharedPtr1->use();

    // 创建另一个 shared_ptr 共享相同的资源
    std::shared_ptr<Resource> sharedPtr2 = sharedPtr1;

    // 再次使用资源
    sharedPtr2->use();

    // 输出当前的引用计数
    std::cout << "Reference count: " << sharedPtr1.use_count() << std::endl;

    return 0;
}

std::shared_ptr的简单模拟实现

以下是一个简化模拟实现的shared_ptr类：

#include <functional>

namespace myptr
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		template<class D>
		shared_ptr(T* ptr,D del)
			: _ptr(ptr)
			, _pcount(new int(1))
			,_del(del)
		{}

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(*_pcount);
		}

		void release()
		{
			if (--(*_pcount) == 0)
			{
				//delete _ptr;
				_del(_ptr);
				delete _pcount;
				_ptr = nullptr;
				_pcount = nullptr;
			}
		}

		shared_ptr<T> operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				//不建议这么用
				//this->~shared_ptr();
				release();

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

			return *this;
		}

		~shared_ptr()
		{
			release();
		}

		T* get() const
		{
			return _ptr;
		}

		int use_count() const
		{
			return *_pcount;
		}

		T& operator*() { return *_ptr; }
		T* operator->() { return _ptr; }
	private:
		T* _ptr;
		int* _pcount;
		function<void(T* ptr)> _del = [](T* ptr){delete ptr; };
	};

	private:
		T* _ptr = nullptr;
	};
}

四、std::weak_ptr

循环引用

#include <iostream>
#include <memory>

class A; // 前向声明

class B {
public:
    std::shared_ptr<A> aPtr;
};

class A {
public:
    std::shared_ptr<B> bPtr;
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->bPtr = b; // A 中的智能指针指向 B
    b->aPtr = a; // B 中的智能指针指向 A

    // 此时，a 和 b 相互引用，形成循环引用，导致它们的引用计数都为 2，无法自动释放内存
    return 0;
}

首先，在main函数中，我们创建了两个shared_ptr智能指针a和b，分别指向A和B类的对象。
然后，我们将a对象中的bPtr智能指针指向b对象，同时将b对象中的aPtr智能指针指向a对象。这样就形成了一个循环引用，a和b相互引用对方。
由于shared_ptr通过引用计数来管理对象的生命周期，当有多个shared_ptr指向同一个对象时，引用计数会增加；当shared_ptr被销毁或重新赋值时，引用计数会减少。只有当引用计数为 0 时，对象才会被自动释放。
在这个例子中，由于a和b相互引用，所以它们的引用计数始终为 2，不会变为 0，导致它们所指向的对象无法被自动释放，从而造成内存泄漏。

std::weak_ptr

那么就引出了std::weak_ptr来解决shared_ptr的循环引用的问题

std::weak_ptr用于解决std::shared_ptr可能导致的循环引用问题，它不参与资源的所有权管理，只是对std::shared_ptr管理的资源进行弱引用观察。

当std::shared_ptr对象的引用计数变为0时，std::weak_ptr对象可以通过lock()函数获取一个有效的std::shared_ptr对象，从而访问资源。如果资源已经被释放，lock()函数将返回一个空的std::shared_ptr对象。

std::shared_ptr和std::weak_ptr的使用示例：

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource created" << std::endl; }
    ~Resource() { std::cout << "Resource destroyed" << std::endl; }
    void use() { std::cout << "Using Resource" << std::endl; }
};

int main() {
    // 创建一个 shared_ptr 来管理 Resource 对象
    std::shared_ptr<Resource> sharedRes1 = std::make_shared<Resource>();

    // 创建一个 weak_ptr 来观察 shared_ptr 管理的资源
    std::weak_ptr<Resource> weakRes1(sharedRes1);

    // 通过 weak_ptr 获取 shared_ptr，并使用资源
    if (auto sharedRes2 = weakRes1.lock()) {
        sharedRes2->use();
    } else {
        std::cout << "Resource no longer available" << std::endl;
    }

    // 减少一个 shared_ptr 的引用计数
    sharedRes1 = nullptr;

    // 再次尝试通过 weak_ptr 获取 shared_ptr
    if (auto sharedRes3 = weakRes1.lock()) {
        sharedRes3->use();
    } else {
        std::cout << "Resource no longer available" << std::endl;
    }

    return 0;
}