C++中的智能指针

最新推荐文章于 2024-03-27 21:36:52 发布

想变成自大狂

最新推荐文章于 2024-03-27 21:36:52 发布

阅读量293

点赞数 1

分类专栏： # C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_55752775/article/details/131383116

版权

C++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

RAII

shared_ptr

unique_ptr

shared_ptr和unique_ptr的模拟实现

循环引用

在C++编程中，动态分配的内存和其他资源管理是一个重要的问题。手动管理这些资源存在一定的风险和复杂性。为了解决这个问题，C++引入了智能指针的概念，它能够提供更安全、更高效的资源管理方式。
智能指针是一个C++类模板，用于管理动态分配的资源，如堆内存、文件句柄等。它通过在对象生命周期结束时自动释放资源，避免了内存泄漏和资源泄漏的风险。与常规的原始指针相比，智能指针提供了一层封装，使资源的管理更加方便和安全。

RAII

RAII（Resource Acquisition Is Initialization）是一种编程技术和设计模式，用于管理资源的获取和释放。它基于C++的对象生命周期管理特性，通过将资源的获取与对象的初始化绑定在一起，可以确保资源在适当的时候被正确释放。

RAII的核心思想是将资源的生命周期与对象的生命周期绑定在一起。当对象被创建时，它负责获取所需的资源，并在析构阶段释放这些资源。这样可以确保资源在对象使用完毕后被正确释放，无论是正常的程序流程还是异常情况下。

在C++中，RAII通常通过使用析构函数来实现。当对象离开其作用域时，析构函数会自动调用，从而实现资源的自动释放。常见的使用RAII的资源包括动态分配的内存、文件句柄、互斥锁、网络连接等。

下面是一个简单的示例，演示了使用RAII管理动态分配的内存：

class Resource {
public:
    explicit Resource(int size)
        : mData(new int[size]) {
        // 获取资源（动态分配内存）
        // 其他必要的初始化操作
    }
    
    ~Resource() {
        // 释放资源（释放动态分配的内存）
        delete[] mData;
    }
    
    // 其他成员函数和操作
    
private:
    int* mData;
};

void foo() {
    Resource res(100); // RAII：获取资源
    // 使用资源
    // ...
} // RAII：资源在对象离开作用域时自动释放

Resource类封装了一个动态分配的整型数组，并在构造函数中申请内存，在析构函数中释放内存。当Resource对象res离开其作用域时，析构函数被自动调用，从而释放了动态分配的内存。

通过使用RAII，我们可以避免显式调用释放资源的函数、忘记释放资源而导致的内存泄漏等问题。RAII不仅可以提高代码的可靠性和可维护性，还能方便地处理异常情况下的资源释放，使代码更加安全和简洁。

需要注意的是，RAII并不仅限于使用析构函数来管理资源，还可以结合其他语言特性，例如智能指针、容器类等来实现更灵活的资源管理策略。RAII是C++中一种重要的编程范式和设计原则，广泛应用于实际项目中。

shared_ptr

std::shared_ptr是一种允许多个智能指针共享同一个资源的智能指针类型。它使用引用计数的方式来追踪资源的所有者。每次创建新的std::shared_ptr并指向同一个资源时，引用计数会增加1。当std::shared_ptr被析构或重新分配时，引用计数会减少1。只有当引用计数为0时，资源才会自动释放。这种共享所有权的机制使得std::shared_ptr在处理复杂的对象关联情况时非常有用。

#include <memory>

int main() {
    std::shared_ptr<int> sharedPtr1(new int(5));
    std::shared_ptr<int> sharedPtr2 = sharedPtr1; // 共享资源

    // 使用sharedPtr1和sharedPtr2操作资源
    *sharedPtr1 = 10;
    *sharedPtr2 = 15;

    return 0; // 在main函数结束时，资源会自动释放
}

unique_ptr

std::unique_ptr表示对资源的独占所有权。它不允许复制和共享资源，并通过移动操作来转移资源的所有权。使用std::unique_ptr能够使资源的管理更加高效和安全，因为只有一个智能指针拥有资源，并且在该指针被析构时会自动释放资源。

#include <memory>

int main() {
    std::unique_ptr<int> uniquePtr(new int(5));

    // 使用uniquePtr操作资源
    *uniquePtr = 10;

    // 使用std::move转移所有权
    std::unique_ptr<int> anotherUniquePtr = std::move(uniquePtr);

    // 注意：此时uniquePtr已不再指向资源

    return 0; // 在main函数结束时，资源会自动释放
}

智能指针的原理是基于RAII（Resource Acquisition Is Initialization）原则。它利用了C++对象生命周期结束时自动调用析构函数的特性，在智能指针对象的析构函数中执行资源的释放操作。因此，当智能指针超出其作用域或被重新分配时，会自动调用析构函数，从而释放资源。

