请使用C加加实现SPSC

SPSC (Single Producer Single Consumer) 是一种并发编程模型，其中一个线程作为生产者将数据放入队列，另一个线程作为消费者从队列中取出数据。以下是使用 C++11 标准库中的原子操作和条件变量实现的 SPSC 队列。

#include <atomic>
#include <condition_variable>
#include <mutex>

template <typename T>
class SPSCQueue {
public:
    SPSCQueue() : head_(new Node), tail_(head_.load()) {}

    ~SPSCQueue() {
        while (Node* const old_head = head_) {
            head_ = old_head->next_;
            delete old_head;
        }
    }

    void push(const T& value) {
        Node* const new_node = new Node(value);
        tail_->next_ = new_node;
        tail_ = new_node;
        std::unique_lock<std::mutex> lock(mutex_);
        ++num_items_;
        lock.unlock();
        cv_.notify_one();
    }

    bool pop(T& value) {
        std::unique_lock<std::mutex> lock(mutex_);
        cv_.wait(lock, [this] { return num_items_ > 0; });
        Node* const old_head = head_;
        head_ = old_head->next_;
        value = old_head->value_;
        --num_items_;
        lock.unlock();
        delete old_head;
        return true;
    }

private:
    struct Node {
        Node() : next_(nullptr) {}
        Node(const T& value) : value_(value), next_(nullptr) {}

        T value_;
        Node* next_;
    };

    std::atomic<Node*> head_;
    std::atomic<Node*> tail_;
    std::atomic<int> num_items_{0};
    std::mutex mutex_;
    std::condition_variable cv_;

    SPSCQueue(const SPSCQueue&) = delete;
    SPSCQueue& operator=(const SPSCQueue&) = delete;
};

在上述实现中，使用 `std::atomic` 模板定义了原子类型的头尾指针和计数器，保证了多线程情况下对它们的操作是原子的。同时使用 `std::mutex` 和 `std::condition_variable` 实现了线程安全的生产者-消费者模型，其中消费者线程在队列为空时等待，生产者线程在向队列中添加元素时通知消费者线程。