说实话，在栈中加一个取栈顶元素会更友好

default

类模板

运算符重载

出栈传入的是引用的好处：

使用这个函数的时候，传入参数可以是一个变量，这个变量可以把传给他的值取出

执行入栈操作，把元素存入栈顶，栈顶指针++以后指向了一个空位置（下一个元素要入栈的位置）所以入栈先复制再++操作

入栈操作后做出栈操作，要先把栈顶指针--指向有元素的位置，再把栈顶元素赋值给变量 ，达到了栈高度度下降，并且返回了一个值

修改后：

#include <iostream>
#include <stdlib.h>
#include "MyStack.h"
#include <algorithm>
#include <string>
using namespace std;

//用栈进行括号匹配

int main(void)
{
    //定义两个栈
    MyStack *pStack = new MyStack(30);//用于存放输入字符串的字符
    MyStack *pNeedStack = new MyStack(30);//用于存放栈顶急需匹配的字符

    char str[] = "[()]";
    char currentNeed = 0;
    for(int i = 0; i < strlen(str);i++)
    {
        if(str[i] != currentNeed)
        {
            pStack->push(str[i]);
            switch(str[i])
            {
                case'[':
                    if(currentNeed != 0)//currentNeed有一个正确的值
                    {
                        pNeedStack->push(currentNeed);
                    }
                    currentNeed = ']';
                    break;
                case '(':
                    if(currentNeed != 0)
                    {
                        pNeedStack->push(currentNeed);
                    }
                    currentNeed = ')';
                    break;
                default:
                    cout<<"字符串括号匹配"<<endl;

                    return 0;
            }
        }
        else
        {
            char elem;
            pStack->pop(elem);
            if(pNeedStack->pop(currentNeed))
            {
                currentNeed = 0;
            }

        }
    }

    if(pStack->stackEmpty())
    {
        cout<<"字符串括号匹配"<<endl;
    }
    else
    {
        cout<<"字符串括号不匹配"<<endl;
    }


    delete pStack;
    pStack = NULL;

    delete pNeedStack;
    pNeedStack = NULL;


    return 0;
}

还是有点不太理解，自己做

#include <iostream>
#include <stdlib.h>
#include "MyStack.h"
#include <algorithm>
#include <string>
using namespace std;

//用栈进行括号匹配

int main(void)
{
    //定义两个栈
    MyStack *pStack = new MyStack(30);//用于存放输入字符串的字符
    MyStack *pNeedStack = new MyStack(30);//用于存放栈顶急需匹配的字符

    char str[] = "[()]";
    char currentNeed = 0;
    for(int i = 0; i < strlen(str);i++)
    {
        if(str[i] != currentNeed)
        {
            pStack->push(str[i]);
            switch(str[i])
            {
                case'[':
                    if(currentNeed != 0)//currentNeed有一个正确的值
                    {
                        pNeedStack->push(currentNeed);
                    }
                    currentNeed = ']';
                    break;
                case '(':
                    if(currentNeed != 0)
                    {
                        pNeedStack->push(currentNeed);
                    }
                    currentNeed = ')';
                    break;
            }
        }
        else
        {
            char elem;
            pStack->pop(elem);
            pNeedStack->pop(currentNeed);
        }
    }

    if(pStack->stackEmpty())
    {
        cout<<"字符串括号匹配"<<endl;
    }
    else
    {
        cout<<"字符串括号不匹配"<<endl;
    }


    delete pStack;
    pStack = NULL;

    delete pNeedStack;
    pNeedStack = NULL;


    return 0;
}

老师是把余数10，11，12，13直接压进栈的，感觉直接压A、B、C、D方便很多。

老师的方法暂未看。

上一个程序不完善，因为有16进制。

https://www.cnblogs.com/curo0119/p/8304924.html

自己修改：应该正确：

#include <iostream>
#include <stdlib.h>
#include "MyStack.h"
#include <algorithm>
#include <string>
using namespace std;

//用栈进行进制转换

#define BIN 2
#define OCT 8
#define HEX 16

