当前位置:网站首页>>电脑技术>>C、C++语言>>我的著作 双击自动滚屏
C语言速成(第二章 常量、变量、运算符与表达式)

发表日期:2006年1月1日      已经有7216位读者读过此文

第二章 常量、变量、运算符与表达式

    C语言中的数据包括常量和变量两类,数据的属性可以通过它们的数据类型和存储类型来描述。各种数据有着不同的数据类型,C语言的数据类型可以分为基本类型、指针类型和由它们组合成的构造类型。对于常量来说,它的属性由其取值形式就能表明,而变量的属性则必须在使用前明确地加以说明。
    本章主要介绍数据的基本类型、存储类型、常量、变量和运算符及其与运算对象组合成的表达式。

第一节 C语言的基本数据类型

    数据是计算机程序处理的主要对象。 在C语言中,数据的基本类型可以分为: 字符型( char )、整型( int )和浮点型。浮点型也称为实型,根据数据的有效位数可以把浮点型再分为单精度浮点型( float )和双精度浮点型( double )。 整型数据又可以分为普通整型( int )、短整型( short )和长整型( long )。 在字符型或整型关键字前再加一个关键字 unsigned 可以把它们说明为无符号字符型或无符号整型。无符号类型的数据没有负值,虽然它和相应的有符号类型占用相同的存储空间,但由于它不需要符号位,因此在不涉及负值的场合使用,可以得到更大的取值范围。使用短整型的目的是为了在存放比较小的整型数时,节省计算机的存储空间。但在 IBM PC 系列等微机上,short 和 int 类型的长度是一样的。
    在不同类型的计算机中,各类型数据占用内存空间的长度是不同的,因此它们的取值范围也不一样。表2.1列出了在 IBM PC 系列微机上各数据类型占用的内存空间长度及其取值范围。

    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
       数据类型          字节数       所占位数          取值范围
    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        char                1            8           -128~+127
      unsigned char         1            8              0~255
        int                 2            16          -32768~+32767
      unsigned int          2            16             0~65535
        short               2            16          -32768~+32767
      unsigned short        2            16             0~65535
        long                4            32       -2147483648~+2147483647
      unsigned long         4            32            0~4294967295
        float               4            32          -1.0E38~+1.0E38
        double              8            64          -1.0E308~+1.0E308
    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

                     表2.1 各数据类型长度和取值范围

    不同数据类型的数据之间可以进行运算,在运算时系统自动把它们转换成同一数据类型。在C语言中,float 类型的数据总是先转换成 double 型,char 和 short 类型数据均先转换成 int 类型才进行运算,即使同类数据间的运算也是如此。对于各类型数据运算时的转换可根据图2.1确定。

              char → int → long → float → double

                 图2.1 数据类型转换方向示意图

    当这些不同类型的数据在一起计算时,左边的类型会先转换成右边的类型。例如,一个 char 类型数据和一个 long 数据一起计算时,先将 char 类型数据转换成 long 类型,计算结果为 long 类型的。

第二节  常   量

    常量是指那些在程序执行过程中不可改变的量,C语言的常量包括直接常量和符号常量两种。

    一、直接常量
    直接常量在程序中可直接使用,具体可分为以下几种基本类型。  

    1、整型常量:是一种整型数。通常有八进制、十进制、十六进制三种表达形式。在C语言中规定八进制数书写时必须以 0 开头,十六进制数以 0x 或 0X 开头。如十进制常量 10,在八进制中写成 012,在十六进制中写成 0XA 或 0xa。为了避免与八进制混淆,十进制整数常量的前面不能出现无效的 0,如 10 不能写成 010。

    2、长整型常量:在一个 long 类型设计取值范围内的整数均可看成长整型常量。书写时在常量后面加上一个英文字符 l 或 L。如:-28l 或 -28L (十进制长整型常量)、056l 或 056L (八进制长整数常量)、0x33dl 或 0X33DL (十六进制长整型常量)。

  3、浮点常量:是一实数,只有十进制一种表达方式。其书写形式有以下两种:
    ⑴ 十进制小数的表示法。如:-1.25,0.452。  
    ⑵ 指数表示法。这种表示法通常用在计算中遇到的很大或小的数。如 60000 可以表示成 6E4,0.000035 可以写成 3.5E-5,等等。E 也可以写成小写 e。

    4、字符常量:是一种用字符来表示该字符在机器字符集中编码值的数字常量,如 IBMPC 系列微机用的 ASCII 码值。其书写形式是把该常量用单引号括起来,如 ''''''''A'''''''',由于字符 A 的 ASCII 码是65,所以取字符常量 ''''''''A'''''''',取到的实际上是数值65。
    另外,也可以把上一章里表1.1中介绍的转义字符放在单引号中作为字符常量。如用 ''''''''\n'''''''' 表示换行符的 ASCII 码10。在转义字符系列中,反斜线“\”改变了后随字符 n的本来意义。

    5、字符串常量:是一种由零个或多个字符组成的常量。书写时用双引号把这些字符括起来。如:"A"、"WORLD"。组成字符串的字符可以包括表1.1所列的转义字符序列。如:

    "CHINA\nHEFEI\n"

