xml地图|网站地图|网站标签 [设为首页] [加入收藏]

正规赌博平台

当前位置:网上十大正规赌博平台 > 正规赌博平台 > 逆波兰计算器,返回数组中当前的键值对并将数

逆波兰计算器,返回数组中当前的键值对并将数

来源:http://www.nb-machinery.com 作者:网上十大正规赌博平台 时间:2019-07-10 22:47

   源自《The C Programming Language》 P62 ex4.3:

each函数返回数组中当前的键/值对并将数组指针向前移动一步

      C语言程序可以看成由一系列外部对象构成,这些外部对象可能是变量或函数。而内部变量是指定义在函数内部的函数参数及变量。外部变量定义在函数之外,因此可以在许多函数中使用。由于C语言不允许在一个函数中定义其它函数,因此函数本身只能是“外部的”。
      由于C语言代码是以文件为单位来组织的,在一个源程序所有源文件中,一个外部变量或函数只能在某个文件中定义一次,而其它文件可以通过extern声明来访问它(定义外部变量或函数的源文件中也可以包含对该外部变量的extern声明)。
      而static则可以限定变量或函数为静态存储。如果用static限定外部变量与函数,则可以将该对象的作用域限定为被编译源文件的剩余部分。通过static限定外部对象,可以达到隐藏外部对象的目的。因而,static限定的变量或函数不会和同一程序中其它文件中同名的相冲突。如果用static限定内部变量,则该变量从程序一开始就拥有内存,不会随其所在函数的调用和退出而分配和消失。
   C语言中使用静态函数的好处

     计算例如:(1 - 2) * (4 5)的值,采用逆波兰表示法(即后缀表示法)

基本语法

  1.       静态函数会被自动分配在一个一直使用的存储区,直到退出应用程序实例,避免了调用函数时压栈出栈,速度快很多。
  2.       关键字“static”,译成中文就是“静态的”,所以内部函数又称静态函数。但此处“static”的含义不是指存储方式,而是指对函数的作用域仅局限于本文件。 使用内部函数的好处是:不同的人编写不同的函数时,不用担心自己定义的函数,是否会与其它文件中的函数同名,因为同名也没有关系。

   代码:

array each ( array &$array )

c语言中static的语义 1.static变量:
网上十大正规赌博平台,1).局部
a.静态局部变量在函数内定义,生存期为整个源程序,但作用域与自动变量相同,只能在定义该变量的函数内使用。退出该函数后, 尽管该变量还继续存在,但不能使用它。
b.对基本类型的静态局部变量若在说明时未赋以初值,则系统自动赋予0值。而对自动变量不赋初值,则其值是不定的。
2).全局
全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。但是他们的作用域,非静态全局 变量的作用域是整个源程序(多个源文件可以共同使用); 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效, 在同一源程序的其它源文件中不能使用它。
2.static函数(也叫内部函数)
只能被本文件中的函数调用,而不能被同一程序其它文件中的函数调用。区别于一般的非静态函数(外部函数)
    static在c里面可以用来修饰变量,也可以用来修饰函数。
         先看用来修饰变量的时候。变量在c里面可分为存在全局数据区、栈和堆里。其实我们平时所说的堆栈是栈而不包含对,不要弄混。
        int a ;
        main()
        {
             int b ;
             int c* = (int *)malloc(sizeof(int));
        }
        a是全局变量,b是栈变量,c是堆变量。
        static对全局变量的修饰,可以认为是限制了只能是本文件引用此变量。有的程序是由好多.c文件构成。彼此可以互相引用变量,但加入static修饰之后,只能被本文件中函数引用此变量。
        static对栈变量的修饰,可以认为栈变量的生命周期延长到程序执行结束时。一般来说,栈变量的生命周期由OS管理,在退栈的过程中,栈变量的生命也就结束了。但加入static修饰之后,变量已经不在存储在栈中,而是和全局变量一起存储。同时,离开定义它的函数后不能使用,但如再次调用定义它的函数时,它又可继续使用, 而且保存了前次被调用后留下的值。
       static对函数的修饰与对全局变量的修饰相似,只能被本文件中的函数调用,而不能被同一程序其它文件中的函数调用。 
      static 声明的变量在C语言中有两方面的特征:
  1)、变量会被放在程序的全局存储区中,这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 
  2)、变量用static告知编译器,自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。

     main.c

在执行 each() 之后,数组指针将停留在数组中的下一个单元或者当碰到数组结尾时停留在最后一个单元。如果要再用 each 遍历数组,必须使用 reset() 。

  问题:Static的理解

网上十大正规赌博平台 1网上十大正规赌博平台 2View Code

