C++堆栈类模板实现代码

C++中的堆栈类是一种常用的数据结构，可以实现后进先出(LIFO)的数据存储和处理方式。

下面是一个C++堆栈类模板的实现代码攻略，主要包括以下几个方面：

堆栈类模板的定义和实现

堆栈类模板由两个部分组成：头文件(.h文件)和源文件(.cpp文件)。

头文件中需要包含以下内容：

头文件保护宏定义，避免重复引用。
类定义，定义堆栈类模板及其成员函数。
类成员，包括存储堆栈数据、堆栈大小、堆栈容量等成员变量，以及对应的入栈、出栈、扩展、判断栈是否为空等成员函数。

以下是一个完整的头文件示例：

#ifndef STACK_H
#define STACK_H

template<typename T>  // 类型参数T为任意数据类型
class Stack {
public:
    // 构造函数
    Stack(int size = 1024);  // 堆栈默认大小为1024个元素

    // 析构函数
    ~Stack();

    // 判断堆栈是否为空
    bool IsEmpty() const;

    // 判断堆栈是否已满
    bool IsFull() const;

    // 元素入栈
    void Push(const T& item);

    // 元素出栈
    T Pop();

private:
    T* data_;  // 用于存储堆栈元素的数组指针
    int size_;  // 堆栈大小
    int top_;   // 堆栈顶部指针

    // 扩展堆栈容量
    void Resize(int size);
};

template<typename T>
Stack<T>::Stack(int size)
    : size_(size), top_(-1)
{
    data_ = new T[size];
}

template<typename T>
Stack<T>::~Stack()
{
    delete[] data_;
}

template<typename T>
bool Stack<T>::IsEmpty() const
{
    return top_ == -1;
}

template<typename T>
bool Stack<T>::IsFull() const
{
    return top_ == size_ - 1;
}

template<typename T>
void Stack<T>::Push(const T& item)
{
    if (IsFull()) {
        Resize(size_ * 2);
    }
    data_[++top_] = item;
}

template<typename T>
T Stack<T>::Pop()
{
    if (IsEmpty()) {
        throw std::out_of_range("stack is empty");  // 抛出异常
    }
    return data_[top_--];
}

template<typename T>
void Stack<T>::Resize(int size)
{
    T* new_data = new T[size];
    for (int i = 0; i <= top_; ++i) {
        new_data[i] = data_[i];
    }
    delete[] data_;
    data_ = new_data;
    size_ = size;
}
#endif  // STACK_H

在头文件中，我们使用了类模板，即将一个或多个参数定义为类型形参，实现代码的复用。类型形参命名为T，可以是任何数据类型。类中还包含堆栈元素的存储数组指针T* data_，堆栈大小和堆栈顶部指针等成员变量，以及堆栈的各个实际操作函数，例如入栈函数Push()和出栈函数Pop()。

源文件的实现主要包括以下内容：

头文件引用。
实现类模板成员函数。

以下是一个完整的源文件示例：

#include "Stack.h"

// 函数实现

int main() {
    // 使用堆栈模板
    Stack<int> my_stack(5);  // 创建一个大小为5的整型堆栈

    my_stack.Push(1);
    my_stack.Push(2);
    my_stack.Push(3);
    my_stack.Push(4);
    my_stack.Push(5);

    while (!my_stack.IsEmpty()) {
        int item = my_stack.Pop();
        std::cout << item << " ";
    }

    return 0;
}

在源文件中，我们使用头文件中定义的堆栈类模板Stack实现一个整型堆栈。首先调用构造函数创建一个大小为5个元素的堆栈，然后往堆栈中依次压入1~5，最后依次执行弹出操作将元素出栈并输出。

示例说明

下面是一个完整的程序示例，包含头文件和源文件。

头文件Stack.h

#ifndef STACK_H
#define STACK_H

template<typename T>
class Stack {
public:
    Stack(int size = 1024);
    ~Stack();
    bool IsEmpty() const;
    bool IsFull() const;
    void Push(const T& item);
    T Pop();

private:
    T* data_;
    int size_;
    int top_;
    void Resize(int size);
};

template<typename T>
Stack<T>::Stack(int size)
    : size_(size), top_(-1)
{
    data_ = new T[size];
}

template<typename T>
Stack<T>::~Stack()
{
    delete[] data_;
}

template<typename T>
bool Stack<T>::IsEmpty() const
{
    return top_ == -1;
}

template<typename T>
bool Stack<T>::IsFull() const
{
    return top_ == size_ - 1;
}

template<typename T>
void Stack<T>::Push(const T& item)
{
    if (IsFull()) {
        Resize(size_ * 2);
    }
    data_[++top_] = item;
}

template<typename T>
T Stack<T>::Pop()
{
    if (IsEmpty()) {
        throw std::out_of_range("stack is empty");  // 抛出异常
    }
    return data_[top_--];
}

template<typename T>
void Stack<T>::Resize(int size)
{
    T* new_data = new T[size];
    for (int i = 0; i <= top_; ++i) {
        new_data[i] = data_[i];
    }
    delete[] data_;
    data_ = new_data;
    size_ = size;
}

#endif

源文件Main.cpp

#include <iostream>
#include "Stack.h"

int main() {
    // 使用堆栈模板
    Stack<int> my_stack(5);  // 创建一个大小为5的整型堆栈

    my_stack.Push(1);
    my_stack.Push(2);
    my_stack.Push(3);
    my_stack.Push(4);
    my_stack.Push(5);

    while (!my_stack.IsEmpty()) {
        int item = my_stack.Pop();
        std::cout << item << " ";
    }

    return 0;
}

在上面这个示例中，我们首先在头文件中定义了一个堆栈类模板，包括构造函数、析构函数、判断堆栈是否为空等函数。然后在源文件中调用堆栈类模板，实现了一个大小为5的整型堆栈，并往堆栈中依次压入1~5，最后依次执行弹出操作将元素出栈并输出。

另外，我们也可以使用堆栈类模板实现一个字符串堆栈。如下：

#include <iostream>
#include "Stack.h"

int main() {
    // 使用堆栈模板
    Stack<std::string> my_stack(3);  // 创建一个大小为3的字符串堆栈

    my_stack.Push("hello");
    my_stack.Push("world");
    my_stack.Push("!");

    while (!my_stack.IsEmpty()) {
        std::string item = my_stack.Pop();
        std::cout << item << " ";
    }

    return 0;
}

在上面这个示例中，我们定义了一个大小为3的字符串堆栈，并往堆栈中依次压入"hello"、"world"、"!"三个字符串，最后依次执行弹出操作将元素出栈并输出。

总之，使用C++堆栈类模板，可以方便地实现各种类型的LIFO数据结构，提高程序的代码复用性和效率。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：C++堆栈类模板实现代码 - Python技术站

C++堆栈类模板实现代码

相关文章