int main(void)
{
    string str = "0123456789ABCDEF";
    MyStack *pStack = new MyStack(30);

    int N = 12;

    while(N)
    {
        int tmp = N % HEX;

        pStack->push(str[tmp]);

        N /= HEX;
    }

    pStack->stackTraverse(false);
    delete pStack;
    pStack = NULL;
    return 0;
}

首先把之前的MyStack改成int型：

#include <iostream>
#include <stdlib.h>
#include "MyStack.h"
#include <algorithm>
using namespace std;

//用栈进行进制转换

#define BIN 2
#define OCT 8
#define HEX 16

int main(void)
{
    MyStack *pStack = new MyStack(30);

    int N = 1348;

    while(N)
    {
        int tmp = N % OCT;
        pStack->push(tmp);
        N /= OCT;
    }

    pStack->stackTraverse(false);
    delete pStack;
    pStack = NULL;
    return 0;
}

没做笔记。。

main.cpp

#include <iostream>
#include <stdlib.h>
#include "MyStack.h"
using namespace std;

//实现栈

int main(void)
{
    MyStack *pStack = new MyStack(5);

    pStack->push('h');
    pStack->push('e');
    pStack->push('l');
    pStack->push('l');
    pStack->push('o');

    pStack->stackTraverse(true);

    pStack->clearStack();

    cout<<pStack->stackLength()<<endl;

    if(pStack->stackEmpty())
    {
        cout << "栈为空" << endl;
    }

    delete pStack;
    pStack = NULL;
    return 0;
}

MyStack.cpp

//

#include "MyStack.h"
#include <iostream>
using namespace std;

MyStack::MyStack(int size)//分配内存初始化栈空间，设定栈容量，栈顶
{
    m_iSize = size;
    m_pBuffer = new char[size];
    m_iTop = 0;//表示此时的栈是个空栈

}

MyStack::~MyStack()
{
    delete []m_pBuffer;
}

bool MyStack::stackEmpty()//判定栈是否为空，为空返回true,非空返回false
{
    if(0 == m_iTop)
    {
        return true;
    }
    return false;
}
bool MyStack::stackFull()
{
    if(m_iTop == m_iSize)
    {
        return true;
    }
    return false;
}

void MyStack::clearStack()//清空栈
{
       m_iTop = 0;
}

int MyStack::stackLength()//已有元素的个数
{
    return m_iTop;
}

bool MyStack::push(char elem)//元素入栈，栈顶上升
{
    //先判断是否栈满
    if(stackFull())
    {
        return false;
    }
    m_pBuffer[m_iTop] = elem;
    m_iTop++;
    return true;
}
//法二
//char MyStack::pop()
//{
//    if(stackEmpty())
//    {
//        throw 1;
//    }
//    else
//    {
//        m_iTop--;
//        return m_pBuffer[m_iTop];
//    }
//}
bool MyStack::pop(char &elem)//元素出栈，栈顶下降
{
    //先判定是否为空
    if(stackEmpty())
    {
        return false;
    }
    m_iTop--;//入栈之后栈顶指向的是一个空位置
    elem = m_pBuffer[m_iTop];
    return true;
}

void MyStack::stackTraverse(bool isFromButoom)//遍历栈中所有元素
{
    if(isFromButoom)
    {
        for(int i = 0; i < m_iTop;i++)//栈的长度就是m_iTop
        {
            cout<< m_pBuffer[i] << ",";
        }
    }
    else
    {
        for(int i = m_iTop-1; i>=0;i--)
        {
            cout << m_pBuffer[i] << ",";
        }
    }

}

MyStack.h



#ifndef INC_0131_MYSTACK_H
#define INC_0131_MYSTACK_H
class MyStack
{
public:
    MyStack(int size);//分配内存初始化栈空间，设定栈容量，栈顶
    ~MyStack();//回收栈空间内存
    bool stackEmpty();//判定栈是否为空，为空返回true,非空返回false
    bool stackFull();
    void clearStack();//清空栈
    int stackLength();//已有元素的个数
    bool push(char elem);//元素入栈，栈顶上升
    bool pop(char &elem);//元素出栈，栈顶下降
    void stackTraverse(bool isFromButoom);//遍历栈中所有元素

private:
    char *m_pBuffer;//栈空间指针
    int m_iSize;//栈容量
    int m_iTop;//栈顶，栈中元素个数栈顶为1说明有一个元素
};