把这个字符串作为库函数 printf 的参数运行后,就会在屏幕上打印出以下结果:

    CHINA
    HEFEI

    字符串常量在编译时,编译系统自动在其后加一个空字符 ''''''''\0'''''''' 作为字符串的终止符,因此,系统对有 N 个字符组成的字符串常量总是分配 N+1 个字节的存储空间。必须注意:''''''''A'''''''' 与 "A" 是不同的。前者是一个字符常量,在内存中只占一个字节的空间;而后者是一个字符串常量,它由字符 ''''''''A'''''''' 和 ''''''''\0'''''''' 组成,它在内存中占两个字节的空间。而一个空字符串常量 "" 实际上包含了一个空字符 ''''''''\0'''''''',在内存中占用一个字符的存储空间。

    二、符号常量
    符号常量用被定义了的标识符来代替常数。对于在程序设计中数位较长、反复出现或者需要经常修改的一些常量,使用符号常量有其独到的好处。在程序调试或移植过程中,需要改变这些常量的值时,只要修改源程序开始部分符号常量宏替换的值就可以了。如程序里经常要用到圆周率 3.14159 就可以通过宏替换命令用符号常量来代替它:

   #define PI 3.14159       /* 通过宏替换命令用符号常量 PI 代替常数 3.14159 */

这样,在程序中凡是用到园周率的地方都可以用 PI 代替了。在例1.2中我们已经用过了类似的代换。为了醒目起见,习惯上总是用大写字母来组成符号常量的标识符。
    在C语言里还有一种常量叫枚举常量,我们将在第八章里再作介绍。

第三节    变量

    一、变量的定义
    变量是程序执行过程中可以改变的量。所有的变量都有一个名字,变量名必需是合法的标识符。变量在内存里占用一定的存储空间来存放变量的值。
    在C语言中,变量在使用前必须先定义,以确定它的数据类型和存储类型。对一个没有定义过的变量进行计算或作为参数传递,在编译时都会作为出错处理。表2.1中列举的各种基本数据类型和取值范围对于定义变量都是适用的。
    变量定义的一般格式为:

    <存储类型> <数据类型> <变量名> = <初值>;

    如:

        static int a;                  /* 说明 a 为整型的静态变量 */
        unsugned long d;               /* 说明 d 为无符号长整型变量 */

    允许一次定义多个变量,各变量名间用逗号分开,最后用分号结束。例如:

        int x,y,sum;                   /* 说明 x,y,sum 为整型变量 */
        char ch,key;                   /* 说明 ch,key 为字符型变量 */

    二、变量的存储类型
    变量按其存储方式可分为外部变量( extern )、自动变量( auto )、静态变量( static)和寄存器变量( register )四类。有的老的C语言版本不支持寄存器变量。

    1、自动变量( auto )
    自动变量也称为局部变量,说明自动变量的关键字 auto 一般可以省略。在一个函数体内定义的变量,如果不给出显式的存储类型,即认为该变量是自动变量。自动变量的作用域局限于定义它的函数内部,程序一旦离开该函数,自动变量就自动停止其存在。在程序运行过程中,自动变量并不始终占有内存单元,只有用到它们时才占据一定的存储空间。如在例2.1中的 main 函数里定义的整型变量 x 和 y 就是自动变量,它们只在 main 函数内部有效,并不因为 main 是主函数而在整个程序中有效。该例中 max 函数的形式参数 a 和 b 也是自动变量,它们仅仅在 max 函数内部有效。
    由于自动变量仅在定义它的函数内部有效,因此,在不同的函数中使用相同的函数名是允许的,它们不会互相发生混淆。
    自动变量也可以在函数里某个复合语句内部定义,这样的自动变量的作用域仅限于该复合语句,离开这个复合语句,变量也就停止其存在了。如:

        main()                         /* 主函数 */
        {
           int x,y;                    /* 自动变量 x、y 在 main 函数内有效 */
              .
              .
              .
           {
              int a,b;                 /* 自动变量 a、b 在复合语句中有效 */
                .
                .
                .
           }
        }

