C++类模板之栈的简单实现

最新推荐文章于 2023-05-14 16:41:45 发布

Richadox

最新推荐文章于 2023-05-14 16:41:45 发布

阅读量1.1k

点赞数 3

CC 4.0 BY-SA版权

分类专栏： C++学习笔记文章标签： stack Template

本文链接：https://blog.youkuaiyun.com/weixin_38185146/article/details/79828195

C++学习笔记专栏收录该内容

1 篇文章

订阅专栏

本文介绍了C++中类模板的应用，通过模板实现了一个通用的栈数据结构。讨论了如何利用模板创建可适应多种数据类型的类，并提醒注意在处理自定义类型时可能需要重载输出操作符。同时，提供了一个简单的栈实现，并给出了一道关于括号匹配的数据结构题目来验证栈的功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

C++类模板之栈的简单实现

1.类模板简介

在写代码过程中，往往会遇到一个问题：现在的类包含一个int型的data，但是如果我以后需要这个data是double的，是long long的，是char * 的，甚至是自定义类型的，那该怎么办呢？

C++里的模板Template就能很好得解决这个问题。类模板使类的data的类型能够随意可变，只要在初始化这个类时传入所需的类型，便可生成一个包含你所需数据类型的data的类。

话不多说，直接上代码

//在类的定义前，如果需要使用类模板，就需添加template <class T>语句
//T就是类中data的数据类型
//因为data的类型是T，所以类里所描述data的数据类型都应是T
//构造函数和析构函数啥的先略去了
template <class T>
class foo
{
    public:
         T print_data();
    private:
        T data;
}

//print_data()的实现
//同样需要在前面加template <class T>语句
//同时还需要再类名后加<T>表示数据类型
//所有用到了T类型的函数都得这样添加语句
template <class T>
    T foo<T>::print_data(){
        cout<<data;
    }


//使用
int main()
{
    foo<int> test;//现在test内的data就是int类型的
    test.print_data();
     return 0;
}

注意事项:

1.struct和class一样，用到template时同样需要添加语句

2.像print_data() 函数一样，使用了<<的符号，<<是能输出int的，自然没问题，但是如果自定义了一些无法使用<<的类型，那么就需要重载这个操作符。同理，+ - * / 都需要

3.因为类在构造前，编译器是不知道具体类型的，如果分成头文件和实现文件，可能会出现一点问题，由于不清楚编译原理的缘故，我并解释不了太多，把实现代码放在头文件里是最简单粗暴的了 =_=

下面是用了类模板写的简单的栈，可能会存在一些问题。

2.简单的栈

#ifndef MYSTACK_H
#define MYSTACK_H
#include<iostream>
using namespace std;
template<class T >
struct Node{
    T data;
    struct Node * next = NULL;
};

template<class T >
class MyStack
{

    public:
        MyStack();
        virtual ~MyStack(){};
        void StackClear();
        bool StackEmpty();
        int StackLength();
        T  GetTop();
        T  Push(T s);
        T  Pop();

    private:
        struct Node<T>  * top;
        struct Node<T>  * base;
        int stacksize ;

};
template<class T >
MyStack<T>::MyStack()
{
    base = NULL;
    top = NULL;
    stacksize = 0;
}

template<class T >
void MyStack<T>::StackClear()
{
 while(!StackEmpty())
        Pop();
}

template<class T >
bool MyStack<T>::StackEmpty()
{
    return (base == NULL)&&(top == NULL);
}

template<class T >
int MyStack<T>::StackLength()
{
    return stacksize;
}

template<class T >
T  MyStack<T>::GetTop()
{
    if(!StackEmpty())
        return top->data;
    else return NULL;
}

template<class T >
T  MyStack<T>::Push(T s)
{
    if(StackEmpty()){
        struct Node<T> * p = new struct Node<T>;
        p->data = s;
        top = p;
        base = p;
    }
    else{
        struct Node<T> * p = new struct Node<T>;
        p->data = s;
        p->next = top;
        top = p;
    }
    stacksize++;
    return s;
}

template<class T >
T  MyStack<T>::Pop()
{
    if(!StackEmpty())
    {
        T s = GetTop();
        struct Node<T> * p = top;
        top = top->next;
        delete p;
        if(--stacksize == 0)
            base = NULL;
        return s;
    }
    return NULL;
}

#endif // MYSTACK_H

给出一道数据结构上的题测试下功能

假设一个算术表达式中可以包含3种括号：园括号“(”和“)”、方括号“[”和“]”、花括号“{”和“}”，且这3种括号可按任意的次序嵌套使用,例如，…[…{…}…[…]…]…[…]…(…)…。编写判别给定表达式中所含括号是否正确配对出现的算法（已知表达式已存入数据元素为字符的顺序表中）。

#include <iostream>
#include <cstring>
#include "MyStack.h"
using namespace std;
MyStack<char> s;
char str[100];
int main()
{
    cin >>str;
    int ans = 1;
    for(int i=0;i< strlen(str);i++ )
    {
        if(str[i]=='['||str[i]=='{'||str[i]=='(')
            s.Push(str[i]);
        else{
            if(s.StackEmpty())
            {
                ans = 0;
                break;
            }
            else if(
                     (s.GetTop() =='(' && str[i] == ')')||
                     (s.GetTop() =='[' && str[i] == ']')||
                     (s.GetTop() =='{' && str[i] == '}')
                    ){
                s.Pop();
                continue;
            }
            else{
                ans = 0;
                break;
            }
        }
    }
    if(ans&&s.StackEmpty())
        cout<<"配对"<<endl;
    else
        cout<<"不配对"<<endl;
    return 0;
}

=_=注释就不打了