智能指针通过使用引用计数或独占所有权的方式来管理资源，从而简化了资源的分配和释放过程，并避免了常见的资源管理错误。在使用智能指针时，要注意避免循环引用（特别是std::shared_ptr），以避免造成资源的泄漏。

shared_ptr和unique_ptr的模拟实现

template<typename T>
class SharedPtr {
public:
    explicit SharedPtr(T* ptr = nullptr) : m_ptr(ptr), m_refCount(new int(1)) {}

    SharedPtr(const SharedPtr<T>& other) : m_ptr(other.m_ptr), m_refCount(other.m_refCount) {
        (*m_refCount)++;
    }

    ~SharedPtr() {
        if (--(*m_refCount) == 0) {
            delete m_ptr;
            delete m_refCount;
        }
    }

    SharedPtr<T>& operator=(const SharedPtr<T>& other) {
        if (this != &other) {
            if (--(*m_refCount) == 0) {
                delete m_ptr;
                delete m_refCount;
            }
            m_ptr = other.m_ptr;
            m_refCount = other.m_refCount;
            (*m_refCount)++;
        }
        return *this;
    }

    T* operator->() const { return m_ptr; }

    T& operator*() const { return *m_ptr; }

    int useCount() const { return *m_refCount; }

private:
    T* m_ptr;
    int* m_refCount;
};


template<typename T>
class UniquePtr {
public:
    explicit UniquePtr(T* ptr = nullptr) : m_ptr(ptr) {}

    ~UniquePtr() {
        delete m_ptr;
    }

    UniquePtr(const UniquePtr<T>& other) = delete;

    UniquePtr<T>& operator=(const UniquePtr<T>& other) = delete;

    UniquePtr(UniquePtr<T>&& other) noexcept : m_ptr(other.m_ptr) {
        other.m_ptr = nullptr;
    }

    UniquePtr<T>& operator=(UniquePtr<T>&& other) noexcept {
        if (this != &other) {
            delete m_ptr;
            m_ptr = other.m_ptr;
            other.m_ptr = nullptr;
        }
        return *this;
    }

    T* operator->() const { return m_ptr; }

    T& operator*() const { return *m_ptr; }

private:
    T* m_ptr;
};

上述代码中，SharedPtr是一个模拟的std::shared_ptr的实现，使用引用计数来跟踪资源的共享情况。在每个SharedPtr对象中，我们有一个指向资源的指针m_ptr，以及一个指向引用计数的指针m_refCount。当创建新的SharedPtr对象时，我们会给引用计数分配一个新的整型对象并设置为1。每当有一个新的SharedPtr指向相同的资源时，引用计数会增加1。在SharedPtr对象的析构函数中，我们会递减引用计数并在计数变为0时释放资源。

UniquePtr是一个模拟的std::unique_ptr的实现，它只允许独占资源的所有权。在每个UniquePtr对象中，我们有一个指向资源的指针m_ptr。当创建新的UniquePtr对象时，我们将资源的指针赋值给m_ptr。在UniquePtr对象的析构函数中，我们会释放资源。

weak_ptr是一种智能指针，用于解决循环引用问题。它可以与shared_ptr配合使用，允许访问由shared_ptr管理的对象，而不会增加对象的引用计数。

下面是一个简化的weak_ptr的模拟实现:

template<typename T>
class shared_ptr;  // 前向声明 shared_ptr

template<typename T>
class weak_ptr {
private:
    T* m_ptr;
    int* m_refCount;
    
public:
    weak_ptr()
        : m_ptr(nullptr), m_refCount(nullptr) {}
    
    weak_ptr(const shared_ptr<T>& shared)
        : m_ptr(shared.m_ptr), m_refCount(shared.m_refCount) {
        // 在 shared_ptr 的引用计数上加一
        if (m_refCount) {
            (*m_refCount)++;
        }
    }
    
    ~weak_ptr() {
        // 在 weak_ptr 的析构函数中减少引用计数
        if (m_refCount && --(*m_refCount) == 0) {
            delete m_ptr;
            delete m_refCount;
        }
    }

    shared_ptr<T> lock() const {
        return shared_ptr<T>(*this);
    }
    
    // 在需要时重载其他操作符，如 operator= 等
    
    friend class shared_ptr<T>;  // 允许 shared_ptr 访问 weak_ptr 的私有成员
};

在上述代码中，我们首先进行了shared_ptr的前向声明，并定义了weak_ptr类。weak_ptr类内部包含了指向T类型对象的原始指针m_ptr和一个整型指针m_refCount，用于存储引用计数。

weak_ptr类的构造函数接受一个shared_ptr作为参数，并从中获取资源的指针和引用计数。构造函数将引用计数加一，以保持引用计数的一致性。

weak_ptr类的析构函数会递减引用计数，如果引用计数变为零，则释放资源。