其中,自动变量 x,y 在 main 函数内部有效,而自动变量 a,b 只在中间两个花括号包含的复合语句内有效。

    2、外部变量( extern )
    外部变量是在函数外部定义的变量,它是全局变量。外部变量可以为整个程序的各个函数使用,它的作用域为从定义这个变量的位置开始到程序文件的结束处为止的区域。如果某个函数改变了一个外部变量的值,那么,使用这个函数的其他函数也会受到影响。确定一个变量是否是外部变量,主要看定义它的表达式在程序里的位置是否在所有的函数之外。
    在一个源程序里要引用另一个源程序文件中的外部变量,或者在一个源程序文件中外部变量作用域前的函数要引用这个外部变量,在引用前都必须加以说明。说明的方法是通过关键字 extern。在外部变量作用域内引用时,一般可以省略说明。一个外部变量只能定义一次,但可以多次说明。第一章例1.2中的变量 z 就是一个外部变量,因为它定义在所有的函数前,所以它的作用域覆盖了整个程序。  如果我们把它的定义语句移动一下位置,放到main 函数后面去,那么在 main 函数里引用这个外部变量前就必须加以说明。见例2.1。

    例2.1

    #define ONE 1               /* 通过宏替换命令用符号常量 ONE 代替常数1 */
    #define TWO 2               /* 通过宏替换命令用符号常量 TWO 代替常数2 */
    int max();                  /* 说明一个返回值为 int 类型的函数 max */
    main()                      /* 主函数 */
    {
       int x=ONE,y=TWO;         /* 定义自动变量 x、y 并赋初值 */
       extern int z;            /* 外部变量 z 的说明 */
       z=max(x,y);              /* 调用函数 max,返回值赋给 z */
       printf("%d",z);          /* 在屏幕上用十进制打印 z 的值 */
    }
    int z;                      /* 外部变量 z 的定义 */

    int max(a,b)                /* 定义函数 max */
    int a,b;                    /* 函数形参说明 */
    {
       if(a>b) return(a);       /* 如果 a>b,返回 a 的值 */
       else return(b);          /* 否则返回 b 的值 */
    }

    外部变量在函数间传递数据比较方便、有效,但外部变量使用过多会削弱函数的独立性,给程序的维护带来困难,因此,作为模块化的C程序设计,不主张过多地使用外部变量。

    3、静态变量( static )
    静态变量分为静态外部变量和静态内部变量。静态外部变量的作用域在定义它的源程序文件中,静态内部变量的作用域在定义它的函数内。它们在作用域外是不可访问的,或称为不可见的。静态变量和自动变量的区别在于:自动变量在使用到时才占用存储单元,当程序离开其作用域时,自动变量释放占据的内存,其值不被保留。而静态变量在编译时就分配了固定的存储单元,当程序离开静态变量作用域时,静态变量的值仍得到保留,当程序再次进入该作用域时,还可继续使用保留着的数值。
    说明一个静态变量的方法是在其类型说明前加关键字 static。例2.2为一个使用静态变量的例程。

    例2.2

    main()                             /* 主函数 */
    {
       add();                          /* 调用函数 add */
       add();                          /* 调用函数 add */
       add();                          /* 调用函数 add */
    }

    add()                              /* 定义函数 add */
    {
       static int x=2;                 /* 定义一个静态变量 x,并赋初值 */
       printf("%d\n",x);               /* 在屏幕上用十进制打印 x 的值 */
       x=x+2;                          /* x 的值增2 */
    }

    在这个例程中,主函数 main 调用了三次函数 add,add 中定义了一个静态整型变量 x。给静态变量赋的初值2是在编译时一次完成的,因此,在第二、第三次调用函数 add 时,x并没有再重新赋初值,而是把上次调用结束时保留的值作为初值。库函数 printf 用十进制方式打印 x 的值,并换行。打印后再把 x 的值增加2。这个例程的运行结果为:

    2
    4
    6

    第一次调用 add 打印的是 x 的初值,其余两次打印的均为上次保留下来的值。如果我们把 x 改为一般的自动变量,即把定义 x 的一句改为:

    int x=2;                           /* 定义一个自动变量 x,并赋初值2 */

