在C++中使用类模板实现堆栈

在计算机科学中，堆栈是一种常用的数据结构，它具有“先进先出”的特点。在C++中，我们可以使用类模板来实现堆栈。

堆栈的概念

堆栈是一种“后进先出”（LIFO）的数据结构。堆栈有两个基本操作：推入（push）和弹出（pop）。

推入操作将元素添加到堆栈的顶部，而弹出操作将堆栈的顶部元素删除。另外，我们可以使用peek操作来访问堆栈的顶部元素而不删除它。

类模板

在C++中，类模板是一种通用的类定义，可以用来生成具有多种数据类型的类。类模板定义的一般形式如下：

template <class T>
class class_name { ... };

其中，T是一个占位符类型，表示我们将在使用模板时指定的实际类型。在堆栈的情况下，我们需要在类模板中存储一个元素的数组，所以我们将使用泛型类型T*。

堆栈类模板的实现

下面是一个简单的堆栈类模板的实现：

template <class T>
class Stack {
  private:
    T* _data;
    int _size;
    int _capacity;

  public:
    Stack(int capacity) {
        _data = new T[capacity];
        _size = 0;
        _capacity = capacity;
    }

    ~Stack() { delete[] _data; }

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

    int size() const { return _size; }

    void push(T value) {
        if (_size == _capacity) {
            throw std::out_of_range("Stack is full");
        }
        _data[_size++] = value;
    }

    T pop() {
        if (_size == 0) {
            throw std::out_of_range("Stack is empty");
        }
        return _data[--_size];
    }

    T peek() const {
        if (_size == 0) {
            throw std::out_of_range("Stack is empty");
        }
        return _data[_size - 1];
    }
};

在上面的代码中，我们定义了一个堆栈类模板，它的私有成员变量包括一个指向占位符类型T的指针_data，一个整形变量_size存储现在已有元素的个数，一个整形变量_capacity存储堆栈的容量。

构造函数Stack(int capacity)用于初始化堆栈的容量，并对私有成员变量进行赋值。析构函数~Stack()则用于释放内存。

另外，我们还定义了一些公有成员函数，包括：empty(), size(), push(), pop()和peek()。

其中，empty()用于检查堆栈是否为空，size()返回堆栈中已有元素的数量，push()将一个元素推入堆栈的顶部，pop()将堆栈的顶部元素弹出并返回它的值，peek()访问堆栈的顶部元素而不将其删除。

使用堆栈类模板

对于堆栈类模板的使用，我们需要指定实际类型，如下所示：

int main() {
    Stack<int> s(10);

    s.push(1);
    s.push(2);
    s.push(3);

    while (!s.empty()) {
        std::cout << s.pop() << std::endl;
    }

    return 0;
}

在上面的示例中，我们实例化了一个整数类型的堆栈，并向其中推入3个值。然后，我们使用while循环将堆栈中的元素弹出并输出它们的值。

总结

在C++中，类模板可以用来生成通用的类定义。我们可以使用类模板来实现堆栈，这样可以很方便地处理不同类型的数据。在使用堆栈类模板时，我们需要指定实际类型，然后调用堆栈的成员函数进行操作。