请使用C加加CAS实现SPSC

CAS (Compare And Swap) 是一种原子操作，可以保证在多线程环境中对某个共享变量的操作是原子的。以下是使用 CAS 实现的 SPSC 队列。

#include <atomic>

template <typename T>
class SPSCQueue {
public:
    SPSCQueue() : buffer_(new Node), tail_(buffer_.load()), head_(tail_.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);
        Node* const tail = tail_.load();
        while (true) {
            Node* const next = tail->next_.load();
            if (!next) {
                if (tail->next_.compare_exchange_weak(next, new_node)) {
                    break;
                }
            } else {
                tail_.compare_exchange_weak(tail, next);
            }
        }
        tail_.compare_exchange_weak(tail, new_node);
    }

    bool pop(T& value) {
        Node* const head = head_.load();
        while (true) {
            Node* const next = head->next_.load();
            if (!next) {
                return false;
            }
            if (head_.compare_exchange_weak(head, next)) {
                value = next->value_;
                delete head;
                break;
            }
        }
        return true;
    }

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

        T value_;
        std::atomic<Node*> next_;
    };

    std::atomic<Node*> buffer_;
    std::atomic<Node*> tail_;
    std::atomic<Node*> head_;

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

在上述实现中，使用 `std::atomic` 模板定义了原子类型的头尾指针和节点中的指针，保证了多线程情况下对它们的操作是原子的。同时使用 `while` 循环和 `compare_exchange_weak` 实现了 CAS 操作，保证了在多线程环境下对队列的操作是原子的。