运行的结果将是:

    2
    2
    2

这是因为每次运行 add 函数后 x 的值没有被保留下来,再次进入 add 后,重新定义x,并置初值2。

    4、寄存器变量( register )
    寄存器变量只能定义在函数内部,它的作用域和自动变量相同。一般的变量都是放在内存单元里的,而寄存器变量则放在 CPU 的寄存器中。因此,访问寄存器变量速度要快得多,这对于那些使用十分频繁的变量是有好处的。但是,CPU 寄存器的数量有限,而且不可能都用来存放寄存器变量,因此寄存器变量不能大量使用。如果寄存器不够分配,编译系统会将多余的寄存器变量转换为自动变量。要注意,寄存器变量不允许用运算符“&”进行取地址运算。
    寄存器变量用关键字 register 来说明。例如:

        register int i;                /* 定义一个整形寄存器变量 i */
        register char key;             /* 定义一个字符型的寄存器变量 key */

    三、变量的初始化
    变量的初始化就是给变量赋初值,以确保某些变量在程序运行时有确定的值。变量的初始化通常在变量定义时一起进行,通过赋值语句来实现。对于静态变量或外部变量,初值表达式必需是常量表达式或有确定值的表达式。而自动变量或寄存器变量可以用任意表达式赋初值。如果在定义静态变量或外部变量时没有显式地置初值,编译系统自动地把它们的初值置为0,而在这种情况下,对于自动变量或寄存器变量则不确定初值。在上面的例2.2里已经涉及了静态变量的初始化,下面是另一些变量初始化的例子:

        int i=3,k=10;                  /* 定义整型变量 i、k,并赋初值 */
        char b=''''''''A'''''''',c=20;               /* 定义字符型变量 b、c,并赋初值 */
        double f1=6.375;               /* 定义双精度浮点型变量 f1,并赋初值 */
        static int size=2;             /* 定义静态变量 size,并赋初值 */
        int m=k/size;                  /* 定义整型变量,用一表达式给它赋初值 */

对几个变量赋同一个初值时允许写成:

        int a1=a2=a3=10;            /* 定义整型变量 a1、a2、a3,并赋同一初值 */

第四节 运算符和表达式

    运算符和运算对象按一定的规则结合在一起就构成了表达式。C语言的运算符按其在运算表达式中与运算对象的关系可以分为单目运算符、双目运算符和三目运算符,它们分别对一个、两个或三个运算对象进行处理。
    运算符和表达式根据其所起作用不同可以分为以下几类:

    一、算术运算符和表达式
    C语言基本的算术运算符有以下几种:

    +   加法运算符             表达式如:  a+b,   3+2
    -   减法运算符                         x-y,   10.5-7.1
    *   乘法运算符                         m*n,   3*size
    /   除法运算符                         5/3,   p/2
    %   取模运算符                         5%3,   y%2

    其中,“-”运算符既可以作为双目运算符,又能作为单目运算符使用。如 -x 即为求变量 x 的负值。取模运算符两边的数据必需是整型数据。
    另外,单目运算符“++”和“--”分别完成使变量增1或减1的运算功能,但不能对常量或表达式进行这样的操作。它们可以放在变量前面,如 ++x、--y,也可以放在变量的后面,如 x++、y--这两种放法相同之处在于都使 x 的值增加1和使 y 的值减少1,但 ++x 是先把 x 的值增1,再使用 x 的值;而 x++ 则是先使用 x 的值,再增1。也就是说“++”和“--”的结合方向是自右至左。如果有:

    int x,i,j;                         /* 定义整型变量 x、i、j */
    x=5;                               /* 把常量5赋给 x */
    i=x++;                             /* 先将 x 赋给 i,再将 x 增1 */
    j=++x;                             /* 先将 x 增1,再把结果赋给 j */