#endif //INC_0131_MYSTACK_H

为什么用.h和.cpp：https://blog.csdn.net/happywlg123/article/details/80375593

要想用 new，这个类要有一个默认的构造函数

函数指针 。

08:00

抛出异常 throw

外部 try catch

?????

（exception）异常，是用来报告你能恢复的那一类错误的，不是bugfix。

public class Coordinate {
    private int x;
    private int y;
    Coordinate(int x,int y){
        this.x=x;
        this.y=y;
    }
    void PrintCoordinate(){
        System.out.println("("+x+","+y+")");
    }
}

public class Mystackmain {
    public static void main(String[] args) {
        Mystack p=new Mystack(5);

        p.push('h');
        p.push('e');
        p.push('l');
        p.push('l');
        p.push('0');

        p.StackTraverse(false);
        System.out.println(p.StackLength());


        p.pop();
        p.pop();

        p.StackTraverse(false);
        System.out.println(p.StackLength());

        if(p.isEmpty()){
            System.out.println("栈为空");
        }
        if(p.isFull()){
            System.out.println("栈为满");
        }

        p.DeleteMystack();

    }

public class Mystack {
    private int head;
    private char[] stack;
    private int StackLength;
    private int StackCapacity;
    Mystack(int StackCapacity){
        this.StackCapacity=StackCapacity;
        head=-1;
        StackLength=0;
        stack=new char[StackCapacity];
    }
    void DeleteMystack(){
        stack=null;
    }

    boolean isFull(){
        if(head+1==StackCapacity){
            return true;
        }
        return false;
    }

    boolean isEmpty(){
        if(head==-1){
            return true;
        }
        return false;
    }

    void ClearStack(){
        head=-1;
        StackLength=0;
    }

    int StackLength(){
        return StackLength;
    }

    boolean push(char k){
        if(isFull()){
            return false;
        }
        head++;
        stack[head]=k;
        StackLength++;
        return true;
    }

    boolean pop(){
        if(isEmpty()){
            return false;
        }
        System.out.println("出栈元素为"+stack[head]);
        head--;
        StackLength--;
        return true;
    }

    void StackTraverse(boolean isFromTop){
        if(!isFromTop){
            for(int i=0;i<=head;i++){
                System.out.print(stack[i]);
            }
            System.out.println();
        }
        else {
            for (int i = head; i >= 0; i--) {
                System.out.print(stack[i]);
            }
            System.out.println();
        }
    }

java实现

栈类：后进先出

公有函数：

MyStack(int size):构造函数，分配内存空间

~MyStack()           :析构函数与构造函数相反，主要在构造函数执行完毕后被自动调用执行善后工作，如释放构造函数开辟的内存

int stackLength(): 返回栈里面的元素个数（不是内存空间大小）

void push(char elem)：入栈（入栈前要判断栈是否已满）

void pop(char &elem):出栈（出栈前要判断栈是否为空）

入栈导致栈顶上升    出栈导致栈顶下降

当成员变量比较复杂时要用到拷贝构造函数

LIFO: last in first out

后进先出

使用类模板时要在每个成员函数前加上template<typename T>，每个成员函数类名后加上<T>。 使用重载运算符重载<<：（库文件加上#include<ostream>）

定义类模板的模板函数T  template<typename T>  用T来取代通用数据类型 使用类模板时要在每个成员函数前加上template<typename T>，每个成员函数类名后加上<T>。

特殊类型

#include<ostream>

using namespace std;

friend sotream &operator<<(ostream &out，类型名 &coor)//声明一个友元函数

实例的介绍

栈是一种先进后出的机制

栈类的声明

栈不能通过下标访问，需要重载

可以通过pop方法打印弹出的值

当打印的数是十六进制，会出现显示问题，所以我们自己建立索引列表