如何得到操作符的优先级

最新推荐文章于 2022-11-15 16:02:48 发布
最新推荐文章于 2022-11-15 16:02:48 发布
阅读量577 收藏
点赞数
分类专栏： 编译器 文章标签： token div file 编译器 null struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/burnalex/article/details/4340275
版权

C语言的教材中有列出各种操作符的优先级。我们编写编译器的时候可以按早教材中定义的优先级编写程序，但是也可以自己定义。通常这样的优先级用一个表格表示。

所以在编译器程序中也可以用结构体数组来定义这个优先级表( operator priority table),简称OPT

1.首先有个tokentype

typedef enum Token_Type{

  ID,NUM,EXP,/*JUDGE SYMBOL*/

  IF,ELSE,DO,WHILE,SWITCH,CASE,INT,LONG,DOUBLE,FLOAT,CHAR,BREAK,FOR,

  EQ,LS,LE,GT,GE,NE, //EQ =,LS <,LE <= ,GT >, GE >=, NE !=

  ASSIGN, //'='

  ADD,SUB,MUL,DIV,INC,DEC,MOD,//OP + , - , * , / ,++,--

  LC,RC, //  '('  ')'

  LR,RR, //  '['  ']'

  LS,RS, //  '{'  '}'

  OR,AND,NOT, // '|' '&' '!'

  SEMI,// ';'

  SHARP,//'#'

  ENDFILE,

  ERROR

 }TOKEN_TYPE;

2.然后定义优先级结构体
typedef struct Opt{
     TOKEN_TYPE op;
     int Proirity;
    }OPT;
3.然后定义一个优先级表
 OPT opt[NUM_OP]={
    {INC,1},
    {DEC,1},
    {MUL,2},
    {DIV,2},
    {MOD,2},
    {ADD,3},
    {SUB,3}
    }; //biger proirity number,lower proirity
4.写个得到优先级的函数
   int get_proirity(TOKEN_TYPE tt){
    int i;
    for(i=0;i<NUM_OP;i++){
        if(opt[i].op==tt)
        return opt[i].Proirity;
        }
    }
5。扫描函数get token
    TOKEN_TYPE GetToken(void){
    int tokenBufferIndex=0;
    char ch;
    TOKEN_TYPE tt;
    TOKEN_STATE state=INIT;
    while(state!=DONE){
        ch=getc(fps);
        switch(state){
            case INIT: if(isdigit(ch))
                          {
                              state=INNUM;
                              tokenStr[tokenBufferIndex++]=ch;
                              }
                      else if (isalpha(ch)){
                            state=INID;
                            tokenStr[tokenBufferIndex++]=ch;}
                      else if((ch==' ')||ch=='/t') state=INIT;
                      else {
                        switch(ch){
                            case '=' : ch=getc(fps);
                                        if(ch=='=') tt=EQ;
                                        else {
                                        ungetc(ch,fps);
                                        tt= ASSIGN;
                                        }
                                        break;
                            case '<' : ch=getc(fps);
                                        if(ch=='=') tt=LE;
                                        else if(ch=='>') tt=NE;
                                        else {
                                        ungetc(ch,fps);
                                        tt= LS;
                                        }
                                        break;
                            case '>' : ch=getc(fps);
                                        if(ch=='=') tt= GE;
                                        else {
                                        ungetc(ch,fps);
                                        tt= GT;
                                        }
                                        break;
                            case '|':  tt=OR;
                                       state=DONE;
                                       break;
                            case '&':  tt=AND;
                                       state=DONE;
                                       break;
                            case '!':  tt=NOT;
                                       state=DONE;
                                       break;
                            case '+': ch=getc(fps);
                                        if(ch=='+') tt= INC;
                                        else{
                                        tt= ADD;
                                        ungetc(ch,fps);
                                        }
                                        state=DONE;
                                        break;
                            case '-':  ch=getc(fps);
                                        if(ch=='-') tt= DEC;
                                        else{
                                        ungetc(ch,fps);
                                        tt=SUB;
                                        }
                                        state=DONE;
                                        break;
                            case '*':
                                       tt= MUL;
                                       state=DONE;
                                       break;
                            case '/':  state=IN_MARK;
                                       break;
                            case '/n': lineno++;
                                       break;
                            case  '#': tt=SHARP;
                                       break;
                            case ';' : tt= SEMI;
                                       state=DONE;
                                       break;
                            case '(' : tt= LC;
                                       state=DONE;
                                       break;
                            case ')' : tt= RC;
                                       state=DONE;
                                       break;
                            case '[' : tt= LR;
                                       state=DONE;
                                       break;
                            case ']' : tt= RR;
                                       state=DONE;
                                       break;
                            case '{' : tt= LS;
                                       state=DONE;
                                       break;
                            case '}' : tt= RS;
                                       state=DONE;
                                       break;
                            case EOF:
                                       tt=ENDFILE;
                                       state=DONE;
                                       break;
                            default :  break;
                            }
                      }
                      break;
            case IN_MARK:
                            if(ch=='*') state= IN_MARK_SEG;
                            else if(ch=='/') state= IN_MARK_LINE;
                            else {
                                ungetc(ch,fps);
                                tt=DIV;
                                state=DONE;
                            }
                             break;
            case IN_MARK_SEG:
                              if(ch=='*') state=IN_MARK_SEG1;
                              break;
            case IN_MARK_SEG1:
                                if(ch=='/') state=INIT;
                                break;
            case IN_MARK_LINE:
                               if(ch=='/n') state=INIT;
                               break;
            case INNUM: if(isdigit(ch))
                            tokenStr[tokenBufferIndex++]=ch;
                        else
                           { tokenStr[tokenBufferIndex]='/0';
                            state=DONE;
                            ungetc(ch,fps);
                            tt=NUM;
                            }
                             break;
            case INID: if(isalpha(ch))
                            tokenStr[tokenBufferIndex++]=ch;
                        else{
                            tokenStr[tokenBufferIndex]='/0';
                            state=DONE;
                            ungetc(ch,fps);
                            tt=ID;
                            }
                             break;
            case DONE: break;
                     }
      }
      if(tt==ID){
        fprintf(fpt,"Get ID -->%s/n",tokenStr);
       }
      else if(tt==NUM)
       fprintf(fpt,"Get NUM -->%s/n",tokenStr);
     return tt;
    }
