《 C++ 容器全景指南：四 》实现媲美 C++ 标准库的 stack 和 queue 容器 —— 模板、动态扩容、迭代器与线程安全详解

1、引言

容器类是C++标准库的重要组成部分，而stack与queue作为两种经典的容器类型，在各类应用中广泛使用。stack提供了后进先出（LIFO）的数据存取方式，queue则使用先进先出（FIFO）原则。标准库中提供了现成的stack与queue实现，然而，出于学习和扩展的目的，学习自行实现这些容器，不仅有助于深入理解其工作原理，更好地理解内存管理、模板元编程和迭代器机制，还能让我们在遇到性能瓶颈时进行更灵活的调整。

2、背景与需求分析

2.1、标准库的 stack 与 queue 适配器

为什么要重新实现标准库中的stack与queue？首先是为了更深入地理解其工作原理。

C++ 标准库的 stack 和 queue 都是基于其他容器的适配器模式（Adapter）。默认情况下，它们是基于 deque 容器实现的，也可以使用 vector 或 list 来作为底层存储结构。但标准库中这两种容器隐藏了大部分底层实现细节，用户无法控制它们的扩展机制或调整内存分配策略。通过自己实现，我们可以控制容器的内存管理、扩容策略，并为其添加更多高级特性，如线程安全支持。

同时，手写容器可以帮助我们在实际项目中更加灵活地应用和优化数据结构。因此，自己实现这些容器是了解其工作原理并灵活调整性能的必要步骤。

通过这种方式，我们能够：

1. 提升对数据结构的理解：通过从零实现容器，深入理解栈和队列的内部工作原理。
2. 增强代码设计能力：考虑内存管理、接口设计、性能优化等多个方面，提高编写高质量代码的能力。
3. 为实际开发做准备：掌握标准库容器的实现原理，有助于在实际开发中做出优化和调整。

2.2、性能需求

我们的目标是实现性能高效、易于扩展的stack与queue，因此需要关注以下几点：

• 时间复杂度：保证常用操作（如push、pop、enqueue、dequeue）的时间复杂度为O(1)或O(1)摊还时间复杂度。
• 空间复杂度：动态扩容的空间开销应最小化，且避免频繁分配和释放内存。
• 迭代器支持：需要提供正向和逆向迭代器，以便用户方便地进行数据遍历。
• 线程安全：考虑在并发场景下的安全性，探讨如何实现锁或无锁的栈与队列。

3、栈的实现 (stack)

3.1、数据结构与设计

栈是一种“后进先出”（LIFO）的数据结构，其实现的核心是维护一个动态扩展的数组。我们采用动态数组来存储栈中的元素，并在容量不足时进行扩容。为了通用化，栈的实现需要支持模板，允许用户存储任意类型的元素。我们将使用一个动态数组（类似于 std::vector）来存储元素。核心操作包括 push、pop 和 top。

template <typename T>
class Stack {
private:
    T* data;
    size_t capacity;
    size_t size;

    void resize() {
        capacity *= 2;
        T* newData = new T[capacity];
        for (size_t i = 0; i < size; ++i) {
            newData[i] = data[i];
        }
        delete[] data;
        data = newData;
    }

public:
    Stack() : data(new T[2]), capacity(2), size(0) {}

    void push(const T& value) {
        if (size == capacity) {
            resize();
        }
        data[size++] = value;
    }

    void pop() {
        if (size > 0) {
            --size;
        }
    }

    T& top() {
        return data[size - 1];
    }

    bool empty() const {
        return size == 0;
    }

    size_t size() const {
        return size;
    }

    ~Stack() {
        delete[] data;
    }
};

代码解释：

• resize 函数：在栈容量不足时，resize 通过倍增容量来动态扩容。
• push 操作：将元素压入栈顶，当容量不足时自动扩容。
• pop 操作：从栈顶弹出元素。
• top 操作：返回栈顶元素的引用。
• empty 函数：检查栈是否为空。
• size 函数：获取栈的当前元素数量。

3.2、动态扩容的内存管理

在设计栈的动态扩容机制时，我们采用倍增策略，即当栈容量不足时，将现有容量翻倍。倍增策略有助于减少频繁的内存重新分配，从而摊还时间复杂度为 O(1)。同时，在每次扩容时，我们需要将旧数组中的元素复制到新分配的内存区域。

void resize() 
{
    capacity *= 2;
    T* newData = new T[capacity];
    for (size_t i = 0; i < size; ++i) {
    	newData[i] = data[i];
    }
    delete[] data;
    data = newData;
}

3.3、迭代器设计

栈本质上是线性存储的，因此可以轻松实现STL风格的迭代器。我们提供begin()和end()函数，以支持从栈底到栈顶的正向迭代。为了更加灵活，我们还可以添加逆向迭代器的支持。

template <typename T>
class Stack {
public:
    class Iterator {
    private:
        T* ptr;
    public:
        Iterator(T* p) : ptr(p) {}
        Iterator& operator++() { ++ptr; return *this; }
        T& operator*() { return *ptr; }
        bool operator!=(const Iterator& other) const { return ptr != other.ptr; }
    };

    Iterator begin() { return Iterator(data); }
    Iterator end() { return Iterator(data + size); }
};

为了支持双向迭代，我们还可以实现reverse_iterator，用于从栈顶向栈底遍历元素。

4、队列的实现 (queue)

4.1、数据结构与设计