那么,得到的 i 的值将是5,而 j 的值为6。

    二、按位运算符和表达式
    C语言提供了象汇编语言那样的字位操作功能,可以通过按位运算符对运算对象的二进制位进行运算。C语言的按位运算符有以下六种:

    &   按位与                    表达式如: a&b
    |   按位或                               a|0x40
    ^   按位异或                             m^n
    ~   按位取反                             ~x
    <<  二进位左移                           b<<2     ( 左移两位 )
    >>  二进位右移                           y>>4     ( 右移四位 )

    按位运算符的两个运算对象都只能是整型量。左移和右移运算符右边的数值表示移动的二进制位数,该数值不允许取负值,其值也不允许超过移位运算符左边数值所占用的实际位数。

    三、赋值运算符和表达式
    等号“=”就是赋值运算符,它是一个双目运算符。包含赋值运算符的表达式叫做赋值表达式。赋值号的左边只能是变量或以表达式表示的变量,而不允许是算术表达式或常量。
例如:

    a=3;                               /* 把常量3赋给变量 a */
    b=(a+3)*c;                         /* 把一个表达式的值赋给变量 b */

是允许的,而

    3+m=6;

则是不合法的。
    当赋值运算符两侧的运算对象的数据类型不同时,系统自动进行类型转换,把赋值运算符右边的数据转换成符号左边的数据类型。如果赋值运算符右边的数据类型是图2.1中相对比较右边类型的,当它赋给相对比较左边类型的变量时,可能会发生截断现象。如把一个浮点数赋给一个整形变量时,小数点后面的部分将被舍去。
    赋值运算符能够和算术运算符或按位运算符组成复合运算符。例如对于表达式

    a=a+2;

可以用复合运算符写成

    a+=2;

这样做不但书写简洁,而且产生的代码短,运行速度也快。复合运算符有:

    +=    -=    *=    /=    %=    <<=    >>=    &=    ^=    |=

    当复合运算符右侧是一个表达式时,总是先计算这个表达式,再进行复合运算和赋值。例如对赋值语句

    a*=2+3;

总是先计算 2+3 得到 5,再将 5 和 a 相乘,最后把结果赋给 a。

    四、数据类型强制转换符和表达式
    在C语言里,一种类型的数据可以强制转换为另一种类型的数据。数据类型强制转换符是将类型符放在一对园括号里,并把它们放在需要转换类型的数据前。例如要把浮点变量 a的值转换成整型,可以用表达式  (int)a  来完成。又如表达式  (char)(4.2+3.3) 将结果转换成字符型量,小数点后面的部分被舍去了。要注意,表达式后面的括号不能省略,否则意思就不一样了。

    五、关系运算符和表达式
    C语言的关系运算符有:

    >    大于                 表达式如: num>8
    <    小于                            x<y
    >=   大于或等于                      s1>=d
    <=   小于或等于                      j<=20
    ==   全等于                          key==''''''''N''''''''
    !=   不等于                          ff!=0

    这些运算符均为双目运算符,主要用在条件语句中。如果比较后关系式成立,则称之为“真”,得到结果为1。如关系式不成立,称为“假”,得到的结果为0。

    六、逻辑运算符和组合关系表达式
    C语言里的逻辑运算符有:

    &&   逻辑与               表达式如:  (a>b)&&(i<1)
    ||   逻辑或                           (a==1)||(b>0)
    !    逻辑非                           !(x>y)

    逻辑运算符用于对几个关系运算表达式的运算结果进行组合,作出综合的判断。逻辑运算的结果以非0为“真”,0为“假”。如果A代表一个关系表达式的运算结果,B代表另一个关系表达式的运算结果,则有:

    A&&B      若A、B均为真,则表达式为真,否则为假。
    A||B      若A、B之一为真,则表达式为真。
    !A        若A为真,则表达式为假;若A为假,则表达式为真。

    可以用多个逻辑运算符组合成更复杂的组合关系表达式。如:

    x>2 && y>3 && z>7 && k>6
    ( a>=1 && b>2 ) || c==0

    七、求类型长度运算符( sizeof )
    和其他运算符不同的是这个运算符是由一个关键字 sizeof 表示的,它用于计算一种数据类型所占用的字节数。不论是基本的数据类型还是复杂的构造类型都可以用它来计算。如:

    sizeof(char)      计算一个字符类型数据占用的字节数
    sizeof(double)    计算一个双精度浮点型数据的长度

    八、逗号运算符和表达式
    逗号运算符“,”是一种特别的运算符,它不是指那些在同时定义的几个变量或函数调用的几个参数之间起分隔作用的逗号,而是用逗号将两个表达式连接起来,形成逗号表达式。如:

    2*8,3+20