6.编写主函数
  //main.c
/*
programed by:alex shoal
edit date:2009-7-11, Satday
revision:2
****************
*Question:How to get the priority of operator?
****************
*/
#include <stdio.h>
#include <stdlib.h>
#include "global.h"
#include "scan.h"
#include "opt.h"
FILE *fps; //* file point of source
FILE *fpt;  //* file point of target
int lineno=0;
int main(int argc, char *argv[]){
TOKEN_TYPE tp;
int j=0;
fpt=stdout;
    if (argc != 2){
        printf("Usage: %s filename/n", argv[0]);
        exit(1);
    }
    if ((fps = fopen(argv[1], "r")) == NULL){
        printf("Can't open file :%s/n", argv[1]);
        exit(1);
    }
     if ((fpt = fopen("out.txt", "w+")) == NULL){
        printf("Can't open file :out.txt /n");
        exit(1);
    }
while (((tp = GetToken()) != ENDFILE)){
    switch (tp){
    case ADD:
         j=get_proirity(tp);
         fprintf(fpt,"the proirity of OP [ADD] is %d/n",j);
         break;
    case SUB:
         j=get_proirity(tp);
         fprintf(fpt,"the proirity of OP [SUB] is %d/n",j);
         break;
    case MUL:
         j=get_proirity(tp);
         fprintf(fpt,"the proirity of OP [MUL] is %d/n",j);
         break;
    case DIV:
         j=get_proirity(tp);
         fprintf(fpt,"the proirity of OP [DIV] is %d/n",j);
         break;
    case INC:
         j=get_proirity(tp);
         fprintf(fpt,"the proirity of OP [INC] is %d/n",j);
         break;
    case DEC:
         j=get_proirity(tp);
         fprintf(fpt,"the proirity of OP [DEC] is %d/n",j);
         break;
    default:
         break;
        }
}
    fclose(fps);
  return 0;
}
7. 编译程序，得到可执行程序 比如可执行文件名为 opt.exe
8。写个输入文件，含一些操作符
    //filename: in.txt
    a + b - c * 3  / 2 + i++ - j--
