C++智能指针: 从初学者到高手-优快云博客

本文链接：https://blog.youkuaiyun.com/2401_82808034/article/details/145963733

C++智能指针: 从初学者到高手

引言

在C++中，内存管理一直是开发者最为关心的问题之一。传统的指针使用虽然灵活，但却容易出错，导致内存泄漏、野指针、悬空指针等严重问题。为了解决这些问题，C++11引入了智能指针（Smart Pointers）概念，提供了更加安全和高效的内存管理方式。

智能指针不仅能够自动管理内存，避免了手动释放内存的麻烦，还能够有效地控制资源的生命周期。对于初学者来说，理解智能指针的概念并学会如何使用它们是非常重要的。本文将从初学者到高手的角度，详细介绍C++智能指针的基础、应用以及进阶技巧。

1. 什么是智能指针？

智能指针是C++标准库中用于管理动态分配内存的类模板。与普通指针不同，智能指针会自动管理指针所指向对象的生命周期。智能指针会在作用域结束时自动释放内存，避免了手动调用delete的麻烦，减少了内存泄漏的风险。

C++标准库提供了三种常用的智能指针类型：

std::unique_ptr：独占所有权，每次只有一个指针指向资源，不能被拷贝，只能被移动。
std::shared_ptr：共享所有权，可以有多个指针共同指向同一资源，内部通过引用计数机制来管理资源。
std::weak_ptr：与shared_ptr配合使用，不会增加引用计数，用于避免循环引用问题。

2. `std::unique_ptr`：独占所有权

std::unique_ptr是最简单的智能指针，它管理着一个指针并且在生命周期结束时自动销毁所指向的对象。unique_ptr不允许拷贝操作，只能进行移动操作，这意味着同一时间只有一个unique_ptr指向资源。

基本使用

#include <iostream>
#include <memory>  // 包含智能指针相关头文件

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor\n"; }
    ~MyClass() { std::cout << "MyClass destructor\n"; }

    void sayHello() { std::cout << "Hello from MyClass\n"; }
};

int main() {
    // 创建一个unique_ptr，管理MyClass对象
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();

    // 使用unique_ptr访问对象
    ptr1->sayHello();

    // unique_ptr会在作用域结束时自动销毁对象
    return 0;
}

代码解析：

std::make_unique<MyClass>()：创建一个MyClass对象，并返回一个unique_ptr指向该对象。
ptr1->sayHello()：使用unique_ptr访问对象的方法。
std::unique_ptr会在作用域结束时自动释放内存，无需显式调用delete。

移动语义

由于unique_ptr不允许拷贝，它提供了一个移动语义，允许将一个unique_ptr的所有权转移给另一个unique_ptr。

std::unique_ptr<MyClass> ptr2 = std::move(ptr1);

通过std::move将ptr1的所有权转移给ptr2，此时ptr1变为空指针。

3. `std::shared_ptr`：共享所有权

std::shared_ptr允许多个智能指针共同拥有一个对象。它通过引用计数来管理对象的生命周期，每当一个shared_ptr被创建或复制时，引用计数会增加，当最后一个shared_ptr被销毁时，才会释放内存。

基本使用

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor\n"; }
    ~MyClass() { std::cout << "MyClass destructor\n"; }

    void sayHello() { std::cout << "Hello from MyClass\n"; }
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();  // 创建shared_ptr
    std::shared_ptr<MyClass> ptr2 = ptr1;  // ptr2和ptr1共享所有权

    ptr1->sayHello();
    ptr2->sayHello();

    std::cout << "ptr1 use count: " << ptr1.use_count() << "\n";  // 输出引用计数

    return 0;
}

代码解析：

std::make_shared<MyClass>()：创建一个shared_ptr并初始化。
ptr2 = ptr1：ptr1和ptr2共享对同一个MyClass对象的所有权。引用计数会增加。
ptr1.use_count()：返回当前共享此对象的shared_ptr的数量。

循环引用问题

shared_ptr使用引用计数来管理对象的生命周期，但如果两个shared_ptr互相持有对方的指针，就会形成循环引用，导致对象无法被销毁。为了解决这个问题，C++引入了std::weak_ptr。

4. `std::weak_ptr`：避免循环引用

std::weak_ptr用于打破循环引用，它不会增加引用计数，因此不会影响对象的生命周期。weak_ptr通常与shared_ptr一起使用，weak_ptr可以观察shared_ptr管理的对象，但不会改变对象的生命周期。

基本使用

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor\n"; }
    ~MyClass() { std::cout << "MyClass destructor\n"; }

    void sayHello() { std::cout << "Hello from MyClass\n"; }
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::weak_ptr<MyClass> weakPtr = ptr1;  // 创建weak_ptr，观察ptr1所指向的对象

    std::cout << "ptr1 use count: " << ptr1.use_count() << "\n";  // 输出引用计数

    if (auto sharedPtr = weakPtr.lock()) {  // 尝试提升weak_ptr为shared_ptr
        sharedPtr->sayHello();
    } else {
        std::cout << "Object has been destroyed\n";
    }

    return 0;
}

代码解析：

std::weak_ptr<MyClass> weakPtr = ptr1;：weakPtr不会增加ptr1的引用计数，因此它不会影响对象的生命周期。
weakPtr.lock()：lock方法尝试将weak_ptr提升为shared_ptr，如果目标对象已经被销毁，则返回空指针。

5. 智能指针的高级应用

5.1 自定义删除器

有时，我们需要使用智能指针来管理非堆内存分配的资源（如文件句柄、数据库连接等）。这时，可以使用自定义删除器来指定资源的销毁方式。

示例：使用自定义删除器

#include <iostream>
#include <memory>

class FileDeleter {
public:
    void operator()(FILE* file) const {
        std::cout << "Closing file...\n";
        fclose(file);
    }
};

int main() {
    std::unique_ptr<FILE, FileDeleter> filePtr(fopen("example.txt", "w"));

    if (filePtr) {
        std::cout << "File opened successfully.\n";
    }

    // 文件将在作用域结束时自动关闭
    return 0;
}

在这个示例中，FileDeleter是一个自定义删除器，它在unique_ptr对象销毁时自动关闭文件。

5.2 `shared_ptr`和`unique_ptr`混合使用

尽管shared_ptr和unique_ptr有不同的语义，但有时我们需要将它们混合使用。shared_ptr可以管理一个unique_ptr对象，确保其资源得到正确释放。

示例：`shared_ptr`管理`unique_ptr`

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor\n"; }
    ~MyClass() { std::cout << "MyClass destructor\n"; }
};

int main() {
    std::unique_ptr<MyClass> uniquePtr = std::make_unique<MyClass>();

    // 将unique_ptr转交给shared_ptr
    std::shared_ptr<MyClass> sharedPtr = std::move(uniquePtr);

    // uniquePtr现在为空，sharedPtr管理资源
    return 0;
}

5.3 `make_shared`的使用

std::make_shared是一种高效的方式来创建shared_ptr对象，它避免了分配两次内存（一次用于对象本身，一次用于引用计数）。因此，它比std::shared_ptr构造函数更高效。

示例：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor\n"; }
    ~MyClass() { std::cout << "MyClass destructor\n"; }
};

int main() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();  // 高效创建shared_ptr
    return 0;
}

6. 总结

智能指针是C++现代编程中的重要特性，它帮助开发者更好地管理动态内存和资源。通过使用std::unique_ptr、std::shared_ptr和std::weak_ptr，我们可以避免内存泄漏和资源管理错误，提高程序的安全性和可靠性。掌握智能指针的使用，将使你成为C++的高手，并能写出更高效、可维护的代码。