它先计算前一个表达式 2*8 得到值 16,再计算后一个表达式 3+20,得值 23,整个逗号表达式的值即为后一个表达式的值 23。其实,使用逗号表达式的目的往往不在于要取得整个逗号表达式的值,而是要让逗号运算符两边的表达式都运算一遍。逗号表达式经常用于下一章将要讲到的 for 循环中。如:

    for(i=0;i<10;i++,j++)
      ......

在 i++ 和 j++ 之间的就是一个逗号运算符,这个表达式作用是每循环一次,逗号运算符两边的变量 i 和 j 均增加1。

    九、条件运算符和表达式
    条件运算符是C语言中唯一的三目运算符,它用两个符号“?”和“:”把三个运算对象连接在一起。符号“?”前是一个关系表达式或由逻辑运算符连接起来的组合关系表达式,用于表示决定条件表达式取值的条件,中间和后面的两个表达式分别代表条件表达式可取的两个值。当条件运算结果为真时,取前一个的值,否则取后一个的值。例如:

   x>y ? 10 : 5

表示当 x>y 成立时,条件表达式的值为10,否则条件表达式的值为5。

    除了上面讲到的运算符外,C语言中还规定了一些其他的运算符,如指针运算符“*”和“&”、分量运算符“.”和“->”、下标运算符“[ ]”等,我们将在以后的各章里陆续介绍。
    当多种运算符在一个表达式里混合使用时,为了确定各种运算的先后顺序,C语言规定了各种运算符的优先级和结合性,见表2.1。表中运算符的优先级以15级为最高,1级最低。优先级高的运算符先运算。结合性“自左至右”是把运算对象先与左边的运算符结合,“自右至左”则反之。

━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━
运算符      名称       优先级  结合性 ┃运算符      名称       优先级  结合性
━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━
 ( )   括号,函数调用                 ┃  ==       全等于        9   自左至右
 [ ]       下标         15  自左至右┃  !=       不等于
 ->    间接成员选择符                 ┣━━━━━━━━━━━━━━━━━━━━
  .    直接成员选择符                 ┃  &        按位与        8   自左至右
━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━
  !       逻辑非                      ┃  ^       按位异或       7   自左至右
  ~      按位取反                     ┣━━━━━━━━━━━━━━━━━━━━
 ++        增1                       ┃  |        按位或        6   自左至右
 --        减1                       ┣━━━━━━━━━━━━━━━━━━━━
  &       取地址        14  自右至左┃  &&       逻辑与        5   自左至右
  *       取内容                      ┣━━━━━━━━━━━━━━━━━━━━
  -       单目减                      ┃  ||       逻辑或        4   自左至右
(类型)  类型强制转换                  ┣━━━━━━━━━━━━━━━━━━━━
sizeof  计算类型长度                  ┃ ? :     条件运算符      3   自右至左
━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━
  *         乘                        ┃  =         等于
  /         除          13  自左至右┃  +=
  %        取模                       ┃  -=
━━━━━━━━━━━━━━━━━━━┫  *=
  +         加          12  自左至右┃  /=
  -         减                        ┃  %=   复合运算赋值符    2   自右至左
━━━━━━━━━━━━━━━━━━━┫  &=
 <<      按位左移       11  自左至右┃  ^=
 >>      按位右移                     ┃  |=
━━━━━━━━━━━━━━━━━━━┫ >>=
  >        大于                       ┃ >>=
  <        小于         10  自左至右┣━━━━━━━━━━━━━━━━━━━━
 >=     大于或等于                    ┃  ,      逗号运算符      1   自左至右
 <=     小于或等于                    ┃
━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━
 
                    表2.1  运算符的优先级和结合性

 

 


相关专题: 我的著作
专题信息:
  C语言速成(第三章 程序控制语句)(2006-1-1 13:51:28)[9375]
  C语言速成(第七章 联合、枚举和自定义数据类型)(2006-1-1 13:51:46)[9993]
  C语言速成(第六章 结构)(2006-1-1 13:52:05)[8790]
  C语言速成(第五章 指针)(2006-1-1 17:28:54)[4524]
  C语言速成(第四章 数组)(2006-1-1 13:52:42)[4666]

相关信息:
 没有相关信息
  打印本页
设为首页 | 加入收藏 | 联系我们 | 管理入口
皖ICP备05018956号
Copyright © 2003 J.W.SHEN All Rights Reserved
后台管理系统 V1.0 制作