括号匹配C++程序

合集下载

括号匹配实验报告书

1．实验题目括号匹配的检验；2．需求分析本演示程序用VC++6.0编写，完成圆括号、方括号和大括号，其嵌套的顺序随意，即（（）[ ]）或{（[ ] [ ]）}等为正确格式，[[ ）]或（（（）均为不正确的格式。

①输入形式：直接输入一串括号；②输出形式：直接输出输入的括号串是否匹配的结果；③程序所能达到的功能：可以多次输入括号串并判断其是否匹配；④测试数据：输入（[ ]（）），结果“匹配”输入 [（ [）]，结果“此串括号匹配不合法”3．概要设计1）为了实现上述程序功能，需要定义栈的抽象数据类型：class Stack{数据对象：kh={ai|ai∈count,i=0,1,2,…,n,n≥0}数据关系：基本操作：push(char b)操作结果：把一个数据压进栈pop()操作结果：把一个数据弹出栈pp(char c[])初始条件：栈已存在操作结果：将栈中的元素进行匹配jc()初始条件：栈已存在操作结果：检查栈是否为空若空，返回0；若不空，返回1.clear()操作结果：清空栈2）本程序包含7个函数：①主函数main()②栈的构造函数Stack()③压栈操作函数push(char b)④弹栈操作函数pop()⑤匹配元素函数pp(char c[])⑥检查栈操作函数jc()⑦清空栈操作函数clear()各函数间关系如下：4．详细设计#include<iostream>#include<string>using namespace std;const int maxstack=100;//-------------------------------------------------------------------class Stack{//栈类public:Stack(){count=-1;};//初始化计数conutvoid push(char b);//压栈char pop();//弹栈void pp(char c[]);//匹配括号int jc();//检查是否为空栈void clear(){count=-1;}private:int count;//计数char a[maxstack];//存储};void Stack::push(char b)//压栈函数{if(count>=maxstack);else{count++;a[count]=b;}}char Stack::pop()//弹栈函数{if(count<0);else{return a[count--];}return 0;}int Stack::jc()//检查函数{if(count<0)return 0;return 1;}void Stack::pp(char c[])//匹配函数{int i=0,s=1,t;t=strlen(c);//测试输入的字符串长度if(c[0]==')'||c[0]==']'||c[0]=='}'||t%2==1)//判断是否为奇个括号或第一个为左括号{cout<<"此串括号匹配不合法"<<"\n"<<endl;}else //判断{while(c[i]!='\0'){if(c[i]=='('||c[i]=='['||c[i]=='{'){push(c[i]);}else{if(c[i]==')'){if(pop()!='('){s=0;break;}}if(c[i]==']'){if(pop()!='['){s=0;break;}}if(c[i]=='}'){if(pop()!='{'){s=0;break;}}}i++;}if(s==1){ if(!jc())cout<<"匹配"<<"\n"<<endl;else cout<<"此串括号匹配不合法"<<"\n"<<endl;}if(s==0)cout<<"此串括号匹配不合法"<<"\n"<<endl;}}//-------------------------------------------------------------------int main(){char a[maxstack];//数组Stack kh;//栈对象char h;cout<<"**************************"<<endl;cout<<"*** 括号匹配测试程序 ***"<<endl;cout<<"**************************"<<endl<<endl;do{cout<<"请输入您的选择: 1.运行程序; 2.结束。

利用栈检查括号匹配问题

工业软件技术基础实验报告实验内容：利用栈检查括号匹配问题班级：自动化202姓名：学号：日期：2022/11/171.程序代码#include<stdio.h>#include<stdlib.h>#include<string.h>#define maxsize 25typedef char datatype;typedef struct {datatype data[maxsize];int Top;}SeqStack;SeqStack* InitStack() //构造一个空栈S{SeqStack* S = (SeqStack*)malloc(sizeof(SeqStack));S->Top = 0;return S;}void SetNull(SeqStack* S){S->Top = 0;} //将栈S置为空栈int Empty(SeqStack* S) //若为空，则返回“真”，否则返回“假”{if (S->Top <= 0) return 1;else return 0;}int Push(SeqStack* S, datatype e){//若栈S不满，则将元素e插入栈顶，并返回1；否则返回0if (S->Top >= maxsize - 1){printf("栈上溢！\n");return 0;}else{S->data[++S->Top] = e;return 1;}}int Pop(SeqStack* S, datatype& e){ //若栈S不空，则删除栈顶元素，由参数e带回栈顶元素，并返回1；否则返回0 if (Empty(S)){printf("栈下溢！\n");return 0;}else{e = S->data[S->Top--];return 1;}}int GetTop(SeqStack* S, datatype& e)//若栈S不空，由参数e带回栈顶元素，并返回1；否则返回0{if (Empty(S)){printf("栈下溢！\n");return 0;}else{e = S->data[S->Top];return 1;}}void print(SeqStack* S){for (int i = S->Top; i >= 1; i--) // 从栈顶到栈底printf("%c\n", S->data[i]);printf("\n");}int compare(SeqStack* S, char a){char b, c;if (Empty(S) == 1){return 0;}if (Empty(S) != 1){GetTop(S, c);if (c == '('){if (a == ')'){Pop(S, c);return 1;}else{return 0;}}if (c == '['){if (a == ']'){Pop(S, c);return 1;}else{return 0;}}if (c == '{'){if (a == '}'){Pop(S, c);return 1;}else{return 0;}}}}//即将进来的括号和栈顶括号相对应才可以相消int correct(SeqStack* S, SeqStack* B, char exp[]){int a = strlen(exp);int i;int b;//设定标志位for (i = 0; i < a; i++){char X = exp[i];if (X == '(' || X == '[' || X == '{')Push(S, X);if (X == ')' || X == ']' || X == '}')Push(B, X);if (compare(S, X) == 1)Pop(B, X);}//每一位进行一次比较if (Empty(S) == 1 && Empty(B) == 1)return 1;elsereturn 0;//左右括号都有对应而且两个栈都为空才算合格}int main(){char function;SeqStack* L; L = InitStack();SeqStack* R; R = InitStack();//建立栈(分别存储左右括号)char exp1[] = "{a*(c-b)-{(b-d)*[(a+b)*(a-b)-(c-d)/2]}";char exp2[] = "a*(c-b)-{(b-d(*[(a+b)*(a-b)-(c-d)/2])}";char exp3[] = "a*(c-b)-[{(b-d(*[(a+b)*(a-b)-(c-d)/2])}";//把三个实验的算式写入数组printf("输入指令:1 验证:a*(c-b)-{(b-d)*[(a+b)*(a-b)-(c-d)/2]} \n");printf("输入指令:2 验证:a*(c-b)-{(b-d(*[(a+b)*(a-b)-(c-d)/2])} \n");printf("输入指令:3 验证:a*(c-b)-[{(b-d(*[(a+b)*(a-b)-(c-d)/2])} \n");while ((function = getchar()))//从键盘接收指令{switch (function){case'1'://式子1if (correct(L, R, exp1) == 1)printf("{a*(c-b)-{(b-d)*[(a+b)*(a-b)-(c-d)/2]}的括号没有问题");elseprintf("{a*(c-b)-{(b-d)*[(a+b)*(a-b)-(c-d)/2]}的括号有问题");break;case'2'://式子2if (correct(L, R, exp2) == 1)printf("a*(c-b)-{(b-d(*[(a+b)*(a-b)-(c-d)/2])} /n的括号没有问题");elseprintf("a*(c-b)-{(b-d(*[(a+b)*(a-b)-(c-d)/2])} /n的括号有问题");break;case'3'://式子3if (correct(L, R, exp3) == 1)printf("a*(c-b)-[{(b-d(*[(a+b)*(a-b)-(c-d)/2])} /n的括号没有问题");elseprintf("a*(c-b)-[{(b-d(*[(a+b)*(a-b)-(c-d)/2])} /n的括号有问题");break;}}}2.结果展示。

利用顺序栈解决括号匹配问题（c++）--数据结构

利⽤顺序栈解决括号匹配问题（c++）--数据结构题⽬：7-1 括号匹配（30 分)给定⼀串字符，不超过100个字符，可能包括括号、数字、字母、标点符号、空格，编程检查这⼀串字符中的( ) ,[ ],{ }是否匹配。

输⼊格式:输⼊在⼀⾏中给出⼀⾏字符串，不超过100个字符，可能包括括号、数字、字母、标点符号、空格。

输出格式:如果括号配对，输出yes，否则输出no。

输⼊样例1:sin(10+20)输出样例1:yes输⼊样例2:{[}]输出样例2:no分析：通过详读题⽬以及例题我们可以知道：程序会读⼊随机输⼊的⼀串字符串，⽽当只有 '('和')' 、'['和']' 、 '{'和'}'相匹配的时候输出“yes”，其他情况都会输出“no”。

这时候我们可以采⽤顺序栈的结构来解决这⼀个问题：将所有的左括号（即" ( 、[ 、{ "）存⼊栈中，遇到右括号（即" )、]、}"）时出栈，再判断两者是否匹配。

代码：#include<iostream>#include<string.h>using namespace std;//定义栈#define max_size 200//栈的最⼤容量typedef char datatype;typedef struct{datatype zhan[max_size];int top;//栈顶}stack;//栈的初始化void initial(stack &st){st.top = 0;}//类型为datatype的x⼊栈void push(stack &st, datatype x){//当栈顶和max_size相等时，栈满if(st.top == max_size){// cout<<"This stack has already full!";cout<<"no";exit(0);}else{st.zhan[st.top] = x;st.top++;}}//出栈char pop(stack &st){if(st.top == 0){// cout<<"This stack is empty!";cout<<"no";exit(0);}else{st.top--;return st.zhan[st.top];}}int main(){stack s;initial(s);/*输⼊字符串，并将字符串放到字符数组中，实现能够逐个扫描字符串中的字符，并且不跳过空格符*/string str;getline(cin, str);char ch[200]={'\0'};strcpy(ch,str.c_str());//flag标志状态 1为括号匹配，0为不匹配int flag=1;int i;for(i=0; ch[i]!='\0'; i++){//元素若为{，(，[则⼊栈if((ch[i] == '{' )|| (ch[i] =='[') || (ch[i] =='(')){push(s, ch[i]);}//元素若为}，)，]则出栈赋值给aelse if((ch[i] == '}') || (ch[i] ==']') || (ch[i] ==')')){char a;a = pop(s);//若a与ch[i]匹配，进⾏下⼀个字符扫描if((a == '{' && ch[i] == '}') || (a == '(' && ch[i] == ')') || (a == '[' && ch[i] == ']')){ continue;}else flag = 0;}}if(s.top != 0){ //当左括号多出没有与右括号匹配的时候（如：" {() "）flag = 0}if(flag == 0){cout<<"no";}else cout<<"yes";return0;}编程过程中遇到的问题：1. 在对字符串进⾏⼊栈操作时s.top（栈顶）的数值不增加，总为1错误代码如下：运⾏结果如下：这段代码对于初学者来说看上去逻辑和操作过程似乎都没有问题，同时也困扰了我许久，在参考了《数据结构（c语⾔版）》李云清等编著的教程后，我发现我犯了⼀个致命的低级错误：编程push函数的时候，传⼊的参数为 stack st ，是不具有返回的功能，也就意味着在 push 函数中对于 st.top++ 这个操作没有更改主函数中st.top的数值。

括号匹配问题源代码(C语言)

括号匹配问题就是给定任意判别式，然后检验括号的配对出现的情况。

可见输入的表达式有四种可能性：右括号配对次序不正确、右括号多于左括号、左括号多于右括号、左右括号匹配正确。

可以先检测表达式中的字符，若是左括号就入栈，如果是右括号就出栈一个元素与其配对，配对成功则继续访问下一个字符，否则退出。

出现非括号字符则跳过。

程序流程图如下：程序代码如下：#include<iostream>#include<string>#include<process.h>#include<stdlib.h>#define MaxSize 50using namespace std;/*------------主要的数据结构类型 --------------*/struct Text{int top;char Szstack[MaxSize];};/*-------------程序功能模块函数-------------*///检验栈是否为空bool IsEmpty(Text G){if(G.top==-1)return true;elsereturn false;}//检验栈是否为满bool IsFull(Text G){if(G.top==MaxSize-1)return true;elsereturn false;}//弹出栈顶元素char Pop(Text G){char n=G.Szstack[G.top];return n;}//检验括号是否配对int Check(char *A){int i;Text G;G.top=-1;int L=strlen(A);char c;for(i=0;i<L;i++){c=A[i];switch(c){case'(':G.Szstack[++(G.top)]=c;cout<<" 压入 ( top="<<G.top<<endl;break;case'[':G.Szstack[++(G.top)]=c;cout<<" 压入 [ top="<<G.top<<endl;break;case'{':G.Szstack[++(G.top)]=c;cout<<" 压入 { top="<<G.top<<endl;break;case')':if(Pop(G)!='('){return 0;}else{G.Szstack[G.top--];cout<<" 当遇 ) 出栈 ( top="<<G.top<<endl; break;}case']':if(Pop(G)!='[')return 0;else{G.Szstack[G.top--];cout<<" 当遇 ] 出栈 [ top="<<G.top<<endl; break;}case'}':if(Pop(G)!='{')return 0;else{G.Szstack[G.top--];cout<<" 当遇 } 出栈 { top="<<G.top<<endl;break;}default:break;}}if(!IsEmpty(G))return 0;return 1;}/*-------------主函数-------------*/int main(){system("color 75"); //设置颜色以美观Text G;char A[MaxSize];cout<<"请输入需要检验的括号(括号数小于50):"<<endl;cin>>A;if(Check(A)==1){cout<<" -----括号匹配-----"<<endl;}else{cout<<endl<<endl<<" -----括号不匹配-----"<<endl<<endl<<endl;}return 0;}以下分别是括号匹配与不匹配时的程序运行结果图：。

C语言检验括号匹配

先按顺序取出所有的括号.然后循环删除_相邻的_差为一或二的_点.最后如果表空则匹配.单向链表:#include <stdio.h>#include <string.h>#include <stdlib.h>#define LEN 80typedef struct list{char node;struct list* next;}list,*plist;void iniList(plist);int isEmpty(plist);int listAppend(plist,char);int delBracketsFormList(plist);int main(int argc,char* argv[]){char test[LEN];int i;list a;plist p;p=&a;iniList(p);scanf("%80s",test);for (i=0;i<LEN;i++){switch(test[i]){case '[': case']': case'{': case'}': case'(': case')':listAppend(p,test[i]);break;default:continue;}}delBracketsFormList(p);if (isEmpty(p)){printf("括号匹配!\n");}elseprintf("括号不配对!\n");return 0;}void iniList(plist aplist){aplist->next=NULL;aplist->node='\0';}int isEmpty(plist aplist){return aplist->next==NULL?1:0; }int listAppend(plist aplist,char a){ plist bplist=aplist,anode;while (bplist->next){bplist=bplist->next;}anode=(plist)malloc(sizeof(list));if (!anode)exit(-1);anode->node=a;anode->next=NULL;bplist->next=anode;return 0;}int delBracketsFormList(plist aplist){plist temp;int has=1;if (isEmpty(aplist))return 0;while(has){has=0;temp=aplist;while (temp->next){if(temp->next->next){if((temp->next->next->node - temp->next->node == 1)||(temp->next->next->node - temp->next->node == 2)){temp->next = temp->next->next->next;has=1;}elsetemp = temp->next;}elsetemp =temp->next;if(!has)break;}}return 0; }。

括号匹配性检测C语言实现

括号匹配性检测C语⾔实现#include <stdio.h>#define SIMPLE_KUOHAO "(()1231qeqw)(@#$)"#define COMPLEX_KUOHAO "{(()[asd])}{{{{(((())))}}}}"int main(int argc, const char * argv[]){/*问题描述：假设⼀个算术表达式中可以包含三种括号：圆括号"(" 和")"，⽅括号"["和"]"和花括号"{"和"}"，且这三种括号可按任意的次序嵌套使⽤（如：…[…{…}…[…]…]…[…]…(…)…）。

编写判别给定表达式中所含括号是否正确配对出现的算法(已知表达式已存⼊数据元素为字符的顺序表中)。

思路分析：检验括号是否匹配的⽅法可以⽤“期待的急迫程度”这个概念来描述。

例如，考虑下列括号序列： [ ( [ ] [ ] ) ] 1 2 3 4 5 6 7 8 当计算机接受了第⼀个括号后，它期待着与其匹配的第⼋个括号的出现，然⽽等来的却是第⼆个括号，此时第⼀个括号“[”只能暂时靠边，⽽迫切等待与第⼆个括号相匹配的、第七个括号“)”的出现，类似地，因等来的是第三个括号“[”，其期待匹配的程度较第⼆个括号更急迫，则第⼆个括号也只能靠边，让位于第三个括号，显然第⼆个括号的期待急迫性⾼于第⼀个括号；在接受了第四个括号之后，第三个括号的期待得到满⾜，消解之后，第⼆个括号的期待匹配就成为当前最急迫的任务了，……依此类推。

很显然，这样的⼀个处理过程和栈的特点⾮常吻合，因此，这个问题可以⽤栈来解决。

解决思路： 1.在算法中设置⼀个栈，每次读⼊⼀个括号； 2.若是右括号，则或者使置于栈顶的最急迫的期待得以消解，此时将栈顶的左括号弹出；或者是不合法的情况，此时将右括号压⼊； 3.若是左括号，则作为⼀个新的更急迫的期待压⼊栈中，⾃然使原有的在栈中的所有未消解的期待的急迫性都降低⼀级； 4.在算法的开始和结束时，栈应该为空。

如何使用栈来实现括号匹配

如何使⽤栈来实现括号匹配题⽬：给定⼀串字符，不超过100个字符，可能包括括号、数字、字母、标点符号、空格，编程检查这⼀串字符中的( ) ,[ ],{ }是否匹配。

输⼊格式:输⼊在⼀⾏中给出⼀⾏字符串，不超过100个字符，可能包括括号、数字、字母、标点符号、空格。

输出格式:如果括号配对，输出yes，否则输出no。

1. 代码实现：1 #include<iostream>2 #include<cstdlib>3using namespace std;4#define OVERFLOW 15#define ERROR 06#define OK -27#define MAXSIZE 1008 typedef int SElemType;9 typedef int Status;10 typedef struct//顺序栈的定义11 {12 SElemType *base;//栈底指针13 SElemType *top;//栈顶指针14int stacksize;//栈可⽤的最⼤容量15 }SqStack;16 Status InitStack(SqStack &S)//顺序栈的初始化17 {18 S.base=new SElemType[MAXSIZE];19if(!S.base) exit(OVERFLOW);//存储分配失败20 S.top=S.base;//空栈，top 初始化 base21 S.stacksize=MAXSIZE;//stacksize 置为栈的最⼤容量MAXSIZE22return OK;23 }24bool StackEmpty(SqStack S)//判断是否栈空25 {26if(S.top==S.base) return true;27else return false;28 }29 Status Push(SqStack &S,SElemType x)//⼊栈30 {31if(S.top-S.base==S.stacksize) return ERROR;//栈满32 *S.top++=x;//元素e压⼊栈顶，栈顶指针加1 后置⾃加 *S.top=e;S.top++;33return OK;34 }35 Status POP(SqStack &S,SElemType &x)//出栈36 {37if(S.top==S.base) return ERROR;//栈空38 x=*--S.top;//栈顶指针减1，将栈顶元素赋给e 前置 --S.top;e=*S.top;39return OK;40 }41 SElemType GetTop(SqStack S)//取栈顶元素42 {43if(S.top!=S.base) return *(S.top-1);44 }45int main()46 {47int flag = 1;//需要⼀个标记48 SqStack S;49 InitStack(S);50 SElemType x;5152char ch[100];//采⽤字符数组53 cin.getline(ch,100);54int length=0;55for(int i=0;ch[i]!='\0';i++)56 {57 length++;58 }5960for(int i=0;i<length;i++)//遍历每⼀个字符61 {62switch(ch[i])63 {64case'{':65// Push(S,ch[i]);66// break;67case'(':68// Push(S,ch[i]);69// break;70case'[':71 Push(S,ch[i]);72break; //退出switch语句，不会退出外⾯的循环结构 73case')':74if(!StackEmpty(S) && GetTop(S)=='(')75 POP(S,x);76else{flag = 0;77 cout<<"no";78return0;79 }80break;81case']':82if(!StackEmpty(S) && GetTop(S)=='[')83 POP(S,x);84// else85// flag = 0;86else{flag = 0;87 cout<<"no";88return0;89 }90break;91case'}':92if(!StackEmpty(S) && GetTop(S)=='{')93 POP(S,x);94else{flag = 0;95 cout<<"no";96return0;97 }98break;99 }100 }101if(flag && StackEmpty(S)) cout<<"yes";102else cout<<"no";103return0;104 }2.分析总结：多思考，多尝试，多回顾总结。

C 语言实现括号匹配算法实例

if(!s->base) return error;
s->StackSize+=10;
s->top=s->base+s->StackSize;
}
*(s->top)=e;
s->top++;
return OK;
}
int Pop (sqstack *s,SElemType *e){
int i,k=0;
for(i=0;i<n;i++)
if(a[i].lc==b){
k=i+1;break;
}
return (k);
}
int bdunrc(bracket *a,char b,int n){/* 判断字符b是不是a的右括号*/
printf("plase input array number:");
scanf("%d",&n);
array=(bracket *)malloc(n*sizeof(bracket));
for(i=0;i<n;i++){
flag=1;
printf("plese input the %dth couple of array:",i+1);
printf("\n");
s->base=(SElemType *)malloc(n*sizeof(SElemType));
if(!s->base) return error;
s->top=s->base;
s->StackSize=n;

编写一个括号匹配的检验的程序实习报告

编写一个括号匹配的检验的程序1．实验题目编写一个括号匹配的检验的程序2．需求分析本演示程序用C++编写，完成圆括号、方括号和大括号（选作）的匹配检验，即当输入一串括号后能够判断出此串括号匹配是否合法。

①输入形式和输入范围：括号以字符串形式输入，只输入圆括号、方括号和大括号三种括号，三种括号可以随意嵌套。

②输出形式及功能：当输入任意一串括号后，都会做出判断，输出输入的括号串是否合法。

③测试数据：输入（[ ]（）），结果“匹配”输入 [（] ），结果“此串括号匹配不合法”3．概要设计1）为了实现上述程序功能，需要定义压栈数据类型：stack<char> openings{数据对象：（symbol∈“（”，“）”，“[”，“]”，“{”，“}”）数据关系：“（”==“）”，“[”==“]”，“{”“}”基本操作：while (is_matched &&(symbol=cin.get())!='\n')操作结果：对括号进行压栈比较，判断下一步是压栈还是弹栈配对。

基本操作：is_matched（）操作结果：判断括号是否匹配，在屏幕打印出。

}2）本程序包含3个函数：①主函数main()②压栈弹栈函数symbol=cin.get()③括号匹配比较函数is_matched（）各函数间关系如下：mainsymbol=cin.getis_matched4．详细设计实现概要设计中定义的所有的数据类型，对每个操作给出伪码算法。

对主程序和其他模块也都需要写出伪码算法。

（1）括号输入while (is_matched &&(symbol=cin.get())!='\n')（2）括号匹配检验is_matched=(5．调试分析（1）由于本程序是通过书本上伪代码改编而来，所以编写时比较简单，程序语把不匹配时的空栈这一点去掉，经过验证我的设计正确，解决了问题，实现了括号匹配的检验程序。

C语言实验二、括号匹配

实验二、括号匹配一、问题描述假设一个输入字符串中包含圆括号、方括号和花括号三种类型的括号，以及其它一些任意字符。

编写程序，判别串中的括号是否正确匹配，即必须满足以下条件1.各种左、右括号的个数要一致；2.要符合正确的嵌套规则。

基本方法：在算法中设置一个栈，每读入一个括号，若是右括号，则或者使置于栈顶的最后进入的左括号消解，或者是不合法的情况；若是左括号，则压入栈中，同时在算法的开始和结束时，栈都应该为空，否则不合法。

二、基本要求输入一个算术表达式，利用栈存储结构来存入左括号，然后判断表达式中的括号是否匹配。

三、测试数据（1）([3＋2]+(7*9))（2）[([3/2 ]-[5*6])]（3）[7+8-(8-9])（4）(2+](3*9)))四、实现提示1、算法思路(1)对于栈的操作包括初始化initstack、判断栈是否满sfull、判断栈是否空sempty、入栈push和出栈pop操作。

该函数被主函数调用。

(2)在主函数中输入一个算术表达式，依次取出该算术表达式的某个字符，如果是左括号则入栈，如果是右括号则出栈，并判断右括号与出栈的元素是否匹配。

当算术表达式取完后，再判断栈是否为空，如果不空，则说明括号不匹配。

2、数据结构typedef struct stk//定义的栈结构{char *s; //栈中存放元素int top;//栈顶指针}stack;3、基本操作void initstack(stack *st) /* 栈s1和s2的初始化操作，st为指向s1或s2的指针 */int sfull(stack st) /* 判断栈s1和s2是否满的操作 */int sempty(stack st) /* 判断栈s1和s2是否空的操作 */int push(stack st,char e) /* 入栈操作，e为栈中结点类型 */int pop(stack *st,char *e) /*出栈操作,e为指向栈中结点的指针类型 */5、主程序main(){int i=0;char e;stack s1;//存放左括号的栈char str[100];//存放算术表达式的值initstack(&s1);printf("请输入表达式\n");gets(str);//输入算术表达式while(i<strlen(str)){if (str[i]=='('||str[i]=='['||str[i]=='{'){……}else if (str[i]==')'||str[i]==']'||str[i]=='}'){……else i++;}……}5、输出结果测试数据（1）([3＋2]+(7*9))括号匹配（2）[([3/2 ]-[5*6])]括号匹配（3）[7+8-(8-9])第10个元素左右括号不匹配（4）(2+](3*9)))第4个元素左右括号不匹配。

c语言正则表达式匹配多个方括号 -回复

c语言正则表达式匹配多个方括号-回复C语言正则表达式匹配多个方括号的问题在实际编程中经常会遇到。

方括号是正则表达式中的特殊字符，用于匹配指定范围内的字符。

但是当我们需要匹配多个方括号时，我们需要使用一些技巧来实现。

本文将一步一步回答关于C语言如何正则表达式匹配多个方括号的问题，并提供一些实际案例来加深理解。

首先，让我们了解一下C语言中正则表达式的基本知识。

正则表达式是用于在字符串中进行模式匹配的工具，它由一系列字符和特殊字符组成。

在C语言中，我们使用正则表达式的函数是regex.h头文件中定义的函数，其中包括`regcomp`、`regexec`和`regfree`等函数。

其次，为了正确地匹配多个方括号，我们需要使用到方括号内的内容。

在正则表达式中，方括号用于定义一个字符集合，其中可以包含多个字符或字符范围。

我们可以使用`[]`表示方括号，例如`[abc]`可以匹配字符a、b 或c。

接下来，我们需要解决匹配多个方括号的问题。

考虑到方括号的数量可能不确定，我们可以使用循环来处理。

下面是一个简单的示例代码，用于匹配字符串中的多个方括号和其中的内容：c#include <stdio.h>#include <regex.h>void matchBrackets(char* str) {regex_t regex;char pattern[] = "\\[([^\\]]*)\\]"; 正则表达式模式size_t matches = 1; 匹配到的结果数量regmatch_t match[matches];regcomp(&regex, pattern, REG_EXTENDED);while (regexec(&regex, str, matches, match, 0) == 0) { for (int i = 1; i < matches; i++) {if (match[i].rm_so == -1) {break;}int start = match[i].rm_so;int end = match[i].rm_eo;printf("方括号内容: .*s\n", end - start, str + start + 1);可以在这里进行进一步的处理}str += match[0].rm_eo; 偏移指针}regfree(&regex);}int main() {char str[] = "这是[第一个]方括号[第二个方括号]测试[字符串]";matchBrackets(str);return 0;}在上面的示例代码中，首先定义了一个函数`matchBrackets`用于匹配多个方括号中的内容。

圆括号匹配C语言可运行的

#include<stdio.h>#include<stdlib.h>//栈存储结构的定义#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct{char *base;char *top;int stacksize;}SeqStack;//栈初始化SeqStack InitSeqStack(){SeqStack s;s.base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));if(!s.base)exit(0);s.top=s.base;s.stacksize=STACK_INIT_SIZE;return s;}//入栈int Push_SeqStack(SeqStack S, char e){if(S.top-S.base>=S.stacksize){S.base=(char*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char));/*栈满，追加存储空间*/if (!S.base)return 0;S.top=S.base+S.stacksize;S. stacksize+=STACKINCREMENT;}*S.top= e;S.top++;return 1;}//出栈int Pop_SeqStack(SeqStack S,char *e){if ( S.top==S.base)return 0; /* 栈空，返回失败标志 */S.top--;*e=*S.top;return 1;}//取栈顶元素int GetTop(SeqStack S,char *e){if(S.top==S.base) return 0;*e=*(S.top-1);return 1;}void BracketCorrespondency(char ch[]){SeqStack ss;int i;char c;ss=InitSeqStack();for(i=0;ch[i]!='#';i++)switch(ch[i]){case '(': //遇到'('就入栈Push_SeqStack(ss,ch[i]);break;case ')': //遇到')'就栈顶元素c相比较if(ss.top!=ss.base&&GetTop(ss,&c)&& c=='(')Pop_SeqStack(ss,&c); //如果匹配栈顶元素出栈else //如果不匹配，退出程序{printf("不匹配!\n");exit(0);}default: break;}if(ss.top==ss.base) //如果最后栈中还有剩余的元素则不匹配printf("匹配!\n");elseprintf("不匹配!\n");}void main(){char b[]="(())#";BracketCorrespondency(b); }。

括号匹配

#include <stdio.h>#include<stdlib.h>#define DATATYPE char#define MAXSIZE 100typedef struct //顺序栈实现括号匹配{DA TATYPE data[MAXSIZE];char top;}SEQSTACK;SEQSTACK *s;void Initstack(SEQSTACK *s){//初始化操作s->top=-1;}int Stackempty(SEQSTACK *s){//判断栈空if(s->top==-1)return 1;elsereturn 0;}void Push(SEQSTACK *s,DATATYPE x) {//入栈if(s->top==MAXSIZE-1)printf("栈已满!\n");else{s->top++;s->data[s->top]=x;}}DA TATYPE Gettop(SEQSTACK *s) {//取栈顶元素DA TATYPE x;if(Stackempty(s)){printf("栈空!");return 0;}elsex=s->data[s->top];return x;}DA TATYPE Pop(SEQSTACK *s){//出栈DA TATYPE x;if(Stackempty(s)){printf("");return 0;}elsex=s->data[s->top];s->top--;return x;}Clearstack(SEQSTACK *s){//清空栈s->top=-1;}int Stacklength(SEQSTACK *s){//求栈长return s->top+1;}void Khop(SEQSTACK *s){char str[21];char *p;printf("请输入长度不超过20个的括号序列\n");gets(str);//获取字符p=str;while(*p!='\0'){if(*p=='('||*p=='['||*p=='{')Push(s,p);//入栈else if(*p==')'||*p==']'||*p=='}'){if(Pop(s)==0)//出栈break;}*p++;}if(*p!='\0'&&Stackempty(s)||*p=='\0'&&!Stackempty(s))//判断是否有空的{printf("这些括号不匹配\n\n");}elseprintf("这些括号匹配\n\n");}void main(){DA TATYPE x;SEQSTACK stack,*s;char ch;s=&stack;Initstack(s);//初始化栈Khop(s);//调用函数}。

链栈(括号匹配)

C语言数据结构中的链栈例题：将输入的字符串进行匹配，看匹配情况1.建立头文件stack.hstruct stacknode{char s;struct stacknode *next;};struct stack{struct stacknode *top;};2.建立各个函数及主函数//输入一行字符（带有括号），问这些括号是否配对//试验正确配对：1.([]()) 2.[([][])]//试验错误配对：1.[(])（不匹配）2.([())（左边多了）3.(()])（右边多了）#include<stdio.h>#include<string.h>#include<stdlib.h>#include"stack.h"void push(struct stack *sp,char c);void pop(struct stack *sp);int lookfor(void);char gettop(struct stack *sp);void main(){int state;state=lookfor();if(state)printf("Matching!\r\n");elseprintf("Not matching!\r\n");}/******************************************************************* 函数名称：lookfor函数功能：输入一个字符串，并查看其中的括号是否配对入口参数：void（类型）出口参数类型：int备注：调用多个函数，有入栈出栈和查询操作******************************************************************/ int lookfor(void){char string[100],e;int i=0,state=1;struct stack sp;//定义一个栈元素sp.top=NULL;//栈顶初始值为空printf("Please input a string with quiotions \r\n");scanf("%s",string);//输入一个字符串while( state && (i<strlen(string)))//条件是状态值为真，且循环变量小于字符串的长度{switch (string[i])//对每一个括号字符进行匹配{case '('://如果是左括号则进栈case '[':case '{':push(&sp,string[i]);printf("%c get in the stack\r\n",string[i]);//如果是右括号，则需要一个个进行匹配，因为'('和')'是不是匹配，计算机是不知道的{e=gettop(&sp);if((sp.top!=NULL) && ('('==e)){pop(&sp);printf("because '%c',so delete '%c' from the stack\r\n",string[i],e);//将每一个匹配的左括号出栈，并且显示在屏幕上i++;}else state=0;break;}case ']':{e=gettop(&sp);if((sp.top!=NULL) && ('['==e)){pop(&sp);printf("because '%c',so delete '%c' from the stack\r\n",string[i],e);//将每一个匹配的左括号出栈，并且显示在屏幕上i++;}else state=0;break;}case '}':{e=gettop(&sp);if((sp.top!=NULL) && ('{'==e)){pop(&sp);printf("because '%c',so delete '%c' from the stack\r\n",string[i],e);//将每一个匹配的左括号出栈，并且显示在屏幕上i++;}else state=0;break;}default:i++;//如果不是括号字符，而是其他字符，则将循环变量自增，继续匹配下一个字符}}if(sp.top!=NULL)//如果左括号有多余,也是不匹配的state=0;return (state);}/*********************************************************************函数名称：push函数功能：将数据n入栈入口参数：srruct stack *（参数类型）sp（参数名）出口参数类型：void备注：*********************************************************************/void push(struct stack *sp,char c){struct stacknode *newp;newp=(stacknode *)malloc(sizeof(stacknode));newp->s=c;newp->next=sp->top;sp->top=newp;}/********************************************************************* 函数名称：pop函数功能：将栈顶的左括号返回入口参数：srruct stack *（参数类型）sp（参数名）出口参数类型：char备注：*********************************************************************/ void pop(struct stack *sp){struct stacknode *to_free;to_free=sp->top;sp->top=to_free->next;free(to_free);}char gettop(struct stack *sp){char nnew;nnew=sp->top->s;return nnew;}。

c语言符号配对思路

c语言符号配对思路在C语言中，符号配对是一种非常重要的概念。

它涉及到了各种符号、括号以及其他的配对符号。

在编写C语言程序时，要确保所有的符号都正确地配对使用，以避免出现语法错误和逻辑错误。

首先，了解C语言中的一些常见符号配对是非常重要的。

其中最常见的配对符号是括号。

在C 语言中，括号用于表示优先级和分组，主要包括圆括号、方括号和花括号。

在使用这些符号时，必须确保每个左括号都有一个匹配的右括号。

这种配对可以确保程序的逻辑正确性，并避免出现语法错误。

其次，理解C语言中不同类型符号的使用规则也是很重要的。

例如，圆括号主要用于函数调用和表达式求值，方括号用于数组的声明和索引访问，而花括号用于代码块的定义。

在使用这些符号时，要确保它们的使用方式是正确的，并且每个左符号都有一个匹配的右符号。

此外，在编写C语言程序时，可以采用一些技巧来帮助确保符号配对的正确性。

其中一个常用的技巧是使用缩进来标记代码块。

通过正确缩进代码，可以更容易地识别出代码块的起始和结束位置，从而更容易地对配对的符号进行匹配。

另一个技巧是使用编辑器自带的代码匹配功能，如自动匹配括号、方括号等符号。

这个功能可以帮助程序员更快速地找到和解决配对错误。

最后，编写程序时要养成良好的编码习惯。

代码风格应该统一一致，注释应该清晰明了。

这样可以更容易地发现和解决符号配对错误。

此外，注意在编写程序时进行代码测试和调试是非常重要的。

通过对程序进行全面的测试和调试，可以发现和解决可能存在的符号配对问题。

综上所述，正确的符号配对是编写C语言程序的关键要素之一。

只有当符号配对的正确性得到保证，程序才能具有正确的语法和逻辑。

通过理解不同类型符号的使用规则，采用一些技巧和良好的编码习惯，能够帮助程序员更好地处理符号配对问题，提高程序的质量和可靠性。

C语言实现括号配对问题

C语⾔实现括号配对问题代码如下：#include<stdio.h>#include<string.h>#include<stdlib.h>// 写⼀个判断的括号是否匹配的函数int MatchCheck(char a[],int len){int flag = 0;char s[10000];int top,i;char temp;// 初始化⼀个栈top = 0;for(i=0;i<len;i++){if(a[i]=='['){ // 如果是左括号直接⼊栈s[++top]=a[i];continue;}if(a[i]==']'){ // 如果是右括号，则尝试匹配temp = s[top];if(temp=='['){flag = 1;top--;continue;}else{flag = 0;break;}}if(a[i]=='('){ // 如果是左括号直接⼊栈s[++top]=a[i];continue;}if(a[i]==')'){ // 如果是右括号，则尝试匹配temp = s[top];if(temp=='('){flag = 1;top--;continue;}else{flag = 0;break;}}}if(flag&&(top==0)){return1;}else{return0;}}int main(){// 提⽰输⼊⼀个数int N,i;scanf("%d",&N);int len;// 对N组数据循环判断int count = 1;int result[5];while(count<=N){char a[10000]={'\0'};// 读⼊⼀⾏字符串scanf("%s",&a);// 求字符串的长度len = strlen(a);result[count]=MatchCheck(a,len);count++;}for(i=1;i<count;i++){if(result[i]){printf("Yes\n");}else{printf("No\n");}}return0;}样例输⼊和输出如下：。

c语言栈的括号匹配算法程序

c语言栈的括号匹配算法程序C语言栈的括号匹配算法程序。

在编程中，括号匹配是一个常见的问题，特别是在处理字符串和表达式的时候。

括号匹配算法可以用来检查一个字符串中的括号是否匹配，即左括号是否有相应的右括号与之匹配。

在C语言中，我们可以使用栈来实现括号匹配算法。

栈是一种后进先出（LIFO）的数据结构，非常适合用来处理括号匹配的问题。

下面是一个简单的C语言程序，实现了括号匹配算法：c.#include <stdio.h>。

#include <stdlib.h>。

#define MAX_SIZE 100。

typedef struct {。

char items[MAX_SIZE];int top;} Stack;void init(Stack s) {。

s->top = -1;}。

void push(Stack s, char c) {。

if (s->top == MAX_SIZE 1) {。

printf("Stack overflow\n"); exit(1);}。

s->items[++s->top] = c;}。

char pop(Stack s) {。

if (s->top == -1) {。

printf("Stack underflow\n"); exit(1);}。

return s->items[s->top--];}。

int isEmpty(Stack s) {。

return s->top == -1;}。

int isMatchingPair(char left, char right) {。

if (left == '(' && right == ')') return 1; if (left == '{' && right == '}') return 1; if (left == '[' && right == ']') return 1; return 0;}。

数据结构与算法--栈的应用（进制转换、括号匹配）

数据结构与算法--栈的应⽤（进制转换、括号匹配）栈的应⽤ps：⽤栈很简单实现的应⽤有很多，⽐如说进制转换，括号匹配等。

学计算机的都知道，2进制，8进制，10进制，16进制等，进制之间的转换也是需要掌握的，以备不时之需，所以我们可以⾃⼰写⼀段程序如果会android的话，可以直接打包成APK。

下⾯就按照这两个应⽤稍微写⼀点C语⾔的代码。

进制转换括号匹配1：进制转换想要⾃⼰做⼀个进制转换的⼯具，⾸先我们要知道如何实现进制之间的转换，我们平常⽤的都是10进制，如果想要转成8进制怎么办，按照⽅法，如图可以看到，N是我们输⼊的10进制数，除以8，余数保留在栈中，得到的168接着与8整除运算，直到N div 8 等于0，最后把栈中数据取出即可，正好⽤到了栈的规则，先进后出的特性。

1.1：定义栈结构体typedef struct zhan{int data;struct zhan *next;}zhan,*ZhanL;1.2：初始化栈/*** 初始化栈* */ZhanL initZhan(){ZhanL L =(ZhanL)malloc(sizeof(zhan));L->next=NULL;return L;}1.3进栈出栈操作在pop⽅法中，把L赋给s，主要是出栈后，把空余的栈位释放掉，push⽅法⽤到了尾插法。

/*** 进栈操作* */int push(ZhanL &L,int data){//创建⼀个新的结点ZhanL p=(ZhanL)malloc(sizeof(zhan));p->data=data;p->next = L;L = p;return0;}int pop(ZhanL &L){if(L->next){ZhanL s=L;//释放空间⽤printf("%d ",s->data);L = L->next;if(L->next){// printf("栈顶%d \n",L->data);} else{printf("栈空\n");}free(s);}return0;}1.4：转换⽅法/*** 转换⽅法* */int zhuanhuan(ZhanL &L,int data,int jz){while (data){push(L,data%jz);data = data/jz;}while (L){pop(L);}return0;}1.5：使⽤int main(){ZhanL L;L=initZhan();printf("请输⼊⼀个⼗进制数");int data,jz;scanf("%d",&data);printf("请输⼊转换的进制");scanf("%d",&jz);zhuanhuan(L,data,jz);return0;}结果图：2：括号匹配什么是括号匹配？在编写代码的时候，经常会⽤到两种括号：圆括号 “()” 和⼤括号 “{}” 。

括号匹配C 程序.

#include <iostream>#include <string>#include <stack>#include <fstream>using namespace std;///////////////////////////////////////////////CBalance类//此类对于一般的C++或者C文件进行括号匹配检查//文件可以有注释，字符串……//字符串常量不可以跨行//my.h定义了常用的类库////////////////////////////////////////////class CBalance{private:ifstream fin; //文件流int nCurrentLine; //正在处理的行号int nErrors; //已发现的错误数struct CSymbol //此类记录遇到的字符和字符的行号{char cToken;int nTheLine;};enum CommentType {SlashSlash , SlashStar};//记录//和/*两中注释方式//CheckBalance()函数的工具类//CheckMatch函数用于比较两个符号是否匹配bool CheckMatch(char char1, char char2, int nLine1, int nLine2); //GetNextSymbol函数用于返回读到的括号char GetNextSymbol(void);//PutBackChar用于把字符重新返还给文件流void PutBackChar(char char1);//SkipComment根据注释符的不同跳过源文件的注释void SkipComment(enum CommentType type);//SkipQuote函数用于跳过源文件中的字符串和字符常量void SkipQuote(char type);//NextChar函数用于得到下一个字符char NextChar(void);public:CBalance(const char* filename); //构造函数int CheckBalance(); //检查fin中的字符是否匹配};class noFile{}; //定义的异常类，当函数不存在的时候抛出异常CBalance::CBalance(const char* filename){fin.open(filename);if(!fin) throw noFile();nCurrentLine = 1;nErrors = 0;}int CBalance::CheckBalance(){struct CSymbol node; //符号与行号stack<CSymbol> st; //定义的符号栈char LastChar,Match; //LastChar为读入的符号，Match为栈顶的字符while(LastChar = GetNextSymbol())//从文件中读取括号字符，直到文件结束{//while_beiginswitch (LastChar){ //switch_beigincase '(':case '[':case '{': //遇到这三种符号要进栈node.cToken = LastChar;node.nTheLine = nCurrentLine;st.push(node);break;case ')':case ']':case '}'://遇到这三种括号要进行比较if(st.isEmpty()){nErrors++;cout<<"在第"<<nCurrentLine<<"有一个多余"<<LastChar<<endl; }else{node = st.pop();Match = node.cToken;if(!CheckMatch(Match,LastChar,node.nTheLine,nCurrentLine)) nErrors++;}break;}//switch_end}//while_endwhile(!st.isEmpty()) //栈中多余的符号{nErrors++;node = st.pop();cout<<"第"<<node.nTheLine<<"行的符号"<<node.cToken<<"不匹配"<<endl; } return nErrors;}bool CBalance::CheckMatch(char char1, char char2, int nLine1, int nLine2){if(char1=='('&&char2!=')'||char1=='['&&char2!=']'||char1=='{'&&char2!='}'){cout<<"发现第"<<nLine2<<"的符号"<<char2<<"与第"<<nLine1<<"的符号"<<char1<<"不匹配"<<endl;return false;}return true;}char CBalance::GetNextSymbol(){char ch;while(ch=NextChar()){if(ch=='/'){ch=NextChar();if(ch=='/')SkipComment(SlashSlash);else if(ch=='*')SkipComment(SlashStar);else PutBackChar(ch);}else if (ch=='\''||ch=='"'){SkipQuote(ch);}else if (ch=='['||ch=='{'||ch=='('||ch==']'||ch=='}'||ch==')') {return ch;}}return NULL;}char CBalance::NextChar(){char ch;if((ch=fin.get())==EOF)return NULL;if(ch=='\n')nCurrentLine++;return ch;}void CBalance::PutBackChar(char char1){fin.putback(char1);if(char1=='\n') nCurrentLine--;}void CBalance::SkipQuote(char type){char ch;while(ch=NextChar()){if(ch==type) return;else if (ch=='\n'){nErrors++;cout<<"在第"<<nCurrentLine<<"行缺少匹配的\'或者\""<<endl; }else if (ch=='\\'){ch = NextChar();}}}void CBalance::SkipComment(enum CommentType type){char ch,flag;if(type==SlashSlash) //对于像//注释一直读到行末尾{while ((ch=NextChar())&&(ch!='\n')){return;}}flag='\0'; //对于像/*这样的注释要不断的读文件 while((ch=NextChar())!=NULL) {if(flag=='*'&&ch=='/')return;flag = ch;}}int main(){try{CBalance b("123.txt"); //文件要在工程当前目录下 b.CheckBalance();}catch (noFile& file){cout <<"文件打开失败！"<<endl; }return 0;}。

C++中用栈来判断括号字符串匹配问题的实现方法

C++中⽤栈来判断括号字符串匹配问题的实现⽅法本⽂实例主要实现：输⼊⼀个括号字符串，依次检验，若为左括号则⼊栈，若为右括号则出栈⼀个字符判断是否与之相对应，在最后还需判断栈是否为空，如果不为空则不匹配。

⾸先回顾栈的基本知识：1.定义栈的结构体并初始化⼀个新栈：struct stack{char strstack[stacksize];int top;};void InitStack(stack &s){s.top=-1;}2.出栈和⼊栈操作：char Push(stack &s,char a){if(s.top==stacksize-1){return 0;}s.top++;s.strstack[s.top]=a;return a;}char Pop(stack &s){if(s.top==-1){return 0;}char a=s.strstack[s.top];s.top--;return a;}3.判断栈是否为空：int Empty(stack &s,int re){if(s.top==-1){return 1;}else{return 0;}}以上是栈的基本操作，定义⼀个栈和初始化⼀个新栈，出栈和⼊栈操作，以及判断栈是否为空的情况。

接下来将写⼀个函数，检查字符串的每个字符，左括号则进⾏⼊栈操作，右括号则进⾏出栈操作看其是否匹配，最后判断是否为空以判定是否匹配。

主要功能代码如下：int Check(char *str){stack s;InitStack(s);int strn=strlen(str);for(int i=0;i<strn;i++){char a=str[i];switch (a){case '(':case '[':case '{':Push(s,a);break;case ')':if(Pop(s)!='('){return 0;}break;case ']':if(Pop(s)!='['){return 0;}break;case '}':if(Pop(s)!='{'){return 0;}break;}}int re=0;re=Empty(s,re);if(re==1){return 1;}else{return 0;}}⾃此，括号字符串匹配的判断问题已经解决，下⾯贴出完整的经过编译运⾏过的代码。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

#include <iostream>#include <string>#include <stack>#include <fstream>using namespace std;///////////////////////////////////////////////CBalance类//此类对于一般的C++或者C文件进行括号匹配检查//文件可以有注释，字符串……//字符串常量不可以跨行//my.h定义了常用的类库////////////////////////////////////////////class CBalance{private:ifstream fin; //文件流int nCurrentLine; //正在处理的行号int nErrors; //已发现的错误数struct CSymbol //此类记录遇到的字符和字符的行号{char cToken;int nTheLine;};enum CommentType {SlashSlash , SlashStar};//记录//和/*两中注释方式//CheckBalance()函数的工具类//CheckMatch函数用于比较两个符号是否匹配bool CheckMatch(char char1, char char2, int nLine1, int nLine2);//GetNextSymbol函数用于返回读到的括号char GetNextSymbol(void);//PutBackChar用于把字符重新返还给文件流void PutBackChar(char char1);//SkipComment根据注释符的不同跳过源文件的注释void SkipComment(enum CommentType type);//SkipQuote函数用于跳过源文件中的字符串和字符常量void SkipQuote(char type);//NextChar函数用于得到下一个字符char NextChar(void);public:CBalance(const char* filename); //构造函数int CheckBalance(); //检查fin中的字符是否匹配};class noFile{}; //定义的异常类，当函数不存在的时候抛出异常CBalance::CBalance(const char* filename){fin.open(filename);if(!fin) throw noFile();nCurrentLine = 1;nErrors = 0;}int CBalance::CheckBalance(){struct CSymbol node; //符号与行号stack<CSymbol> st; //定义的符号栈char LastChar,Match; //LastChar为读入的符号，Match为栈顶的字符while(LastChar = GetNextSymbol())//从文件中读取括号字符，直到文件结束{//while_beiginswitch (LastChar){ //switch_beigincase '(':case '[':case '{': //遇到这三种符号要进栈node.cToken = LastChar;node.nTheLine = nCurrentLine;st.push(node);break;case ')':case ']':case '}'://遇到这三种括号要进行比较if(st.isEmpty()){nErrors++;cout<<"在第"<<nCurrentLine<<"有一个多余"<<LastChar<<endl;}else{node = st.pop();Match = node.cToken;if(!CheckMatch(Match,LastChar,node.nTheLine,nCurrentLine))nErrors++;}break;}//switch_end}//while_endwhile(!st.isEmpty()) //栈中多余的符号{nErrors++;node = st.pop();cout<<"第"<<node.nTheLine<<"行的符号"<<node.cToken<<"不匹配"<<endl;}return nErrors;}bool CBalance::CheckMatch(char char1, char char2, int nLine1, int nLine2){if(char1=='('&&char2!=')'||char1=='['&&char2!=']'||char1=='{'&&char2!='}') {cout<<"发现第"<<nLine2<<"的符号"<<char2<<"与第"<<nLine1<<"的符号"<<char1<<"不匹配"<<endl;return false;}return true;}char CBalance::GetNextSymbol(){char ch;while(ch=NextChar()){if(ch=='/'){ch=NextChar();if(ch=='/')SkipComment(SlashSlash);else if(ch=='*')SkipComment(SlashStar);else PutBackChar(ch);}else if (ch=='\''||ch=='"'){SkipQuote(ch);}else if (ch=='['||ch=='{'||ch=='('||ch==']'||ch=='}'||ch==')'){return ch;}return NULL;}char CBalance::NextChar(){char ch;if((ch=fin.get())==EOF)return NULL;if(ch=='\n')nCurrentLine++;return ch;}void CBalance::PutBackChar(char char1){fin.putback(char1);if(char1=='\n') nCurrentLine--;}void CBalance::SkipQuote(char type){char ch;while(ch=NextChar()){if(ch==type) return;else if (ch=='\n'){nErrors++;cout<<"在第"<<nCurrentLine<<"行缺少匹配的\'或者\""<<endl;}else if (ch=='\\'){ch = NextChar();}}}void CBalance::SkipComment(enum CommentType type){char ch,flag;if(type==SlashSlash) //对于像//注释一直读到行末尾{while ((ch=NextChar())&&(ch!='\n')){return;}flag='\0'; //对于像/*这样的注释要不断的读文件while((ch=NextChar())!=NULL){if(flag=='*'&&ch=='/')return;flag = ch;}}int main(){try{CBalance b("123.txt"); //文件要在工程当前目录下b.CheckBalance();}catch (noFile& file){cout <<"文件打开失败！"<<endl;}return 0;}（注：文档可能无法思考全面，请浏览后下载，供参考。

可复制、编制，期待你的好评与关注！）。