队列是一种“先进先出”（FIFO）的数据结构。在我们的实现中，需要一个动态数组，并维护两个索引——front和back，分别表示队列的头部和尾部。与栈相似，我们使用动态数组来存储队列中的元素，并根据需要进行扩容。由于队列中的元素是循环管理的（即头尾可能绕过数组的边界），我们还需要实现 “环形缓冲区” 策略，以便最大化利用数组空间。

template <typename T>
class Queue {
private:
    T* data;
    size_t capacity;
    size_t size;
    size_t frontIndex;
    size_t backIndex;

    void resize() {
        capacity *= 2;
        T* newData = new T[capacity];
        for (size_t i = 0; i < size; ++i) {
            newData[i] = data[(frontIndex + i) % capacity];
        }
        delete[] data;
        data = newData;
        frontIndex = 0;
        backIndex = size;
    }

public:
    Queue() : data(new T[2]), capacity(2), size(0), frontIndex(0), backIndex(0) {}

    void enqueue(const T& value) {
        if (size == capacity) {
            resize();
        }
        data[backIndex] = value;
        backIndex = (backIndex + 1) % capacity;
        ++size;
    }

    void dequeue() {
        if (size > 0) {
            frontIndex = (frontIndex + 1) % capacity;
            --size;
        }
    }

    T& front() {
        return data[frontIndex];
    }

    bool empty() const {
        return size == 0;
    }

    size_t size() const {
        return size;
    }

    ~Queue() {
        delete[] data;
    }
    
    // 迭代器支持
    typedef T* iterator;
    iterator begin();              // 返回指向队列头部的迭代器
    iterator end();                // 返回指向队列尾部的迭代器
};

代码解释：

• resize 函数：当队列容量不足时，进行扩容，并重新调整队列元素的顺序。
• enqueue 操作：将元素加入队列尾部，必要时扩容。
• dequeue 操作：移除队列首部元素。
• front 操作：返回队列首元素的引用。
• empty 函数：检查队列是否为空。
• size 函数：返回队列中元素的数量。

4.2、环形缓冲区与动态扩容

环形缓冲区的设计可以有效避免在频繁的enqueue与dequeue操作后出现大量空闲的空间浪费。在实现环形缓冲区时，我们使用模运算来管理 front 与 back 索引的循环。与此同时，当队列容量不足时，我们仍然使用倍增策略来进行扩容。

在扩容时，由于 front 和 back 可能并不连续，我们需要将队列中的元素按照正确的顺序重新排列到新的内存区域中。

4.3、迭代器设计

与栈类似，我们为队列也提供正向迭代器begin()和end()，方便用户遍历队列中的元素。与栈不同的是，由于队列元素是环形存储的，我们需要在迭代过程中考虑front和back的环绕关系。

template<typename T>
typename Queue<T>::iterator Queue<T>::begin() {
    return data + front;
}

template<typename T>
typename Queue<T>::iterator Queue<T>::end() {
    return data + back;
}

5、性能与复杂度分析

5.1、栈的时间与空间复杂度

• push 操作：在扩容前，push操作的时间复杂度为 O(1)。扩容时，resize操作的时间复杂度为O(n)，其中n为栈中的元素数量。然而，使用摊还分析法，push操作的平均时间复杂度为O(1)。
• pop 操作：移除栈顶元素的操作时间复杂度为O(1)。
• 空间复杂度：栈的空间复杂度取决于元素数量与扩容策略，通常为 O(n)，其中 n 为栈中的元素数量。

5.2、队列的时间与空间复杂度

• enqueue操作：正常情况下为O(1)，扩容时为O(n)，但摊还时间复杂度为O(1)。
• dequeue操作：移除队列头部元素的时间复杂度为O(1)。
• 空间复杂度：类似于栈，队列的空间复杂度为O(n)。

6、线程安全与并发设计

为了让栈与队列在多线程环境下安全使用，我们可以使用C++标准库中的互斥锁std::mutex来保护关键操作。例如，在push和pop操作中加锁，确保只有一个线程能够同时修改栈或队列。以下是为栈添加线程安全支持的示例代码：

template<typename T>
class ThreadSafeStack {
private:
    Stack<T> stack;
    std::mutex mtx;

public:
    void push(const T& value) {
        std::lock_guard<std::mutex> lock(mtx);
        stack.push(value);
    }

    void pop() {
        std::lock_guard<std::mutex> lock(mtx);
        stack.pop();
    }

    T& top() {
        std::lock_guard<std::mutex> lock(mtx);
        return stack.top();
    }
};

对于更高级的并发设计，我们可以考虑无锁数据结构（Lock-Free Data Structure）或使用条件变量来减少线程等待的时间。

7、结论与未来展望

通过本篇从设计、实现到性能优化，详细探讨了如何构建支持动态扩容、模板化和迭代器的stack与queue容器。通过深入分析这些容器的数据结构、算法原理和复杂度，我们不仅掌握了其基本实现，还探讨了如何在多线程环境下保证线程安全。这样的实现为读者提供了对C++标准库容器的深刻理解，并为实际开发中的性能优化提供了良好的实践基础。未来，我们可以继续扩展这些容器的功能，如支持持久化存储、与其他容器的交互等，以适应更多应用场景。

希望这篇博客对您有所帮助，也欢迎您在此基础上进行更多的探索和改进。如果您有任何问题或建议，欢迎在评论区留言，我们可以共同探讨和学习。更多知识分享可以访问我的个人博客网站 ： https://blog.lenyiin.com/ 。