指针，引用和智能指针

最新推荐文章于 2024-07-16 20:31:39 发布

三驴蛋蛋

最新推荐文章于 2024-07-16 20:31:39 发布

阅读量437

点赞数

分类专栏： c++ 文章标签： c++

本文链接：https://blog.csdn.net/weixin_38587462/article/details/129624438

版权

c++ 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

什么时候使用指针，引用，智能指针

在C++中，指针、引用和智能指针是三种不同的机制，用于在程序中处理和传递内存地址。它们都有不同的适用场景和用法。

指针：指针是一个变量，它存储了一个对象的内存地址。指针可以通过解引用操作符（*）来访问其所指向的对象。指针通常用于动态分配内存、处理数组和访问动态分配的结构体或类对象。
引用：引用是一个别名，它是一个已经存在的对象的别名。引用本身并不占用内存空间，而是指向已经存在的变量或对象的内存地址。引用通常用于函数参数的传递，以及在函数内部对变量或对象进行修改。
智能指针：智能指针是一个包装了原始指针的对象，它可以自动释放动态分配的内存空间，以避免内存泄漏。C++11引入了两种智能指针：shared_ptr和unique_ptr。shared_ptr可以在多个指针之间共享一个对象，并在最后一个指针离开作用域时自动释放内存。unique_ptr是一种独占所有权的指针，它可以确保只有一个指针可以访问一个对象，并在指针离开作用域时自动释放内存。

因此，当需要使用指向动态分配内存的对象时，应该使用指针。当需要对函数参数进行修改或者需要使用已存在对象的别名时，应该使用引用。当需要自动释放内存时，可以使用智能指针，其中shared_ptr用于多个指针之间共享内存，而unique_ptr用于独占所有权的内存。

unique_ptr怎么使用

unique_ptr是一种智能指针，它独占一个对象的所有权并在它离开作用域时自动释放它。在C++11及以后的版本中，unique_ptr成为了管理动态内存的首选智能指针，因为它更加轻量、简单且安全。

下面是一个例子，演示了unique_ptr的使用：

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> p(new int(42));  // 创建一个unique_ptr，指向一个int值为42的对象
    std::cout << *p << std::endl;         // 输出42
    *p = 24;                             // 修改对象的值
    std::cout << *p << std::endl;         // 输出24
    return 0;
}  // 在p离开作用域时，它所指向的内存会自动释放

在上面的例子中，我们使用unique_ptr来动态分配一个int对象，并对其进行访问和修改。当unique_ptr对象p离开作用域时，它所指向的内存会自动释放，这样可以避免内存泄漏。

使用unique_ptr的好处在于它可以确保只有一个指针可以访问动态分配的内存。这样就可以避免在程序中出现多个指针指向同一个内存块，从而导致多个指针释放同一个内存块的问题。因此，当需要动态分配内存并保证只有一个指针可以访问该内存块时，应该使用unique_ptr。

share_ptr怎么使用

shared_ptr是C++中另一种智能指针，它可以共享一个对象的所有权，即多个指针可以指向同一个对象，当最后一个指针离开作用域时，该对象的内存会被自动释放。shared_ptr在多线程环境下使用也比较方便。

下面是一个简单的使用shared_ptr的例子：

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> p1(new int(42)); // 创建一个shared_ptr，指向一个int值为42的对象
    std::cout << *p1 << std::endl;        // 输出42
    std::shared_ptr<int> p2 = p1;        // 复制p1，p1和p2现在指向同一个对象
    std::cout << *p2 << std::endl;        // 输出42
    *p1 = 24;                            // 修改对象的值
    std::cout << *p2 << std::endl;        // 输出24
    return 0;
}  // 在最后一个指向对象的shared_ptr离开作用域时，对象的内存会自动释放

在上面的例子中，我们使用shared_ptr来动态分配一个int对象，并对其进行访问和修改。我们还复制了shared_ptr，使得两个指针指向同一个对象。当最后一个指向对象的shared_ptr离开作用域时，对象的内存会自动释放，这样可以避免内存泄漏。

使用shared_ptr的好处在于可以避免内存泄漏，同时可以方便地共享一个对象的所有权，这在一些场景下非常有用。例如，在一个类中，如果需要一个成员变量可以被多个对象访问并且需要确保在最后一个对象离开作用域时自动释放内存，可以使用shared_ptr来管理该成员变量的内存。

weak_ptr使用方式

weak_ptr 是 C++11 引入的一种智能指针，它可以解决 C++ 中的循环引用问题。与 shared_ptr 不同，weak_ptr 不会增加所指向对象的引用计数，它只是提供了一种安全的访问被 shared_ptr 管理的对象的方式，而不会导致对象的引用计数增加，从而不会影响对象的生命周期。

在异步请求中，通常会使用 shared_ptr 管理一个请求对象，并将该对象传递给异步回调函数。如果回调函数是在请求对象销毁之后才被调用，那么就会出现访问已经被销毁的对象的情况，这可能导致程序崩溃。为了解决这个问题，可以使用 weak_ptr 来传递请求对象的引用，并在回调函数中使用 lock 方法来获取对该对象的 shared_ptr 引用。

下面是一个示例代码：

#include <iostream>
#include <memory>
#include <chrono>
#include <thread>

class Request {
public:
    Request(std::weak_ptr<int> wp) : wp_(wp) {}

    void process() {
        std::cout << "Processing request..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));

        // 通过weak_ptr获取共享的对象
        if (auto shared_ptr = wp_.lock()) {
            std::cout << "Request processed. Shared value: " << *shared_ptr << std::endl;
        } else {
            std::cout << "Request processed. But the shared value has been deleted." << std::endl;
        }
    }

private:
    std::weak_ptr<int> wp_;
};

int main() {
    auto shared_ptr = std::make_shared<int>(42);

    Request req(shared_ptr);

    // 启动一个异步线程处理请求
    std::thread t([&req]() { req.process(); });

    // 等待线程结束
    t.join();

    // 手动释放shared_ptr
    shared_ptr.reset();

    return 0;
}

在这个例子中，我们创建了一个Request类，它需要访问一个由std::shared_ptr管理的对象。我们使用std::weak_ptr作为Request的构造函数的参数，这样就避免了循环引用的问题，因为Request对象不会持有std::shared_ptr指向的对象的所有权。

在Request的process()函数中，我们首先等待1秒钟，模拟请求的处理时间。然后，我们使用std::weak_ptr的lock()方法尝试获取共享的对象的指针。如果对象还存在，则可以访问它，否则就意味着对象已经被释放了。

在main()函数中，我们创建了一个std::shared_ptr指向整数值42，并将它传递给Request的构造函数。然后，我们启动一个异步线程来处理请求，并等待线程结束。最后，我们手动释放std::shared_ptr，这样它就不再引用对象了。如果在Request的处理过程中，我们尝试访问这个对象，由于它已经被释放，std::weak_ptr的lock()方法将返回一个空指针，我们就可以检测到对象已经不存在的情况。