参数介绍:

  关于static变量,请选择下面所有说法正确的内容:

  1 #include <stdio.h>
  2 #include <stdlib.h>            //为了使用库函数atof
  3 #include <math.h>            //使用sin, exp, pow等数学函数
  4 #include <string.h>            //使用strcmp, strlen等字符串函数
  5 #include "getop.h"
  6 
  7 #define        MAXOP        100    //操作数或运算符的最大长度(待处理字符串的最大长度)
  8 #define        NUMBER        '0'    //标识找到一个数
  9 #define        NAME        'n' //标示找到一个数学函数
 10 
 11 void push(double );
 12 double pop();
 13 //void printStack(double []);
 14 void clear();
 15 void mathfnc(char []);
 16 
 17 //extern double val[];        //如果声明为extern val[]; 则报错:变量val被重定义
 18 //extern sp;
 19 
 20 //逆波兰计算器
 21 int main()
 22 {
 23 
 24     int type;
 25     int i;
 26     int var;
 27     double op2;
 28     double op1;
 29     double variable[26];
 30     double v;
 31     //double tmp;
 32     char s[MAXOP];
 33 
 34     var = 0;
 35     for(i = 0; i < 26;   i)
 36         variable[i] = 0.0;
 37     while((type = getop(s)) != EOF)
 38     {
 39         switch(type)
 40         {
 41         case NUMBER:        //当待处理字符串是数值字符串时,将其转换,并压栈
 42             push(atof(s));
 43             break;
 44 
 45         case ' ':
 46             push(pop()   pop());
 47             break;
 48 
 49         case '*':
 50             push(pop() * pop());
 51             break;
 52 
 53         case '-':
 54             op2 = pop();
 55             push(pop() - op2);    //push(pop() - pop());是错误的,虽然算法运算符中操作数的结合方式是从左到右
 56                                 //但是不能确定push参数中左边的pop函数一定比右边的pop函数先执行
 57             break;
 58 
 59         case '/':
 60             op2 = pop();
 61             if(op2 != 0.0)
 62                 push(pop() / op2);
 63             else
 64             {
 65                 printf("error: divide 0.0!");
 66                 return -1;
 67             }
 68             break;
 69 
 70         case '%':
 71             op2 = pop();
 72             if(op2 != 0.0)
 73                 push(fmod(pop(), op2));
 74             else
 75                 printf("error: mod 0.0!");
 76             break;
 77 
 78         case '=':
 79             pop();
 80             if(var >= 'A' && var <= 'Z')
 81             {
 82                 variable[var - 'A'] = pop();
 83                 push(variable[var - 'A']);
 84             }
 85             else
 86                 printf("error: no variable namen");
 87             break;
 88 
 89         case 'n':        //当键入换行符时,打印输出栈顶元素
 90             /*if(sp > 0)
 91                 printStack(val);
 92             else
 93                 printf("error: stack empty!n");
 94             */
 95             v = pop();
 96             printf("the result = %.8gn", v);
 97             break;
 98 
 99         case 'p':        //不出栈的情况下,打印栈顶元素
100             op2 = pop();
101             printf("the top element of stack = %fn", op2);
102             push(op2);
103             break;
104 
105         case 'd':        //复制栈顶元素
106             op2 = pop();
107             //tmp = op2;
108             //printf("the duplication of top element = %fn", op2);
109             push(op2);
110             push(op2);
111             printf("the duplication of top element = %fn", op2);
112             break;
113 
114         /*case 'S':
115             push(sin(pop()));
116             break;
117 
118         case 'E':
119             push(exp(pop()));
120             break;
121 
122         case 'P':
123             op2 = pop();
124             push(pow(pop(), op2));
125             break;
126         */
127 
128         case NAME:        //处理数学函数分支,这样比上面分别用每个命令来定义一个函数要通用,并容易扩展
129             mathfnc(s);
130             break;
131 
132         case 's':        //交换栈顶元素
133             op2 = pop();
134             op1 = pop();
135             push(op1);
136             push(op2);
137             break;
138 
139         case 'c':        //清空堆栈
140             clear();
141             break;
142 
143         default:
144             if(type >= 'A' && type <= 'Z')
145                 push(variable[type - 'A']);
146             else if(type == 'v')
147                 push(v);
148             else
149                 printf("error: unknown command %s", s);
150             break;
151 
152         }
153         var = type;
154     }
155 
156     return 0;
157 }
158 
159 #define        MAXVAL        100        //栈val的最大深度
160 
161 int sp = 0;                        //栈中的下一个空闲的位置
162 double val[MAXVAL];                //值栈
163 
164 void push(double f)                //把f压入值栈中
165 {
166     if(sp < MAXVAL)
167         val[sp  ] = f;
168     else
169         printf("error: stack full, can't push %gn", f);
170 }
171 
172 double pop()                    //从值栈中弹出并返回栈顶的值
173 {
174     if(sp > 0)
175         return val[--sp];
176     else
177     {
178         printf("error: stack empty, can't popn");
179         return 0.0;
180     }
181 }
182 
183 /*void printStack(double* val)
184 {
185     printf("top of stack = %fn", val[sp-1]);
186 }
187 */
188 
189 void clear()                    //清空值栈
190 {
191     sp = 0;
192 
193     return;
194 
195 }
196 
197 void mathfnc(char s[])            //数学函数处理的通用接口
198 {
199     double op2;
200 
201     if(strcmp(s, "sin") == 0)
202         push(sin(pop()));
203     else if(strcmp(s, "cos") == 0)
204         push(cos(pop()));
205     else if(strcmp(s, "exp") == 0)
206         push(exp(pop()));
207     else if(strcmp(s, "pow") == 0)
208     {
209         op2 = pop();
210         push(pow(pop(), op2));
211     }
212     else
213         printf("error: %s not supported!n", s);
214     
215 }
参数 描述
array 必需。规定要使用的数组。

  A、若全局变量仅在单个C文件中访问,则可以将这个变量修改为静态全局变量,以降低模块间的耦合度;

   getop.c