9. 运行程序
   opt.ext in.txt
10。产看结果，从程序主函数中可看到，
    运行之后有个 out.txt 产生。
   打开 out.txt 可看到内容
 Get ID -->a
the proirity of OP [ADD] is 3
Get ID -->b
the proirity of OP [SUB] is 3
Get ID -->c
the proirity of OP [MUL] is 2
Get NUM -->3
the proirity of OP [DIV] is 2
Get NUM -->2
the proirity of OP [ADD] is 3
Get ID -->i
the proirity of OP [INC] is 1
the proirity of OP [SUB] is 3
Get ID -->j
the proirity of OP [DEC] is 1
由此可见函数运行基本正常。

浴缸里跑马
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lingo_ 运算符及其优先级和函数总览
goog
08-18 8944
1.运算符及其优先级 现在归纳一下 LING0 中的三类运算 符:算术运算符、逻辑运算符和关系运算符。 算术运算符有 5 种:+(加法)，—(减法或负号)，*(乘法)，/(除法)，^(求幂)。 逻辑运算符有 9 种:#AND#(与)，#OR#(或)，#NOT#(非)，#EQ#(等于)，#NE# (不等于)，#GT#(大于)，#GE#(大于等于)，#LT#(小于)，#LE#(小于等于)。 逻 ...
C语言操作符详解和优先级问题
weixin_59406869的博客
05-15 1341
C语言是底层语言，因为其操作符便能直接操作到内存中存储的二进制位，使用起来灵活方便，为此我认为有必要专门写一篇博客总结C语言的操作符然后分享给大家，没有深入了解过的朋友一定能够在此有所收获，如果喜欢点赞收藏支持一下吧！👍⭐ 1.算数操作符 + - * / %--------------- （加，减，乘，除，取模） 算数操作符也和数学上的定义是一样的，不必过多介绍，不过...
各种操作符及其优先级
AC_Arthur的专栏
07-15 1351
优先级 运算符 名称或含义 使用形式 结合方向 说明 1 [] 数组下标 数组名[整型表达式] 左到右   () 圆括号 （表达式）/函数名(形参表)   . 成员选择（对象） 对象.成员名  
操作符的优先级更高!
shazhugw的博客
06-28 593
请注意，指针引用必须括在括号中，因为成员选择运算符比解引用操作符的优先级更高。 因为访问结构和类成员的指针是通过笨拙的语法，C++提供了一个二成员选择运算符（->）从指针做成员选择。以下两行是等价的： 1 2 3 4 5 6 7 8 9 10 struct Person { int age; double weight; }; Person person; // Membe
运算符优先级的比较
Chason的博客
01-29 5625
一段代码 int main(int argc, const char * argv[]) { char s[100]; gets(s); char *t = s; printf("%c %c\n",*t+1,*(t+1)); return 0; } 输入&输出 aa b a 在这之前我一直有个错误认识，那就是「+」运算符的优先级是高于「*」
main_进程调度_操作系统优先级进程调度算法_
09-29
1. **进程描述符**：操作系统需要一个数据结构（如PCB - 进程控制块）来存储每个进程的状态、优先级和其他相关信息。 2. **优先级设置**：每个进程被分配一个优先级值，可能是固定或者动态调整的。 3. **调度函数*...
【C语言】操作符大全万字详解
最新发布
我的主页
11-15 3499
本期讲解：原码、反码、补码的计算，以及各种操作符的运算规则，如+、-、*、/、%、&、*、|、[]、()、等等，最后还附有优先级从高到低的表格参考。
一元操作符、强制类型转换表达式、乘除操作符、加法操作符、移位操作符、关系操作符、判等操作符、位操作符与逻辑操作符、条件与操作符、条件或操作符--运算机制与返回值
norang的博客
01-07 673
这里写目录标题一元操作符前缀递增操作符 ++前缀递增操作符 - -一元加号操作符 +一元加号操作符 -按位取反操作符 ~逻辑取反操作符 ！强制类型转换表达式乘除操作符乘法操作符 *除法操作符 /取余操作符 %加减操作符字符串连接操作符 +用于数字类型的加减操作符（ + 和 -）移位操作符关系操作符数字比较操作符 <、<=、>和>=类型比较操作符 instanceof判等操作符数字判等操作符 == 和 !=布尔判等操作符 == 和 !=引用判等操作符 == 和 != 表达式就是操作数和
按位操作符
12-09
按位操作符是编程语言中一组特殊的运算符，它们对整型变量的二进制表示进行操作，而不是对数值本身进行运算。这些操作符在处理二进制数据、位掩码或者进行高效的位级逻辑运算时非常有用。下面将详细阐述几种常见的按...
操作符优先级全列表，一览表
一骑绝尘的专栏
08-04 5137
在一个表达式中可能包含多个有不同运算符连接起来的、具有不同数据类型的数据对象；由于表达式有多种运算，不同的运算顺序可能得出不同结果甚至出现错误运算错误，因为当表达式中含多种运算时，必须按一定顺序进行结合，才能保证运算的合理性和结果的正确性、唯一性。 优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。表达式的结合次序取决于表达式中各种运算符的优先级。优先级高的运算符先
【数据结构】比较运算符优先级的函数（栈实现表达式的计算）
phantom的博客
11-03 3226
记下来！！！很重要，很方便。 char Precede(char theta1,char theta2) { if((theta1=='('&&theta2==')')||(theta1=='#'&&theta2=='#')) return '='; else if(theta1=='('||theta1=='#'||theta2=='('||(theta1=='+'||theta1=='-')&&(theta2=='*'||theta
C64X EDMA优先级及优先级队列
byebyegov5qq
02-20 193
C64X EDMA优先级及优先级队列 下图为EDMA传输请求方框图： 从图中我们可以看到，请求有三种： l L2控制器传输请求：L2控制器发布所有用于CACHE服务的传输请求：如存取非CACHE内存、QDMA传输等。对C64x DSP，CACHE服务请求可以在任何优先级上产生，这可以通过CACHE配置寄存器（CCFG）的P位来设置。对于读请求，CACHE控制器对一个L2行，总是以2个突发...
C语言符号的优先级
热门推荐
xiaoxiaoyu
04-20 3万+
一. C语言总共有15个优先级，下面我将一一介绍 数字越大所代表的优先级越高 二. 15优先级有： 强制，下标，成员，结合性为从左向右，从左向右其实就是我们正常的数学运算符的结合性 强制：（）这个符号所代表的含义可以有 类型转换，参数表，函数调用。 下标：[] 就是数组元素的下标。 成员： -&gt; 与. 这两个符号代表的是结构型和共用型成员。 14优先级有：逻辑，位，算术，指针，算...
操作符的优先级
zhang_zhilai的博客
05-21 1503
*p++和（*p）++的区别：*p++等价于*p，然后p++（*p）++等价于（*p），然后对*p的值进行++ 
字符串处理函数 以及优先级总结
qq_41915323的博客
12-01 1084
一、强制类型转换 语法格式：（类型）表达式 例，int x=5； float b=3.5； x=x+（int）y； y的值是3.5，在进行运算时强制转换成int型，值为3参与运算。运算结束后，y的值仍然是3.5，float型。 二、sizeof 运算符 单目运算符，以字节形式给出其操作数的存储空间的大小。判断数据类型的字节长度。 例，确定整形数据类型的字节长度。 源程序： #include&amp;lt;...
编译器练习：将C程序中的注释中的小写字母转换为大写字母
跑上岸晒太阳的鱼滴空间
03-17 1327
/*filename:notes.cprogramed by:alex shoaledit date:2009-2-9revision:1****************reference:"compiler construction principles and practice"  page 42~43 DFA design*****************/#include #include
编译器练习：将C程序中的除注释外的所有保留字全部大写
跑上岸晒太阳的鱼滴空间
03-18 1260
/*programed by:alex shoaledit date:2009-3-22, Sunday revision:2*****************Program Objective:将C程序中的除注释外的所有保留字全部大写*****************int,long,float,double,bool,char,if,while,switch,case,continue,bre
C语言基础：操作符优先级详解及示例
例如，在第一个谜题1.1.1中，`x=-3+4*5-6`，根据操作符优先级表，先执行乘法`4*5`，然后是加法和减法，最终结果是`11`。作者建议读者仔细查看附录A的操作符优先级表，以便正确解析这些表达式。 在解答1.1.2的表达式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值