lock()函数返回一个shared_ptr，它与当前的weak_ptr共享相同的资源。如果资源仍然有效（即引用计数大于零），那么shared_ptr将继续增加引用计数。否则，返回一个空的shared_ptr。

以上是一个简单的模拟实现，它提供了weak_ptr的基本功能，包括构造、析构和lock()函数。在实际使用中，还可以根据需要重载其他操作符，如operator=等，以提供更多的功能。

循环引用

智能指针中的循环引用是指两个或多个智能指针彼此持有对方的资源，导致资源无法正常释放的情况。这种情况下，资源的引用计数永远不会降为零，从而导致内存泄漏。

循环引用常见于使用共享指针（如std::shared_ptr）的情况下。当两个对象相互引用，并且使用共享指针进行管理时，若没有适当地打破循环引用关系，资源将无法释放。

class Node {
public:
    Node() { cout << "Node constructor" << endl; }
    ~Node() { cout << "Node destructor" << endl; }

    SharedPtr<Node> m_next;
};

int main() {
    SharedPtr<Node> node1(new Node());
    SharedPtr<Node> node2(new Node());
    
    node1->m_next = node2;
    node2->m_next = node1;

    return 0;
}

我们有两个Node对象node1和node2，它们彼此持有对方的资源。这种循环引用在释放资源时会发生问题，因为两个节点的引用计数永远不会降为零，导致资源泄漏。当程序执行完毕时，由于循环引用导致资源无法正常释放，没有打印任何析构函数的输出。

为了解决循环引用问题，可以使用弱引用（如std::weak_ptr）或者手动打破循环引用关系，使得资源能够正确释放。弱引用允许获取一个指向资源的临时引用，而不会增加引用计数。通过使用弱引用，可以避免循环引用并且在需要时访问资源。

class Node {
public:
    Node() { cout << "Node constructor" << endl; }
    ~Node() { cout << "Node destructor" << endl; }

    SharedPtr<Node> m_next;
    WeakPtr<Node> m_weakNext; // 引入弱引用
};

int main() {
    SharedPtr<Node> node1(new Node());
    SharedPtr<Node> node2(new Node());
    
    node1->m_next = node2;
    node2->m_weakNext = node1; // 使用弱引用替代共享指针

    return 0;
}

我们将m_next成员改为了SharedPtr<Node>，同时引入了m_weakNext用作弱引用。这样，循环引用被打破，资源可以得到正确释放。

总结来说，循环引用是智能指针使用中需要注意的问题。为了避免循环引用导致的资源泄漏，可以使用弱引用、适时打破循环引用关系或者使用其他技术来管理资源。

总结：智能指针提供了更安全和高效的资源管理方式，通过对象的生命周期来自动释放资源。使用std::shared_ptr实现资源的共享，使用std::unique_ptr实现资源的独占所有权。合理使用智能指针能提高C++程序的稳定性和可读性。

智能指针是一种用于自动管理动态分配的内存的对象。它们提供了一种更安全、更方便的方式来管理资源，特别是动态分配的内存，以避免内存泄露和悬挂指针等问题。智能指针的发展历史可以追溯到早期的C++标准，并逐步演变到现在的C++17和后续版本。

早期C++标准库并未提供内置的智能指针类型。然而，C++98标准引入了auto_ptr，它是第一个类似智能指针的类模板。auto_ptr允许所有权的转移，即在对象析构时自动释放资源。然而，由于其不完善的设计和使用方式的限制，auto_ptr很快在C++11标准中被废弃。

C++11标准引入了新的智能指针机制，包括shared_ptr、unique_ptr和weak_ptr。这些智能指针提供了更丰富的功能和更安全的资源管理方式。

shared_ptr是一种引用计数智能指针，它可以跟踪对象有多少个shared_ptr共享它。只有当所有的shared_ptr都析构时，才会自动释放对象。这种智能指针可以解决传统裸指针容易出现的悬挂指针和多次删除等问题。

unique_ptr是一种独占所有权的智能指针，它不使用引用计数，而是确保只有一个指针可以指向资源。当unique_ptr超出范围或者被显式地释放时，它会自动释放资源。这种智能指针提供了高效的资源管理，可以避免资源的重复释放和多线程竞争等问题。

weak_ptr是一种弱引用智能指针，它允许观察一个由shared_ptr管理的对象，但不会增加对象的引用计数。这可以解决循环引用的问题。

C++17进一步扩展了智能指针的功能，引入了shared_ptr的make_shared函数和weak_ptr的lock函数，提供了更便捷和安全的使用方式。

此外，许多第三方库和框架也提供了自己的智能指针实现，如Boost库中的智能指针模块。

总体而言，智能指针的发展历史是逐渐从早期的简单实现（如auto_ptr）演变到现在更为完善、功能丰富的标准智能指针（如shared_ptr、unique_ptr和weak_ptr）。这些智能指针提供了更安全、更高效的资源管理方式，成为现代C++开发中的重要工具之一。