each() 函数生成一个由数组当前内部指针所指向的元素的键名和键值组成的数组,并把内部指针向前移动。

  B、若全局变量仅由单个函数访问,则可以将这个变量改为该函数的静态局部变量,以降低模块间的耦合度;

网上十大正规赌博平台 3网上十大正规赌博平台 4View Code

返回值:

  C、设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时,需要考虑重入问题;

  1 #include <stdio.h>
  2 #include <ctype.h>
  3 #include <string.h>
  4 #include "getop.h"
  5 
  6 //extern NUMBER;
  7 #define        NUMBER        '0'
  8 #define        NAME        'n'
  9 
 10 int getop(char s[])        //获取下一个运算符或操作数
 11 {
 12     int i;
 13     int c;
 14 
 15     while((s[0] = c = getch()) == ' ' || c == 't')
 16         ;
 17     s[1] = '\0';
 18     i = 0;
 19     if(c != '-' && !islower(c) && !isdigit(c) && c != '.')    //判断是否属于这四种情况,如不是,下面分别对这四种情况处理
 20         return c;        //当是运算符或大写字母时,返回其ASCII值
 21     if(c == '-')
 22         if(isdigit(c = getch()) || c == '.')
 23             s[  i] = c;
 24         else
 25         {
 26             if(c != EOF)
 27                 ungetch(c);
 28             return '-';
 29         }
 30     if(islower(c))
 31     {
 32         while(islower(s[  i] = c = getch()))
 33             ;
 34         s[i] = '\0';
 35         if(c != EOF)
 36             ungetch(c);
 37         if(strlen(s) > 1)
 38             return NAME;
 39         else
 40             return s[0];                //错误:return c;例: s = "v ",如果用return c;则会返回空格,而本意是返回v
 41     }
 42     if(isdigit(c))
 43         while(isdigit(s[  i] = c = getch()))    //收集整数部分
 44             ;
 45     if(c == '.')
 46         while(isdigit(s[  i] = c = getch()))    //收集小数部分
 47             ;
 48     s[i] = '\0';
 49     if(c != EOF)
 50         ungetch(c);
 51 
 52     return NUMBER;        //当是操作数时,返回NUMBER,标识这种情况
 53 }
 54 
 55 #define        BUFSIZE        100        //缓冲区的最大长度
 56 
 57 //int buf[BUFSIZE];                //这样可以正确处理压回EOF(-1)及其他任何负数的情况
 58 char buf[BUFSIZE];                //用于ungetch函数的缓冲区
 59 int bufp = 0;                    //buf中下一个空闲位置
 60 
 61 int getch()                        //取一个字符(可能是要压回的字符)
 62 {
 63     return (bufp > 0) ? buf[--bufp] : getchar();
 64 }
 65 
 66 void ungetch(int c)                //把字符压回到输入(缓冲区)中
 67 {
 68     if(bufp >= BUFSIZE)
 69         printf("ungetch: too many charactersn");
 70     else
 71         buf[bufp  ] = c;
 72 }
 73 
 74 /************************************************************************
 75 另一种getch ungetch函数,最多只压回一个字符,则缓冲区大小为1个字节即可
 76 *************************************************************************
 77 char buf = 0;
 78 
 79 int getch()
 80 {
 81     int c;
 82 
 83     if(buf != 0)
 84         c = buf;
 85     else
 86         c = getchar();
 87     buf = 0;
 88 
 89     return c;
 90 }
 91 
 92 void ungetch(int c)
 93 {
 94     if(buf != 0)
 95         printf("error: too many charactersn");
 96     else
 97         buf = c;
 98 }
 99 ***********************************************************************/
