C++11中的std::shared_ptr与C++17中的std::optional 比较

本文链接：https://blog.youkuaiyun.com/scoone/article/details/143564779

摘要：本文将探讨C++11引入的智能指针std::shared_ptr与C++17引入的std::optional之间的差异，并分析它们在实践中的应用场景。我们将从功能、性能和设计哲学三个方面进行比较，帮助读者更好地理解这两种工具的使用时机和优势。

正文：

引言 C++作为一门多范式编程语言，不断地在标准库中添加新的特性以适应现代软件开发的需求。C++11和C++17标准分别为这门语言带来了许多革命性的改进。在这两个标准中，std::shared_ptr和std::optional是两个特别重要的特性，它们在处理资源管理和可选值方面提供了强大的工具。

一、std::shared_ptr：智能指针的共享所有权

std::shared_ptr是C++11中引入的一个智能指针，用于自动管理资源，特别是动态分配的内存。以下是其主要特点：

共享所有权：多个shared_ptr可以指向同一个对象，并共享对该对象的所有权。只有当最后一个shared_ptr被销毁或重置时，对象才会被销毁。
自动资源管理：通过引用计数机制，std::shared_ptr确保了对象在不再需要时自动释放资源，从而防止内存泄漏。
接口丰富：std::shared_ptr提供了与原始指针相似的接口，包括解引用、成员访问运算符、比较运算符等。

用例：

管理动态分配的内存，避免手动管理内存带来的风险。
在容器中存储指针，而无需担心对象生命周期问题。
实现共享资源，如线程池或缓存。

二、std::optional：可选值的优雅处理

std::optional是C++17中引入的一个容器，它可以包含一个值或者不包含任何值。以下是其主要特点：

表示空值：std::optional可以用来表示一个可能不存在的值，而不需要使用特殊的错误码或指针。
简洁的接口：std::optional提供了值的存在性检查（通过has_value()方法）和值访问（通过value()或*运算符）。
类型安全：与使用指针或特殊值表示空值相比，std::optional提供了更强的类型安全性。

用例：

返回函数的结果，其中结果可能不存在。
代替可能抛出异常的操作，提供更可控的错误处理。
在数据结构中存储可选字段，而不需要额外的标记。

三、比较与选择

功能：

std::shared_ptr主要用于资源管理，特别是内存管理。
std::optional用于表示可选值，为空值处理提供了一种更清晰、类型安全的方式。

性能：

std::shared_ptr由于引用计数机制，可能会引入额外的性能开销。
std::optional可能会增加内存使用，因为它需要额外的空间来存储值的存在性信息。

设计哲学：

std::shared_ptr鼓励使用RAII（Resource Acquisition Is Initialization）原则，自动管理资源。
std::optional鼓励显式处理可能不存在的值，提高代码的可读性和安全性。

std::shared_ptr和std::optional都是C++标准库中非常有用的工具，但它们适用于不同的场景。std::shared_ptr是资源管理的瑞士军刀，而std::optional则是对可选值处理的优雅解决方案。了解它们的特点和用例可以帮助开发者编写更安全、更高效、更易于维护的C++代码。随着C++语言的发展，我们可以期待更多强大的特性加入到标准库中，以进一步提高我们的编程效率。

以下为线程安全的队列实现：

C++11

#include <mutex>
#include <deque>
#include <condition_variable>
#include <memory>

template<typename T>
class ThreadSafeQueue {
private:
    std::deque<T> queue;
    mutable std::mutex mtx;
    std::condition_variable cond_var;

public:
    ThreadSafeQueue() {}

    void enqueue(const T& item) {
        std::lock_guard<std::mutex> lock(mtx);
        queue.push_back(item);
        cond_var.notify_one();
    }

    std::shared_ptr<T> dequeue() {
        std::unique_lock<std::mutex> lock(mtx);
        cond_var.wait(lock, [this] { return !queue.empty(); });

        if (queue.empty()) {
            return std::shared_ptr<T>(); // Return an empty shared_ptr
        }

        std::shared_ptr<T> item_ptr(new T(queue.front())); // Use shared_ptr to hold the item
        queue.pop_front();
        return item_ptr;
    }

    bool empty() const {
        std::lock_guard<std::mutex> lock(mtx);
        return queue.empty();
    }

    void clear() {
        std::lock_guard<std::mutex> lock(mtx);
        queue.clear();
        cond_var.notify_all(); // Notify all waiting threads
    }
};

C++17

#include <deque>
#include <mutex>
#include <condition_variable>
#include <optional>

template<typename T>
class ThreadSafeQueue {
private:
    std::deque<T> queue;
    mutable std::mutex mtx;
    std::condition_variable cond_var;

public:
    ThreadSafeQueue() {}

    void enqueue(const T& item) {
        std::lock_guard<std::mutex> lock(mtx);
        queue.push_back(item);
        cond_var.notify_one();
    }

    std::optional<T> dequeue() {
        std::unique_lock<std::mutex> lock(mtx);
        cond_var.wait(lock, [this] { return !queue.empty(); });

        if (queue.empty()) {
            return std::nullopt;
        }

        T item = queue.front();
        queue.pop_front();
        return item;
    }

    bool empty() const {
        std::lock_guard<std::mutex> lock(mtx);
        return queue.empty();
    }

        void clear() {
        std::lock_guard<std::mutex> lock(mtx);
        queue.clear();
        cond_var.notify_all(); // 通知所有等待的线程，因为队列状态已改变
    }
};