精华内容
下载资源
问答
  • C语言C语言赋值语句规则

    万次阅读 多人点赞 2017-04-09 20:30:24
    赋值语句的使用中需要注意以下几点: 由于在赋值符“=”右边的表达式也可以又是一个赋值表达式, 因此,下述形式 变量=(变量=表达式); 是成立的,从而形成嵌套的情形。 其展开之后的一般形式为:变量=变量=…=...

    赋值语句是由赋值表达式再加上分号构成的表达式语句。

    其一般形式为: 变量=表达式;

    在赋值语句的使用中需要注意以下几点:

    1. 由于在赋值符“=”右边的表达式也可以又是一个赋值表达式, 因此,下述形式 变量=(变量=表达式); 是成立的,从而形成 嵌套的情形。 其展开之后的一般形式为:变量=变量=…=表达式; 例如: a=b=c=d=e=5; 按照赋值运算符的右接合性,因此实际上等效于: e=5; d=e; c=d; b=c; a=b;

    2. 注意在变量==说明==中给变量赋初值和赋值语句的区别。 给变量赋初值是变量说明的一部分,赋初值后的变量与其后的其它同类变量之间仍必须用逗号间隔,而赋值语句则必须用分号结尾。 例如: int a=5,b,c;

    3. 在变量说明中,不允许连续给多个变量赋初值。 如下述说明是错误的: int a=b=c=5 必须写为 int a=5,b=5,c=5; 而赋值语句允许连续赋值。

    4. 注意赋值表达式和赋值语句的区别。 赋值表达式是一种表达式,它可以出现在任何允许表达式出现的地方,而赋值语句则不能。

    下述语句是合法的:
    if((x=y+5)>0) z=x;

    这里(x=y+5)是赋值表达式,语句的功能是,若表达式x=y+5大于0则z=x。

    下述语句是非法的:

    if((x=y+5;)>0) z=x;

    因为x=y+5;是语句,不能出现在表达式中。

    展开全文
  • 这里给出两种思路,都比王爽老师书上做法要简单高效,事实上,理解指令本质,就能达到灵活应用,这样才能打破规则 题目:将内存ffff:0 - ffff:b数据,复制到内存ffff:10 - ffff:1b中 备注:使用8086汇编语言...

    0 前言

    这里给出两种思路,都比王爽老师书上的做法要简单高效,事实上,理解指令的本质,就能达到灵活应用,这样才能打破规则

    题目:将内存ffff:0 - ffff:b的数据,复制到内存ffff:10 - ffff:1b中

    备注:使用8086汇编语言

    本篇的核心是:分别使用8086、x86-32和C语言,理解内存空间的复制

    1 思路一:使用push、pop指令

    push,pop指令的本质,是内存传送指令,它也是送数据的。

    例如pop DS:[EA]本质是mov DS:[EA],SS:[SP]

    ; 思路一:使用push,pop内存转移指令,注意是字型数据,2个2个搬运
    assume cs:code
    code segment
    start:
    	; DS:[bx]指向0:200
    	mov ax,0
    	mov ds,ax
    	mov bx,0200h
    	
    	; 设置栈顶
    	mov ax,0ffffh
    	mov ss,ax
    	mov sp,0
    	
    	; 设置循环
    	mov cx,6
    	s:
    		pop [bx]
    		add bx,2  ; 一次copy一个字
    		loop s
    		
    	mov ax,04c00h
    	int 021h
    code ends
    end start
    

    2 思路二:使用段前缀

    完全没有必要一个字节一个字节传送,这样需要字节扩展为字再使用,效率低下。

    ; 思路二:使用段前缀
    assume cs:code
    code segment
    
    start:
    	mov ax,0ffffh
    	mov ds,ax
    	mov ss,ax
    	
    	mov bx,0
    	mov cx,6
    	s: 
    		mov dx,ds:[bx]
    		mov ss:[bx+10h],dx
    		add bx,2
    		loop s
    		
    	mov ax,04c00h
    	int 021h
    code ends
    end start
    

    3 结合C语言和x86-32汇编语言

    这个题目,本质上对应于C语言的基本模型:赋值语句,例如int a = b;

    int a = 2;
    int b;
    b = a;
    

    对应汇编语言

    int a = 2;
    mov dword ptr [a],2
    
    int b
    b = a;
    mov eax,dword ptr [a]
    mov dword ptr [b],eax
    

    这里也可以看出int b;变量声明,是不会生成汇编代码的,它的本质就是给某个内存段做个标记,叫b,且它占连续的4个字节

    4 第3部分的扩展:连续内存空间的copy

    先来看一个基本数组

    int a[10] = { 1,23,4,4,5,6,77,0 };
    

    对应的汇编

    00184198  mov         dword ptr [a],1  
    0018419F  mov         dword ptr [ebp-28h],17h  
    001841A6  mov         dword ptr [ebp-24h],4  
    001841AD  mov         dword ptr [ebp-20h],4  
    001841B4  mov         dword ptr [ebp-1Ch],5  
    001841BB  mov         dword ptr [ebp-18h],6  
    001841C2  mov         dword ptr [ebp-14h],4Dh  
    001841C9  mov         dword ptr [ebp-10h],0  
    001841D0  xor         eax,eax  
    001841D2  mov         dword ptr [ebp-0Ch],eax  
    001841D5  mov         dword ptr [ebp-8],eax 
    

    这里有一个值得注意的地方,就是寄存器的清零,这里使用了xor eax,eax,一个数跟自己异或,再赋值给自己,必然是0,这个用法比较新奇。当然也可以使用基本语句mov eax,0

    另外,你可以知道

    1. 数组被分配了一段连续的内存空间,共40字节
    2. 地址顺序与数组标号顺序一致,都是从小到大
    3. 没有被赋值的,默认赋值为0

    如果想要将整个数组的内容,复制到另外一个数组int b[10]怎么办?

    最容易想到的做法是,直接循环递增复制

    int a[10] = { 1,23,4,4,5,6,77,0 };
    
    int b[10];
    for (int i = 0; i < 10; i++) {
    	b[i] = a[i];
    }
    

    对应的汇编语言

         1: 	for (int i = 0; i < 10; i++) {
    00DB4D21  mov         dword ptr [ebp-78h],0  
    00DB4D28  jmp         00DB4D33  
    00DB4D2A  mov         eax,dword ptr [ebp-78h]  
    00DB4D2D  add         eax,1  
    00DB4D30  mov         dword ptr [ebp-78h],eax  
    00DB4D33  cmp         dword ptr [ebp-78h],0Ah  
    00DB4D37  jge         00DB4D49  
         2: 		b[i] = a[i];
    00DB4D39  mov         eax,dword ptr [ebp-78h]  
    00DB4D3C  mov         ecx,dword ptr [ebp-78h]  
         3: 		b[i] = a[i];
    00DB4D3F  mov         edx,dword ptr [ebp+ecx*4-30h]  
    00DB4D43  mov         dword ptr [ebp+eax*4-6Ch],edx  
         4: 	}
    00DB4D47  jmp         00DB4D2A
    

    这种拷贝方式,就是一个个拷贝,很容易想到,但是在C语言中,这一点都不酷,不过这种做法与最开始8086汇编的思路是一致的,一点点转移过去,应该有更酷的内容被使用。

    此外,应该了解小知识点是 【寻址方式】,对于语句mov edx,dword ptr [ebp+ecx*4-30h]中的[ebp+ecx*4-30h],地址形成的方式是 ebp + ecx*常数 + 常数

    更酷的方式是memcpy函数(memory copy),也就是内存复制。

    int a[10] = { 1,23,4,4,5,6,77,0 };
    int b[10];
    memcpy(&b, &a,sizeof(a));
    

    这样,就能够直接将整个内存空间拷贝到另外一段内存空间了,不过,这种做法其实就是直接使用封装的函数,本质还是一点点拷贝过去。但是对于高级语言来说,应该更多地使用已经封装好的常用函数,以提高效率。

    对于memcoy的用法,简单说明,(1,2,3)

    • 1放的是目标的内存地址空间的首地址,这里是&b
    • 2放的是源内存地址空间的首地址,这里是&a
    • 3放的是需要拷贝过去地址空间的大小,这里是sizeof(a),也就是40个字节
    展开全文
  • 前言在Python中变量名规则与其他大多数高级语言一样,都是受C语言影响,另外变量名是大小写敏感。Python是动态类型语言,也就是说不需要预先声明变量类型,变量类型和值在赋值那一刻被初始化,下面详细介绍了...

    前言

    在Python中变量名规则与其他大多数高级语言一样,都是受C语言影响的,另外变量名是大小写敏感的。

    Python是动态类型语言,也就是说不需要预先声明变量类型,变量的类型和值在赋值那一刻被初始化,下面详细介绍了Python的变量赋值问题,一起来学习学习吧。

    我们先看一下如下代码:

    c = {}

    def foo():

    f = dict(zip(list("abcd"), [1, 2 ,3 ,4]))

    c.update(f)

    if __name__ == "__main__":

    a = b = d = c

    b["e"] = 5

    d["f"] = 6

    foo()

    print(a)

    print(b)

    print(c)

    print(d)

    输出结果:

    {"a": 1, "c": 3, "b": 2, "e": 5, "d": 4, "f": 6}

    {"a": 1, "c": 3, "b": 2, "e": 5, "d": 4, "f": 6}

    {"a": 1, "c": 3, "b": 2, "e": 5, "d": 4, "f": 6}

    {"a": 1, "c": 3, "b": 2, "e": 5, "d": 4, "f": 6}

    如果你对以上输出结果不感到奇怪,那么就不必往下看了。实际上本文要讨论的内容非常简单,不要为此浪费您宝贵的时间。

    Python 属于动态语言,程序的结构可以在运行的过程中随时改变,而且 python 还是弱类型的语言,所以如果你是从静态、强类型编程语言转过来的,理解起 Python 的赋值,刚开始可能会感觉有些代码有点莫名其妙。

    可能你会以为上面代码的输出会是这样的:

    {}

    {"e": 5}

    {}

    {"f": 6}

    你可能认为 a 没有被改变,因为没有看到哪里对它做了改变;b 和 d 的改变是和明显的;c 呢,因为是在函数内被改变的,你可能认为 c 会是一个局部变量,所以全局的 c 不会被改变。

    实际上,这里的 a, b, c, d 同时指向了一块内存空间,这可内存空间保存的是一个字典对象。这有点像 c 语言的指针,a, b, c, d 四个指针指向同一个内存地址,也就是给这块内存其了 4 个笔名。所以,不管你改变谁,其他三个变量都会跟着变化。那为什么 c 在函数内部被改变,而且没有用 global 申明,但全局的 c 去被改变了呢?

    我们再来看一个例子:

    >>>a = {1:1, 2:2}

    >>>b = a

    >>>a[3] = 3

    >>>b

    {1: 1, 2: 2, 3: 3}

    >>>a = 4

    >>>b

    {1: 1, 2: 2, 3: 3}

    >>>a

    4

    当 b = a 时,a 与 b 指向同一个对象,所以在 a 中添加一个元素时,b 也发生变化。而当 a = 4 时, a 就已经不再指向字典对象了,而是指向一个新的 int 对象(python 中整数也是对象),这时只有 b 指向字典,所以 a 改变时 b 没有跟着变化。这是只是说明了什么时候赋值变量会发生质的改变,而以上的问题还没有被解决。

    那么,我么再来看一个例子:

    class TestObj(object):

    pass

    x = TestObj()

    x.x = 8

    d = {"a": 1, "b": 2, "g": x}

    xx = d.get("g", None)

    xx.x = 10

    print("x.x:%s" % x.x)

    print("xx.x: %s" % xx.x)

    print("d["g"].x: %s" % d["g"].x)

    # Out:

    # x.x:10

    # xx.x: 10

    # d["g"].x: 10

    由以上的实例可以了解到,如果仅改变对象的属性(或者说成是改变结构),所有指向该对象的变量都会随之改变。但是如果一个变量重新指向了一个对象,那么其他指向该对象的变量不会随之变化。所以,最开始的例子中,c 虽然在函数内部被改变,但是 c 是全局的变量,我们只是在 c 所指向的内存中添加了一个值,而没有将 c 指向另外的变量。

    需要注意的是,有人可能会认为上例中的最后一个输出应该是 d["g"].x: 8。 这样理解的原因可能是觉得已经把字典中 "g" 所对应的值取出来了,并重新命名为 xx,那么 xx 就与字典无关了。其实际并不是这样的,字典中的 key 所对应的 value 就像是一个指针指向了一片内存区域,访问字典中 key 时就是去该区域取值,如果将值取出来赋值给另外一个变量,例如 xx = d["g"] 或者 xx = d.get("g", None),这样只是让 xx 这个变量也指向了该区域,也就是说字典中的键 "g" 和 xx 对象指向了同一片内存空间,当我们只改变 xx 的属性时,字典也会发生变化。

    下例更加直观的展示了这一点:

    class TestObj(object):

    pass

    x = TestObj()

    x.x = 8

    d = {"a": 1, "b": 2, "g": x}

    print(d["g"].x)

    xx = d["g"]

    xx.x = 10

    print(d["g"].x)

    xx = 20

    print(d["g"].x)

    # Out:

    # 8

    # 10

    # 10

    这个知识点非常简单,但如果没有理解,可能无法看明白别人的代码。这一点有时候会给程序设计带来很大的便利,例如设计一个在整个程序中保存状态的上下文:

    class Context(object):

    pass

    def foo(context):

    context.a = 10

    context.b = 20

    x = 1

    def hoo(context):

    context.c = 30

    context.d = 40

    x = 1

    if __name__ == "__main__":

    context = Context()

    x = None

    foo(context)

    hoo(context)

    print(x)

    print(context.a)

    print(context.b)

    print(context.c)

    print(context.d)

    # Out:

    # None

    # 10

    # 20

    # 30

    # 40

    示例中我们可以把需要保存的状态添加到 context 中,这样在整个程序的运行过程中这些状态能够被任何位置被使用。

    在来一个终结的例子,执行外部代码:

    outer_code.py

    from __future__ import print_function

    def initialize(context):

    g.a = 333

    g.b = 666

    context.x = 888

    def handle_data(context, data):

    g.c = g.a + g.b + context.x + context.y

    a = np.array([1, 2, 3, 4, 5, 6])

    print("outer space: a is %s" % a)

    print("outer space: context is %s" % context)

    main_exec.py

    from __future__ import print_function

    import sys

    import imp

    from pprint import pprint

    class Context(object):

    pass

    class PersistentState(object):

    pass

    # Script starts from here

    if __name__ == "__main__":

    outer_code_moudle = imp.new_module("outer_code")

    outer_code_moudle.__file__ = "outer_code.py"

    sys.modules["outer_code"] = outer_code_moudle

    outer_code_scope = code_scope = outer_code_moudle.__dict__

    head_code = "import numpy as np from main_exec import PersistentState g=PersistentState()"

    exec(head_code, code_scope)

    origin_global_names = set(code_scope.keys())

    with open("outer_code.py", "rb") as f:

    outer_code = f.read()

    import __future__

    code_obj = compile(outer_code, "outer_code.py", "exec", flags=__future__.unicode_literals.compiler_flag)

    exec(code_obj, code_scope)

    # 去除掉内建名字空间的属性,仅保留外部代码中添加的属性

    outer_code_global_names = set(outer_code_scope.keys()) - origin_global_names

    outer_func_initialize = code_scope.get("initialize", None)

    outer_func_handle_data = code_scope.get("handle_data", None)

    context = Context()

    context.y = 999

    outer_func_initialize(context)

    outer_func_handle_data(context, None)

    g = outer_code_scope["g"]

    assert g.c == 2886

    print("g.c: %s" % g.c)

    print(dir(g))

    print(dir(context))

    pprint(outer_code_moudle.__dict__)

    总结

    以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作能带来一定的帮助,如果有疑问大家可以留言交流。

    展开全文
  • 在本文代码中,只实现了对主函数、赋值语句、if(else)条件语句的递归下降分析,其余语句还未实现。 下面贴上代码,具体解释在代码中已注释。 #include #include #include #include #include #include #incl

    (声明:本代码参考了网络上的代码,有改动,侵删)

    首先,我们需要了解一下little c的语法规则,可以在以下链接查看详细文档little c语法的详细定义

    在本文代码中,只实现了对主函数、赋值语句、if(else)条件语句的递归下降分析,其余语句还未实现。

    下面贴上代码,具体解释在代码中已注释。

    #include<stdio.h>  
    #include<sstream>  
    #include<iostream>  
    #include<stdlib.h>  
    #include<fstream>  
    #include<string.h>  
    #include<math.h>  
    #include<cstring>  
    #include <vector>  
    #include<iomanip>  
      
    using namespace std;  
    char const *keyword[7] = { "if", "else", "for", "while", "do", "int", "main"}; //关键字 
    
    
    class Word           //单词表类   
    {   
        public:  
        char value[20];//单词自身的值   
        int type;//单词的种别(10标识符,20常数,30关键字,4-运算符(加法运算符为41,乘法为42,关系运算符43),50界符)   
        int line;//行号  
    };  
    
    FILE *fin,*fout;//文件流   
    int line=1; //单词所在行数   
    char buff[10];//存放单词的数组   
    int flag=0;//词法分析判断是否已经从文件流中获取字符   
    Word new_w;    
    int e=0;//记录错误次数 
    
    void error(char doc[])//报错,定位到错误行   
    {  
            cout<<"第"<<new_w.line<<"行出错!\t";  
            cout<<doc<<"\n";  
            e++;  
    }  
    
    void P();//程序  
    int A(); //(){分程序}  
    void B();//分程序  
    void C();//变量说明部分  
    int F();//标识符表  
    int F1();//标识符  
    void D();//语句部分  
    int D1();//子语句部分  
    int H();//语句  
    int I();//赋值语句  
    int Q();//表达式  
    int J();//条件语句   
    int H1();//语句1  
    int TJ();//条件  
    
    char ch;//字符流中获取的字符    
    
    int getWord()
    {
    	int i=0; //buff当前字符的位置   
        int j=0; //new_w当前字符的位置   
        if(flag==0)  
        {  
            ch=getc(fin);  
        }  
        while(ch==' '||ch=='\n'||ch=='\t')//识别空格,换行,和tab  
        {  
            if(ch=='\n')  
            {      
                line++;//行+1   
            }  
            ch=getc(fin);  
            flag=1;  
        }   
        if(ch>='a'&&ch<='z')//识别字母开头的变量或者单词;   
        {  
            for(i=0;i<10;i++)  
            {  
                buff[i]=NULL;  
            }i=0;  
          
            do{  
                buff[i++]=ch;  //吧字符流中的字符放到buff中   
                ch=getc(fin);  
                flag=1;  
            }while((ch>='a' && ch<='z') || (ch>='0' && ch<='9'));   
            strcpy(new_w.value,buff);//把buff的值放到单词表   
            new_w.line=line;//行数   
            int n;  
            for(n=0;n<7;n++)  
            {  
                if(strcmp(new_w.value,keyword[n])==0)//判断是不是关键字   
                break;  
            }  
            if(n<7)//是关键字   
            {  
                new_w.type=30;//关键字类型为03   
            }else{  
                new_w.type=10;//标识符类型为01   
            }  
        return 0;  
        }  
        else if(ch>='0' && ch<='9')  
        {  
            for(i=0;i<10;i++)  
            {  
                buff[i]=NULL;  
            }i=0;  
            do{  
                buff[i++]=ch;  
                ch=getc(fin);  
                flag=1;   
            }while(ch>='0' && ch<='9');  
            strcpy(new_w.value,buff);  
            new_w.type=20;//数字类型为02   
            new_w.line=line;  
              
            //***************************  
        //  cout<<new_w.value;  
        return 0;  
        }  
        else if(ch=='+' || ch=='-')  
        {     
            for(i=0;i<10;i++)  
            {  
                buff[i]=NULL;  
            }i=0;  
            buff[i++]=ch;  
            ch=getc(fin);  
            flag=1;   
            strcpy(new_w.value,buff);  
            new_w.type=41;  //加法运算符   
            new_w.line=line;  
              
            //**************************  
        //  cout<<new_w.value;  
        return 0;  
        }  
        else if(ch=='*'||ch=='/')  
        {  
            for(i=0;i<10;i++)  
            {  
                buff[i]=NULL;  
            }i=0;  
            buff[i++]=ch;  
            ch=getc(fin);  
            flag=1;   
            strcpy(new_w.value,buff);  
            new_w.type=42;  //乘法运算符   
            new_w.line=line;  
              
            //**************************  
        //  cout<<new_w.value;  
        return 0;  
        }  
        else if(ch=='='||ch=='<'||ch=='>'||ch=='!')  
        {     
            for(i=0;i<10;i++)  
            {  
                buff[i]=NULL;  
            }  
            i=0;  
            buff[i++]=ch;  
            ch=getc(fin);  
            flag=1;   
            if(ch=='=')  
            {  
                buff[i++]=ch;  
                ch=getc(fin);  
                flag=1;   
            }  
            strcpy(new_w.value,buff);  
            new_w.type=43;  //关系运算符   
            new_w.line=line;  
              
            //**************************   
        return 0;  
        }  
        else if(ch==','||ch==';'||ch=='('||ch==')'||ch=='{'||ch=='}')  
        {  
            for(i=0;i<10;i++)  
            {  
                buff[i]=NULL;  
            }  
            i=0;  
            buff[i++]=ch;  
            strcpy(new_w.value,buff);  
            new_w.type=50;//界符   
            ch=getc(fin);  
            flag=1;   
            //**************************  
            //cout<<new_w.value;  
            return 0;  
        }  
        else  
        {  
            new_w.type=00;//错误的单词类型   
            strcat(new_w.value," ");  
            //*************************  
            //cout<<new_w.value;  
            return 0;  
        }  
    }
    void P()//整个程序
    {
        getWord();//main  
        if(strcmp(new_w.value,"void"))//当new_w.value不等于main满足条件   
        {  
            error("缺少void");   
        }
        else
        	getWord();//(  
        if(strcmp(new_w.value,"main"))//当new_w.value不等于main满足条件   
        {  
            error("缺少main");   
        }     
    	getWord() ;
        A();  
    } 
    int A() //(){分程序}  
    {  
        if(strcmp(new_w.value,"("))  
        { error("缺少'('");}  
            getWord();//)  
        if(strcmp(new_w.value,")"))  
        { error("缺少')'");}  
            getWord();//{  
        if(strcmp(new_w.value,"{"))  
        { error("缺少'{'");}  
            getWord();//int  
            B();  
            //getWord();  
        if(strcmp(new_w.value,"} "))  
        { error("缺少'}'");}      
        cout<<"语法检查完成,共发现"<<e<<"个错误。"<<endl;      
        return 0;  
    }  
    void B()//分程序  
    {  
        C();  
        if(strcmp(new_w.value,";"))  
        { error("缺少';'");}  
        getWord();//a=10;中的a  
        D();  
    }  
    void C()//变量说明部分   
    {  
        if(strcmp(new_w.value,"int"))  
        { error("缺少'int'");}  
            getWord();//a   
            F();  
    }  
    void D()//语句部分   
    {  
        H();//语句   
        D1();//子语句部分  
    }  
    int D1()//子语句部分  
    {     
        if(strcmp(new_w.value,"}")==0)  
        {  
            getWord();  
            if(strcmp(new_w.value,";")==0)  
            {  
                return 0;  
            }  
            else{  
                H();  
                D1();  
                return 0;  
            }     
        }  
        if(strcmp(new_w.value,";")==0)  
        {  
            getWord();  
            H();  
            D1();  
        }//else error("语句错误");   
         return 0;  
    }  
    int F()//标识符  
    {  
        if(new_w.type==10)  
        {  
            getWord();  
        }  
        F1();//标识符表,标识符   
        return 0;  
    }  
    int F1()//多标识符   
    {  
        if(strcmp(new_w.value,";")==0)  
        {  
            return 0;  
        }  
        if(strcmp(new_w.value,","))  
        {error("标识符错误");}  
            getWord();//b   
        if(new_w.type!=10)  
        {error("标识符错误");}  
            getWord();  
            F1();  
        return 0;  
    }   
    int H()//语句   
    {
        if(new_w.type==10)//如果当前符号为标识符,则为赋值语句   
        {           
            getWord();  
            I();//赋值语句  
            return 0;   
        }  
         else if(strcmp(new_w.value,"if")==0)//判断是否为条件语句   
         {  
            getWord();  
            J();//条件语句   
            return 0;   
         }  
         else if(strcmp(new_w.value,";")==0)  
         {  
            return 0;  
         }  
         return 0;  
    }  
    int I()//赋值语句  
    {  
        if(strcmp(new_w.value,"="))  
        {error("缺乏'='");}  
        getWord();   
        Q();//表达式  
        return 0; 
    }
    int Q()//表达式  
    {  
    	if(new_w.type==10||new_w.type== 20){
    		getWord();
    	} 
    	else{
    		error("赋值出错");
    		e++;
    	}
        return 0;  
    }    
    int J()//条件语句   
    {  
        if(strcmp(new_w.value,"("))  
        {  
            error("缺少'('");  
        }  
        getWord();  
        TJ();//条件 
    	if(strcmp(new_w.value,")"))  
         {  
            error("缺少')'");  
         }
        getWord();  
        H();//语句一 
        if(strcmp(new_w.value,";")==0)  
        {  
                getWord();  
        }  
              if(strcmp(new_w.value,"else"))  
          {  
            error("缺少'else'");   
            H();//语句一  
          }  
          else  
          {  
            getWord();  
            H();//语句一  
          }   
    }
    int TJ()//条件  
    {  
        //进Q之前时(a>0)中的a   
        Q();  
        if(new_w.type!=43)  
        {  
            error("缺少关系运算符");   
        }  
        getWord();  
        Q();  
        return 0;  
    }   
    int main()  
    {  
        char Infile[100];  
          
        //对文件的读出和写入借用了网上的知识     
        scanf("%s", Infile);  
        if ((fin = fopen(Infile, "r")) == NULL)  
        {  
            printf("\n 读入文件错误 \n");  
            return (1);  
        }   
         
        P();  
        if(e==0)  
        {  
            cout<<"语法正确"<<endl;  
        }  
        else  
        {  
            cout<<"\n存在语法错误"<<endl;  
        }  
          
        return 0;  
    }  

    展开全文
  • C语言表达式基本遵循一般代数规则。 表达式类型 变量常量表达式:a; sum; max; 1; 10; 算术表达式:a + b; a - b; i ++; i –; 赋值表达式:x = y; a *= b; c = (a - 10) + (b + 15); 逗号表达式:int
  • c语言

    2018-11-06 19:36:52
    1.了解赋值运算符运算特点和优先级比较。 2.区分不同逻辑表达式运算规则 3.明白条件运算符特点。 4.合理利用自增自减运算符。 5.学会使用中间变量来交换两个变量数据。 6.学会检查错误及改正错误。 7.了解...
  • 参考书:《C Primer Plus》第六版 while循环,程序清单1。 基本运算符有:赋值运算符=、加法...复合语句:用花括号括起来一条或多条语句,也称为块。 基本类型转化规则:1)当类型转换出现在表达式时,无论是
  • C语言基础

    2020-09-14 11:17:30
    注:部分内容省略了,适用于学过C语言或其他语言读者阅读 赋值定义运算语句 运算规则 先运算,再取值 ++a a取值后,a值再自增1 a++ 与或非 (&& || !) 注意:在定义中不允许连续赋值,如int a=b=c=5;...
  • C语言的三目运算符

    万次阅读 多人点赞 2010-01-11 17:30:00
    如果在条件语句中,只执行单个的赋值语句时, 常可使用条件表达式来实现。不但使程序简洁,也提高了运行效率。条件运算符为?和:,它是一个三目运算符,即有三个参与运算量。由条件运算符组成条件表达式一般形式...
  • 条件运算符是C语言中唯一一个三目运算符,其求值规则为:如果表达式1值为真,则以表达式2 值作为整个条件表达式值,否则以表达式3值作为整个条件表达式值。条件表达式通常用于赋值语句之中。 上面 if ...
  • 在一个赋值语句中,当赋值运算符左侧变量的类型和右侧的表达式不一致时, 就会发生自动类型转换. 问题:自动类型转换的规则是什么? 将赋值运算符右侧表达式的类型自动转换为左侧表达式变量的类型. 问题: 在不同...
  • 一些注意事项: 全局变量和局部变量重名以后,根据就近原则,打印会显示局部变量值,可在变量前加入...浮点型变量,即便赋值一样,也很难真相等,所以应尽量避免(double a/b;if(a==b))这样的语句; ...
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    3.12 我不想学习那些复杂的规则,怎样才能避免这些未定义的求值顺序问题呢? 其他的表达式问题 *3.13 ++i和i++有什么区别? 3.14 如果我不使用表达式的值,那我应该用i++还是++i来做自增呢? 3.15 我要检查...
  • c语言入门

    2018-07-28 18:40:06
    - C语言不是英语,C语法的背后都是人性化的规则 数组是一组变量:初始化是对一组变量的初始化,由此产生省略,定位和补0(都是为了方便对一批变量初始化) 数组的大小是一个值(非0整数): (int)3.5也可以作为...
  • 第三章;...赋值语句数据类型转换;逻辑运算符和表达式;关系运算符;按位运算符;运算符说明;移位使用技巧;C特殊运算符&和*运算符;运算符;sizeof运算符;C运算符优先级;C运算符优先级;本章总结
  • 一个简单程序结构 你已经看过一个具体例子,下面可以了解一些 C程序基本规则了。 程序由一个或多个函数组成,其中一定有一个名为 main()...然后是一个赋值语句,给变量赋一个值。接着,是1个输出语句,...
  • c语言基础(二)

    2019-05-13 19:42:54
    目录 标识符的定义规则 ...赋值表达式跟赋值语句的区别:表达式没有分号,赋值语句有分号 逻辑运算符的优先级顺序:!>&&>|| 三数比大小 #include<stdio.h> int main() { int ...
  • C语言大纲及课件

    2014-03-27 19:26:42
    赋值运算符、赋值表达式、赋值语句、复合赋值运算符;增量运算符与增量表达式;关系运算符和关系表达式;逻辑运算符和逻辑表达式;条件运算符和条件表达式,逗号运算符和逗号表达式;  理解:字符常量和字符串常量...
  • c语言基础知识总结

    2020-06-24 18:44:57
    c语言入门基础知识有:c语言的命名,变量及赋值,基本数据类型,格式化输出语句,强制类型转换以及运算符等知识。 1、c语言的命名 编程时给变量或者函数起名字就是标识符。C语言的标识符是不可以随便...
  • C语言 三目运算符

    2018-04-15 15:18:21
    如果在条件语句中,只执行单个的赋值语句时, 常可使用条件表达式来实现。不但使程序简洁,也提高了运行效率。 条件运算符为?和:,它是一个三目运算符,即有三个参与运算量。由条件运算符组成条件表达式一般...
  • 标准C语言(3)

    2018-01-14 21:34:00
    操作符用来描述对数字处理规则根据操作符所需要配合数字个数把操作符分为单...赋值操作符用=表示它可以把一个数字记录到一个存储区里,赋值语句可以当作数字使用,这个数字就是赋值完成后左边存储区里数字,可以...
  • 3.12 我不想学习那些复杂的规则,怎样才能避免这些未定义的求值顺序问题呢? 其他的表达式问题 3.13 ++i和i++有什么区别? 3.14 如果我不使用表达式的值,那我应该用i++还是++i来做自增呢? 3.15 我要检查一个数...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    3.12 我不想学习那些复杂的规则,怎样才能避免这些未定义的求值顺序问题呢? 38 其他的表达式问题 39 *3.13 ++i和i++有什么区别? 39 3.14 如果我不使用表达式的值,那我应该用i++还是++i来做自增呢? 39 ...
  • c语言 编程 规范 pdf

    2010-03-31 22:07:20
    c语言编程规范 高质量C++/C编程指南 文件结构 程序板式 命名规则 表达式和基本语句 常量 函数设计 内存管理 C++函数高级特性 类构造函数、析构函数和赋值函数 类继承和组合
  • 教学内容 3.1 基本数据类型 3.2 常用运算符和表达式 3.3 表达式及赋值语句 3.4 基本输入输出操作实现 3.5 顺序结构程序设计应用实例 教学要求 1.掌握整型数据实型数据字符数据使用规则 2.掌握各种数据运算运算符...
  • 谭浩强c语言程序设计

    2011-03-18 09:58:19
    4.2 赋值语句 53 4.3 数据输入输出概念及在C语言实现 54 4.4 字符数据输入输出 54 4.4.1 putchar 函数(字符输出函数) 54 4.4.2 getchar函数(键盘输入函数) 55 4.5 格式输入与输出 55 4.5.1 printf函数...
  • 4.2 赋值语句 3 4.3 数据输入输出概念及在C语言实现 4 4.4 字符数据输入输出 4 4.4.1 putchar 函数(字符输出函数) 4 4.4.2 getchar函数(键盘输入函数) 5 4.5 格式输入与输出 5 4.5.1 printf函数(格式...
  • 谭浩强c语言word版

    2011-04-25 10:40:43
    4.2 赋值语句 53 4.3 数据输入输出概念及在C语言实现 54 4.4 字符数据输入输出 54 4.4.1 putchar 函数(字符输出函数) 54 4.4.2 getchar函数(键盘输入函数) 55 4.5 格式输入与输出 55 4.5.1 printf函数...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 189
精华内容 75
关键字:

c语言赋值语句的规则

c语言 订阅