100 
101 /**********************************************************************
102 另一种getop函数:不使用函数ungetch,而是使用一个static变量来代替缓冲区
103 ***********************************************************************
104 int getop(char s[])        //获取下一个运算符或操作数
105 {
106     int i;
107     int c;
108     static int lastc = 0;
109 
110     if(lastc == 0)
111         c = getch();
112     else
113     {
114         c = lastc;
115         lastc = 0;
116     }
117     while((s[0] = c) == ' ' || c == 't')
118         c = getch();
119     s[1] = '\0';
120     i = 0;
121     if(c != '-' && !islower(c) && !isdigit(c) && c != '.')    //判断是否属于这四种情况,如不是,下面分别对这四种情况处理
122         return c;        //当是运算符或大写字母时,返回其ASCII值
123     if(c == '-')
124         if(isdigit(c = getch()) || c == '.')
125             s[  i] = c;
126         else
127         {
128             if(c != EOF)
129                 lastc = c;
130             return '-';
131         }
132     if(islower(c))
133     {
134         while(islower(s[  i] = c = getch()))
135             ;
136         s[i] = '\0';
137         if(c != EOF)
138             lastc = c;
139         if(strlen(s) > 1)
140             return NAME;
141         else
142             return s[0];    //错误:return c;例: s = "v ",如果用return c;则会返回空格,而本意是返回v
143     }
144     if(isdigit(c))
145         while(isdigit(s[  i] = c = getch()))    //收集整数部分
146             ;
147     if(c == '.')
148         while(isdigit(s[  i] = c = getch()))    //收集小数部分
149             ;
150     s[i] = '\0';
151     if(c != EOF)
152         lastc = c;
153 
154     return NUMBER;        //当是操作数时,返回NUMBER,标识这种情况
155 }
156 ***********************************************************************/

返回 array 数组中当前指针位置的键/值对并向前移动数组指针。键值对被返回为四个单元的数组,键名为0,1,key和 value。单元 0 和 key 包含有数组单元的键名,1 和 value 包含有数据。如果内部指针越过了数组的末端,则 each() 返回 FALSE 。

  D、静态全局变量过大,可那会导致堆栈溢出。

  getop.h   

each函数实例一:

  答案与分析:

网上十大正规赌博平台 5网上十大正规赌博平台 6View Code

<?php
$foo = array(
  "bob",
  "fred",
  "jussi",
  "jouni",
  "egon",
  "marliese"
);
$bar = each($foo);
print_r($bar);
?> 

  对于A,B:根据本篇概述部分的说明b),我们知道,A,B都是正确的。

 1 #ifndef    _GETOP_H_
 2 #define    _GETOP_H_
 3 
 4 //#include <stdio.h>
 5 //#include <stdlib.h>
 6 //#include <ctype.h>
 7 
 8 //#define        MAXOP        100
 9 //#define        NUMBER        '0'
10 
11 int getch();
12 void ungetch(int);
13 int getop(char []);
14 
15 #endif

运行结果;

  对于C:根据本篇概述部分的说明a),我们知道,C是正确的(所谓的函数重入问题,下面会详细阐述)。

   分析:

Array
(
    [1] => bob
    [value] => bob
    [0] => 0
    [key] => 0
)

  对于D:静态变量放在程序的全局数据区,而不是在堆栈中分配,所以不可能导致堆栈溢出,D是错误的。

     1,  程序设计:在设计本程序时,首先进行模块划分,

each函数实例二:

  因此,答案是A、B、C。

          main.c:main函数 实现操作数压栈,出栈,算术运算,数学运算,打印 复制 交换栈顶元素等基本操作;

each() 结合 list()遍历数组

  问题:不可重入函数

                       push函数 实现将double型数据压入值栈val中;

<?php
$fruit = array(
  'a' => 'apple',
  'b' => 'banana',
  'c' => 'cranberry'
);
reset($fruit);
while (list($key, $val) = each($fruit)) {
  echo " $key => $val <br/>";
}
?> 

  曾经设计过如下一个函数,在代码检视的时候被提醒有bug,因为这个函数是不可重入的,为什么?

                       pop函数 实现将值栈val中的栈顶元素出栈;

运行结果:

unsigned int sum_int( unsigned int base )
{
 unsigned int index;
 static unsigned int sum = 0; // 注意,是static类型的。
 for (index = 1; index <= base; index )
 {
  sum = index;
 }
 return sum;
}

                       clear函数 实现清空值栈val;

a => apple
b => banana
c => cranberry

  答案与分析:

本文由网上十大正规赌博平台发布于正规赌博平台,转载请注明出处:逆波兰计算器,返回数组中当前的键值对并将数

关键词: mg线上娱乐