C语言入门系列之2.数据类型、运算符和表达式

小鱼儿 2023-05-22 05:00 65阅读 0赞

### 数据类型，运算符和表达式 ###

*  一、数据类型
 *   *  1.数据类型
     *  2.常量和变量
     *   *  常量和符号变量
         *  变量
     *  3.整型数据
     *   *  整型常量的表示方法
         *  整型变量
     *  4.实型数据
     *   *  Ⅰ.实型常量的表示方法
         *  Ⅱ.实型变量
         *   *  实型数据在内存中的存放形式
             *  实型变量的分类
             *  实型数据的舍入误差
     *  5.字符型数据
     *   *  字符常量
         *  字符变量
         *  转义字符
         *  字符串常量
     *  6.变量赋初值
     *  7.变量类型转换
     *   *  自动类型转换
         *  强制类型转换
 *  二、运算符和表达式
 *   *  1.基本算术运算符
     *  2.运算符的优先级和结合性
     *  3.高级运算符
     *   *  强制类型转换运算符
         *  自增、自减运算符
         *  赋值运算符和赋值表达式
         *  逗号运算符和逗号表达式

# 一、数据类型 #

C语言常见数据类型如下：  
![C数据类型][C]

## 1.数据类型 ##

*  基本数据类型  
    基本数据类型最主要的特点是，其值**不可以再分解**为其他类型。  
    也可以说，基本数据类型是自我说明的。
 *  构造数据类型  
    构造数据类型是根据已定义的一个或多个数据类型用构造的方法来定义的。  
    也就是说，一个构造类型的值可以**分解**成若干个“成员”或“元素”。每个“成员”都是一个基本数据类型或一个构造类型。  
    在C语言中，构造类型有以下几种：
    
     *  数组
     *  结构体
     *  共用体（联合）类型
 *  指针类型  
    指针是一种特殊的、且具有重要作用的数据类型，其值用来表示**某个变量在内存储器中的地址**。  
    虽然指针变量的取值类似于整型量，但这是两个类型完全不同的量，因此不能混为一谈。
 *  空类型  
    在调用函数值时，通常应向调用者返回一个函数值，这个返回的函数值是具有一定的数据类型的，应在函数定义及函数说明中给以说明。  
    例如在上一节例题中给出的max函数定义中，函数头为`int max(int a, int b);`，其中**int**类型说明符即表示该函数的返回值为整型量。  
    但是，也有一类函数，调用后并不需要向调用者返回函数值，这种函数可以定义为“**空类型**” ，其类型说明符为void。

## 2.常量和变量 ##

对于基本数据类型量，按其取值是否可改变又分为常量和变量两种。  
在程序执行过程中，其值不发生改变的量称为常量，其值可变的量称为变量。  
它们可与数据类型结合起来分类，例如,可分为整型常量、整型变量、浮点常量、浮点变量、字符常量、字符变量、枚举常量、枚举变量。  
在程序中，**常量是可以不经说明而直接引用的，而变量则必项先定义后使用**。  
整型量包括整型常量、整型变量。

### 常量和符号变量 ###

在程序执行过程中，其值不发生改变的量称为常量。  
符号常量：用标示符代表一个常量。  
在C语言中，可以用一个标识符来表示一个常量，称之为符号常量。  
符号常量在使用之前必须先定义，其一般形式为：

#define 标识符 常量

其中`#define`也是一条**预处理命令**(预处理命令都**以\#开头**)，称为**宏定义**命令，其功能是把该标识符定义为其后的常量值。一经定义，以后在程序中所有出现该标识符的地方均代之以该常量值。

习惯上符号**常量**的标识符用**大写字母**，**变量**标识符用**小写字母**，以示区别。  
举例如下：

#include <stdio.h>
    #define PRICE 30
    
    void main()
    { 
        int num, total;
        num = 10;
        total = num * PRICE;
        printf("total=%d", total);
    }

打印：

total=300

其中：  
`#define PRICE 30`用标识符代表一个变量，称为符号变量；  
符号常量与变量不同，它的值在其作用域内不能改变，也**不能再被赋值**。

使用符号常量的好处：

*  含义清楚；
 *  能做到”**一改全改**“。

### 变量 ###

其值可以改变的量称为变量。一个变量应该有一个名字，在内存中占据一定的存储单元。  
变量定义必项放在变量使用之前，一般放在函数体的开头部分。  
如下：

int k = 3;

要区分变量名和变量值是两个不同的概念，在上例中，k是变量名，3是变量值。

## 3.整型数据 ##

### 整型常量的表示方法 ###

整型常量就是整常数。  
在C语言中，使用的整常数有八进制、十六进制和十进制三种：

*  十进制整常数  
    十进制整常数没有前缀，其数码为0-9。  
    以下各数是合法的十进制整常数：  
    237、-568、65535、1627等。
 *  八进制整常数  
    八进制整常数必须以0开头，即以0作为八进制数的前缀，数码取值为0-7。  
    八进制数通常是无符号数。  
    以下各数是合法的八进制数：  
    015(十进制为13)、0101(十进制为65)、0177777(十进制为65535)。
 *  十六进制整常数  
    十六进制整常数的前缀为0X或0x，其数码取值为0-9、A-F或a-f。  
    以下各数是合法的十六进制整常数：  
    0X2A(十进制为42)、0XA0 (十进制为160)、0xFFFF (十进制为65535)。

在程序中是根据前缀来区分各种进制数的，在书写常数时不要把前缀弄错造成结果不正确。

整型常数的后缀：  
在16位字长的机器上，基本整型的长度也为16位，因此表示的数的范围也是有限定的。十进制无符号整常数的范围为0-65535，有符号数为-32768 - +32767，八进制无符号数的表示范围为0 - 0177777，十六进制无符号数的表示范围为0X0 - 0XFFFF或0x0 - 0xFFFF。  
如果使用的数超过了上述范围，就必须用**长整型数**来表示，长整型数是用后缀 **L或l** 来表示的。

### 整型变量 ###

变量定义的一般形式为：

类型说明符  变量名标识符, 变量名标识符, ...;

例如：

int a,b,c;      // a,b,c为整型变量
    long x,y;       // x,y为长整型变量
    unsigned p,q;   // p,q为无符号整型变量

在书写变量定义时，应注意以下几点：

*  允许在一个类型说明符后，定义多个相同类型的变量，各变量名之间用“,”号间隔，类型说明符与变量名之间至少用一个空格间隔。
 *  最后一个变量名之后必须以“;”号结尾。
 *  变量定义必须放在变量使用之前。  
    一般放在函数体的开头部分。

整型数据在内存中的存放形式是二进制，在上例中声明k变量，值为3，以二进制存储示意如下：  
![变量名和变量值][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NVRkVFQ1I_size_16_color_FFFFFF_t_70_pic_center]

**补充–内存中的二进制存储：**  
1字节Byte = 8位bit。  
数值是以补码表示的：

*  正数的补码与原码相同；
 *  负数的补码  
    将该数的绝对值的二进制形式按位取反再加1。  
    举例说明–求-10的补码：
    
    > 10的原码： 00001010  
    > 取反： 11110101  
    > 再加1，得到-10的补码： 11110110
    
    可以得到，**最高位是符号位**，1表示负数，0表示整数。

整型变量的分类：

*  基本型  
    类型说明符为**int**，在内存中占4个字节。
 *  短整型  
    类型说明符为**short int**或**short**，在内存中占2个字节。
 *  长整型  
    类型说明符为**long int**或**long**，在内存中占4个字节。
 *  无符号型  
    类型说明符为**unsigned**。

注意：  
这里占多少个字节跟具体的系统和编译器规定有关。

在本机查看不同类型所占位数测试：

#include <stdio.h>
    
    void main()
    { 
        printf("%d\n", sizeof(int));
        printf("%d\n", sizeof(short));
        printf("%d\n", sizeof(long));
        printf("%d\n", sizeof(unsigned));
    }

打印：

4
    2
    4
    4

整型变量信息如下：

<table> 
 <thead> 
  <tr> 
   <th>类型说明符</th> 
   <th>数的范围</th> 
   <th>字节数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int</td> 
   <td>-2<sup>31</sup> - (2<sup>31</sup>-1)</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td>unsigned int</td> 
   <td>0 - (2<sup>32</sup>-1)</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td>short int</td> 
   <td>-2<sup>15</sup> - (2<sup>15</sup>-1)</td> 
   <td>2</td> 
  </tr> 
  <tr> 
   <td>unsigned short int</td> 
   <td>0 - (2<sup>16</sup>-1)</td> 
   <td>2</td> 
  </tr> 
  <tr> 
   <td>long int</td> 
   <td>-2<sup>31</sup> - (2<sup>31</sup>-1)</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td>unsigned long</td> 
   <td>0 - (2<sup>32</sup>-1)</td> 
   <td>4</td> 
  </tr> 
 </tbody> 
</table>

整型变量的定义和使用举例如下：

#include <stdio.h>
    
    void main()
    { 
        int a, b, c, d;
        unsigned u;
        a = 5;
        b = -15;
        u = 12;
        c = a + u;
        d = b + u;
        printf("a+u=%d, b+u=%d\n", c, d);
    }

打印：

a+u=17, b+u=-3

在编译运行时a、b、c、d与u的数据类型不一样，会自动将无符号型转化为默认类型有符号型再进行计算。

整型数据的溢出举例如下：

#include <stdio.h>
    
    void main()
    { 
        short int a, b;
        a = 32767;
        b = a + 1;
        printf("%d, %d", a, b);
    }

打印：

32767, -32768

显然，出现了负数-32768。  
解释：在本机编译环境中，short int是2个字节16位，216=65536，65536÷2=32768，即short int有符号型的范围是 **-32768-32767**，而程序中b的值为32768，超出范围即溢出，其二进制为1000000000000000，此时最高位为1表示负数，所以显示了-32768。

再举一个例子，如下：

#include <stdio.h>
    
    void main()
    { 
        long x, y;
        int a, b, c, d;
        x = 5;
        y = 6;
        a = 7;
        b = 8;
        c = x + a;
        d = y + b;
        printf("c=x+a=%d, d=y+b=%d", c, d);
    }

打印：

c=x+a=12, d=y+b=14

从程序中可以看到：  
x、y是长整型变量，a、b是基本整型变量，它们之间允许进行运算，运算结果为长整型。但c，d被定义为基本整型，此最后结果为基本整型。  
本例说明，不同类型的量可以参与运算并相互赋值，其中的类型转换是由编译系统自动完成的。

## 4.实型数据 ##

### Ⅰ.实型常量的表示方法 ###

实型也称为浮点型，实型常量也称为实数或者浮点数。  
在C语言中，实数**只采用十进制**。  
它有二种形式：十进制小数形式和指数形式：

*  十进制小数形式  
    由数码0-9和小数点组成，必须有小数点。  
    例如0.0、25.0、5.789、0.13、5.0、300.、-267.8230等均为合法的实数。  
    标准C允许浮点数使用后缀，后缀为 **f或F** 即表示该数为浮点数，如 356f 和 356. 是等价的。
 *  指数形式  
    由十进制数、阶码标志“e”或“E”和阶码（只能为整数，可以带符号）组成。  
    其一般形式为：
    
        aEn（a为十进制数，n为十进制整数）
    
    例如：
    
    > 2.1E5 (等于2.1*105)  
    > 3.7E-2 (等于3.7*10-2)  
    > 0.5E7 (等于0.5*107)  
    > \-2.8E-2 (等于-2.8*10-2)
    
    以下不是合法的实数：
    
    > 345 (无小数点)  
    > E7 (阶码标志E之前无数字)  
    > \-5 (无阶码标志)  
    > 53.-E3 (负号位置不对)  
    > 2.7E (无阶码)

### Ⅱ.实型变量 ###

#### 实型数据在内存中的存放形式 ####

实型数据一般占4个字节（32位）内存空间，按指数形式存储。  
浮点数的二进制存储方式如下：  
![浮点数的二进制存储方式][20200416122916716.png_pic_center]  
举例3.14159在内存中的存放形式如下：

*  小数部分占的位（bit）数愈多，数的有效数字愈多，精度愈高;
 *  指数部分占的位数愈多，则能表示的数值范围愈大。

#### 实型变量的分类 ####

*  单精度（float型）
 *  双精度（double型）
 *  长双精度（long double型）

在Turbo C中单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38-3.4E+38，只能提供七位有效数字；双精度型占8个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。

<table> 
 <thead> 
  <tr> 
   <th>类型说明符</th> 
   <th>比特数（字节数）</th> 
   <th>有效数字</th> 
   <th>数值范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>float</td> 
   <td>32(4)</td> 
   <td>6-7</td> 
   <td>-2<sup>128</sup> - 2<sup>128</sup></td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>64(8)</td> 
   <td>15-16</td> 
   <td>-2<sup>1024</sup> - 2<sup>1024</sup></td> 
  </tr> 
  <tr> 
   <td>long double</td> 
   <td>128(16)</td> 
   <td>18-19</td> 
   <td>-2<sup>16384</sup> - 2<sup>16384</sup></td> 
  </tr> 
 </tbody> 
</table>

#### 实型数据的舍入误差 ####

测试如下：

#include <stdio.h>
    
    int main()
    { 
        float a, b;
        a = 123456.789e5;
        b = a + 20;
        printf("%f\n", a);
    	printf("%f\n", b);
    	return 0; 
    }

打印：

12345678848.000000
    12345678848.000000

显然，a的值已经不准确，整数部分后3位产生误差，同时b在a的基础上加20（两位数，在后边的3位误差之内）也会产生误差。

计算以下表达式的值：

> （1）1.0 / 3 \* 3等于多少？  
> （2）3 / 2呢？  
> （3）1 / 3 \* 3呢？

通过程序计算：

#include <stdio.h>
    
    int main()
    { 
        printf("%f\n", 1.0 / 3 * 3);
    	printf("%f\n", 3 / 2);
    	printf("%f\n", 1 / 3 * 3);
    	return 0; 
    }

打印：

1.000000
    0.000000
    0.000000

## 5.字符型数据 ##

字符型数据包括字符常量和字符变量。

### 字符常量 ###

字符常量是用单引号括起来的**一个字符**。  
例如：‘a’、‘b’、’=’、’+’、’?'等都是合法字符常量。

在C语言中，字符常量有以下特点：

*  字符常量只能用单引号括起来，不能用双引号或其它括号。
 *  字符常量只能是单个字符，不能是字符串。
 *  字符可以是字符集中任意字符，但数字被定义为字符型之后就不能参与数值运算。  
    如’5’和5是不同的，'5’是字符常量，不能参与运算。

### 字符变量 ###

字符变量用来存储字符常量，即单个字符，类型说明符是char。  
字符变量类型定义的格式和书写规则都与整型变量相同，例如：

char a, b;

### 转义字符 ###

转义字符是一种特殊的字符常量，以反斜线"\\"开头，后跟一个或几个字符。  
转义字符具有特定的含义，不同于字符原有的意义，故称**转义**字符。  
例如，在之前的练习中`printf()`函数的格式串中用到的 **\\n** 就是一个转义字符，其意义是**回车换行**。  
转义字符主要用来表示那些用一般字符不便于表示的控制代码。  
所有的转义字符及其含义如下：

<table> 
 <thead> 
  <tr> 
   <th>转义字符</th> 
   <th>含义</th> 
   <th>ASCII码值（十进制）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\a</td> 
   <td>响铃(BEL)</td> 
   <td>007</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>退格(BS) ，将当前位置移到前一列</td> 
   <td>008</td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td>换页(FF)，将当前位置移到下页开头</td> 
   <td>012</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>换行(LF) ，将当前位置移到下一行开头</td> 
   <td>010</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>回车(CR) ，将当前位置移到本行开头</td> 
   <td>013</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>水平制表(HT) （跳到下一个TAB位置）</td> 
   <td>009</td> 
  </tr> 
  <tr> 
   <td>\v</td> 
   <td>垂直制表(VT)</td> 
   <td>011</td> 
  </tr> 
  <tr> 
   <td>\</td> 
   <td>代表一个反斜线字符’\</td> 
   <td>092</td> 
  </tr> 
  <tr> 
   <td>’</td> 
   <td>代表一个单引号（撇号）字符</td> 
   <td>039</td> 
  </tr> 
  <tr> 
   <td>"</td> 
   <td>代表一个双引号字符</td> 
   <td>034</td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>代表一个问号</td> 
   <td>063</td> 
  </tr> 
  <tr> 
   <td>\0</td> 
   <td>空字符(NUL)</td> 
   <td>000</td> 
  </tr> 
  <tr> 
   <td>\ddd</td> 
   <td>1到3位八进制数所代表的任意字符</td> 
   <td>三位八进制</td> 
  </tr> 
  <tr> 
   <td>\xhh</td> 
   <td>十六进制所代表的任意字符</td> 
   <td>十六进制</td> 
  </tr> 
 </tbody> 
</table>

转义字符的使用：

#include <stdio.h>
    
    int main()
    { 
        int a, b, c;
        a = 5, b = 6, c = 7;
        printf(" ab c\tde\rf\n");
        printf("hijk\tL\bM\n");
    	return 0; 
    }

打印：

fab c   de
    hijk    M

**字符数据在内存中的存储形式及使用方法：**  
每个字符变量被分配一个字节的内存空间，因此只能存放一个字符。  
字符值是以ASCII码的形式存放在变量的内存单元之中的，如x的十进制ASCII码是120，y的十进制ASCII码是121。  
对字符变量a、b赋予’x’和’y’值：

a ='x';
    b = '7';

实际上是在a、b两个单元内存放120和55的二进制值。

向字符变量赋以整数：

#include <stdio.h>
    
    int main()
    { 
        char a, b;
        a = 120;
        b = 121;
        printf("%c, %c\n", a, b);
        printf("%d, %d\n", a, b);
    	return 0; 
    }

显示：

x, y
    120, 121

本程序中定义a、b为字符型，但在赋值语句中赋以整型值。  
从结果可以看到，a、b值的输出形式取决于`printf()`函数格式串中的格式符，当格式符为"c"时，对应输出的变量值为字符，当格式符为"d"时，对应输出的变量值为整数。

下面的代码的效果是一样的：

#include <stdio.h>
    
    int main()
    { 
        char a, b;
        a = 'x';
        b = 'y';
        printf("%c, %c\n", a, b);
        printf("%d, %d\n", a, b);
    	return 0; 
    }

练习--小写字母转变成大写字母：

#include <stdio.h>
    
    int main()
    { 
        char a, b;
        a = 'a';
        b = 'b';
        a = a - 32;
        b = b - 32;
        printf("%c, %c\n%d, %d\n", a, b, a, b);
        
    	return 0; 
    }

打印：

A, B
    65, 66

`char a = 33`和`int a = 33`的比较：

#include <stdio.h>
    
    int main()
    { 
        char a;
        int b;
        a = 33;
        b = 33;
        printf("%c, %c\n%d, %d\n", a, b, a, b);
        
    	return 0; 
    }

打印：

!, !
    33, 33

显然，效果是一样的，char是int的一种特殊情况，char占1个字节，int占4个字节，显然char更节省内存。

### 字符串常量 ###

字符串常量是由一对双引号括起的字符序列。  
例如：“CHINA”、“C program”、"$12.5" 等都是合法的字符串常量。

字符串常量和字符常量是不同的量。它们之间主要有以下区别：

*  字符常量由单引号括起来，字符串常量由双引号括起来。
 *  字符常量只能是单个字符，占八位，字符串常量则可以含一个或多个字符。
 *  可以把一个字符常量赋值给一个字符变量，但不能把一个字符串常量赋值给一个字符变量。  
    例如：可以`char a = 'a';`，但不能`char a = "a";`。
 *  字符常量占一个字节的内存空间，字符串常量占的内存字节数等于字符串中字节数加1，增加的一个字节中存放字符 **\\0** (ASCII码为0)，这是字符串结束的标志。  
    例如，字符串**C program**在内存中所占的字节示意如下：  
    ![c program 0][]

字符常量’a’和字符串常量"a"虽然都只有一个字符，但在内存中的情况是不同的：

*  'a’在内存中占一个字节；
 *  "a"在内存中占二个字节。

对比如下：  
![字符和字符串][20200416123446181.png_pic_center]

## 6.变量赋初值 ##

在程序中常常需要对变量赋初值，以便使用变量。  
C语言中有多种方法为变量提供初值，在作变量定义的同时给变量赋以初值的方法称为初始化。  
在变量定义中赋初值的一般形式为：

类型说明符 变量1 = 值1, 变量2 = 值2, ……;

例如：

int a=3;
    int b, c=5;
    float x=3.2, y=3f, z=0.75;
    char ch1='K', ch2='P';

## 7.变量类型转换 ##

变量的数据类型是可以转换的。  
转换的方法有两种，一种是自动转换，一种是强制转换。

### 自动类型转换 ###

自动转换发生在不同数据类型的量混合运算时，由编译系统自动完成。  
自动转换遵循以下规则：

*  若参与运算量的类型不同，则先转换成同一类型，然后进行运算。
 *  转换按**数据长度增加**的方向进行，以保证**精度不降低**。如int型和long型运算时，先把int量转成long型后再进行运算，来保证损失较低、精度较高。
 *  所有的**浮点运算都是以双精度进行**的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。
 *  char型和short型参与运算时，必须先**转换成int型**。
 *  在赋值运算中，赋值号两边量的数据类型不同时，赋值号**右边量的类型将转换为左边量的类型**。如果右边量的数据类型长度大于左边时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入。

类型自动转换的规则如下：  
![类型自动转换][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NVRkVFQ1I_size_16_color_FFFFFF_t_70_pic_center 1]

举例如下：

#include <stdio.h>
    
    int main()
    { 
        float PI = 3.14159;
        int s, r = 5;
        s = r * r * PI;
        printf("s=%d\n", s);
    	    
    	return 0; 
    }

打印：

s=78

程序中，PI为实型，s、r为整型。在执行`s = r * r * PI;`语句时，r和PI都转换成double型计算，结果也为double型。但由于s为整型，故赋值结果仍为整型，舍去了小数部分。  
显然，精度出现损失，可以将s声明为double或float型，计算结果就会更准确，如下：

#include <stdio.h>
    
    int main()
    { 
        float s, PI = 3.14159;
        int r = 5;
        s = r * r * PI;
        printf("s=%f\n", s);
    	    
    	return 0; 
    }

打印：

s=78.539749

显然，此时结果精确度更高。

### 强制类型转换 ###

强制类型转换是通过**类型转换运算符**来实现的。  
其一般形式为：

(类型说明符)  (表达式)

其功能是把表达式的运算结果强制转换成类型说明符所表示的类型。  
例如：

(float) a      // 把a转换为实型
    (int)(x+y)     // 把x+y的结果转换为整型

在使用强制转换时应注意以下问题：

*  类型说明符和表达式都必须加括号(单个变量可以不加括号)，如把`(int)(x+y)`写成`(int)x+y`则成了把x转换成int型之后再与y相加了。
 *  无论是强制转换或是自动转换，都只是为了本次运算的需要而对变量的数据长度进行的临时性转换，而**不改变数据说明时对该变量定义的类型**。

举例如下：

#include <stdio.h>
    
    int main()
    { 
        float f = 3.14159;
        printf("(int)f=%d, f=%f\n", (int)f, f);
    	    
    	return 0; 
    }

显示：

(int)f=3, f=3.141590

因此，`(int)f`的值为3(删去了小数)而f的值不变，仍为3.14159。  
本例表明，f虽强制转为int型，但只在运算中起作用，是临时的，而f变量本身的类型并不改变。

# 二、运算符和表达式 #

## 1.基本算术运算符 ##

*  加法运算符+  
    加法运算符为双目运算符，即应有两个量参与加法运算，如a+b、4+8等。具有**右结合性**。
 *  减法运算符-  
    减法运算符为双目运算符，但“-”也可作负值运算符，此时为单目运算，如-x, -5等具有**左结合性**。
 *  乘法运算符\*  
    双目运算，具有**左结合性**。
 *  除法运算符/  
    双目运算，具有**左结合性**。  
    参与运算量均为整型时，结果也为整型，舍去小数；如果运算量中有一个是实型，则结果为双精度实型。
 *  取余运算符%  
    双目运算，当运算符%的操作数（被除数和除数）均为整数时，结果为取余。  
    例如，`16%5`的结果为两数相除的余数1。  
    当运算符%的操作数中有一个或两个浮点数时，会产生语法错误。  
    例如`8%2.5`存在语法错误。
    
    举例如下：
    
        #include <stdio.h>
        
        int main()
        {
            printf("\n%d, %d\n", 20 / 7, -20 / 7);
            printf("%f, %f\n", 20.0 / 7, -20 / 7.0);
            printf("%d\n", 100 % 3);
        	    
        	return 0; 
        }
    
    打印：
    
        2, -2
        2.857143, -2.857143
        1

## 2.运算符的优先级和结合性 ##

*  运算符的优先级  
    C语言中，运算符的运算优先级共分为15级，1级最高，15级最低。  
    在表达式中，优先级较高的先于优先级较低的进行运算，而在一个运算量两侧的运算符优先级相同时，则按运算符的结合性所规定的结合方向处理。
 *  运算符的结合性  
    C语言中各运算符的结合性分为两种，即**左结合性**(自左至右)和**右结合性**(自右至左)。  
    例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z则y应先与“-”号结合，执行x-y运算，然后再执行+z的运算。这种自左至右的结合方向就称为“左结合性”。  
    而自右至左的结合方向称为“右结合性”。最典型的右结合性运算符是赋值运算符，如x=y=z,由于“=”的右结合性，应先执行y=z再执行x=(y=z)运算。  
    C语言运算符中有不少为右结合性，应注意区别，以避免理解错误。

C语言中运算符的优先级和结合性如下：  
![算术运算符的优先级和结合性][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NVRkVFQ1I_size_16_color_FFFFFF_t_70_pic_center 2]

## 3.高级运算符 ##

### 强制类型转换运算符 ###

见**强制类型转换**部分。

### 自增、自减运算符 ###

自增1、自减1运算符：

*  自增1运算符记为“++”，其功能是使变量的值自增1；
 *  自减1运算符记为“--”，其功能是使变量值自减1。

自增1，自减1运算符均为单目运算，都具有右结合性。可有以下几种形式：

*  \++i  
    i自增1后再参与其它运算。
 *  \--i  
    i自减1后再参与其它运算。
 *  i++  
    i参与运算后，i的值再自增1。
 *  i--  
    i参与运算后，i的值再自减1。

自增、自减运算符测试：

#include <stdio.h>
    
    int main()
    { 
        int i = 8;
        printf("%d\n", ++i);
        printf("%d\n", --i);
        printf("%d\n", i++);
        printf("%d\n", i--);
        printf("%d\n", -i++);
        printf("%d\n", -i--);
        printf("%d\n", i);
    	    
    	return 0; 
    }

打印：

9
    8
    8
    9
    -8
    -9
    8

再如：

#include <stdio.h>
    
    int main()
    { 
        int i = 5, j = 5, p ,q;
        p = (i++) + (i++) + (i++);
        q = (++j) + (++j) + (++j);
        printf("%d, %d, %d, %d\n", p, q, i, j);
        i = 5, j = 5;
        p = i++ + i++ + i++;
        q = ++j + ++j + ++j;
        printf("%d, %d, %d, %d\n", p, q, i, j);
    	    
    	return 0; 
    }

打印：

18, 22, 8, 8
    18, 22, 8, 8

### 赋值运算符和赋值表达式 ###

简单赋值运算符和表达式：  
简单赋值运算符记为“=”，由“= ”连接的式子称为**赋值表达式**，其一般形式为：

变量 = 表达式

例如：

x = a + b
    w = sin(a) + sin(b)
    y = i + j

赋值表达式的功能是计算表达式的值再赋予左边的变量，具有右结合性，因此`a=b=c=5`可理解为 `a=(b=(c=5))`。

如果赋值运算符两边的数据类型不相同，系统将自动进行类型转换，即把赋值号右边的类型换成左边的类型，具体如下：

*  实型赋予整型，舍去小数部分。
 *  整型赋予实型，数值不变，但将以浮点形式存放，即增加小数部分(小数部分的值为0)。
 *  字符型赋予整型，由于字符型为1个字节，而整型为4个字节，故将字符的ASCII码值放到整型量的低8位中，其余高位为0。
 *  整型赋予字符型，只把低8位赋予字符量。

举例如下：

#include <stdio.h>
    
    int main()
    { 
        int a, b = 322;
        float x, y = 8.88;
        char c1 = 'k', c2;
        a = y;
        printf("%d\n", a);
        x = b;
        a = c1;
    	c2 = b;
    	printf("%f, %d, %c", x, a, c2);  
    	    
    	return 0; 
    }

打印：

8
    322.000000, 107, B

在赋值符“=”之前加上其它二目运算符可构成复合赋值符。如+=、-=、\*=、／=、%=、<<=、>>=、&=、^=和|=等。  
用法举例如下：

a+=5      // 等价于a=a+5
    x*=y+7    // 等价于x=x*(y+7)
    r%=p      // 等价于r=r%p

复合赋值符这种写法，对初学者可能不习惯，但十分有利于编译处理，能**提高编译效率**并产生质量较高的目标代码。

### 逗号运算符和逗号表达式 ###

在Ｃ语言中逗号“,”也是一种运算符，称为逗号运算符，其功能是把两个表达式连接起来组成一个表达式，称为逗号表达式。  
其一般形式为`表达式1, 表达式2`。  
求值过程是分别求两个表达式的值，并以表达式2的值作为整个逗号表达式的值。  
如下：

#include <stdio.h>
    
    int main()
    { 
        int a = 2, b = 4, c = 6, x, y;
    	y = (b + c,(x = a + b));	// 逗号运算符
    	printf("y=%d, x=%d", y, x);
    	    
    	return 0; 
    }

打印：

y=6, x=6

对于逗号表达式要注意：

*  逗号表达式一般形式中的表达式1和表达式2也可以是逗号表达式。  
    例如`表达式1，(表达式2，表达式3)`形成了嵌套情形，因此可以把逗号表达式扩展为`表达式1，表达式2，…表达式n`，整个逗号表达式的值等于表达式n的值。
 *  程序中使用逗号表达式，通常是要分别求逗号表达式内各表达式的值，并不一定要求整个逗号表达式的值。  
    并不是在所有出现逗号的地方都组成逗号表达式，如在变量说明中和函数参数表中逗号只是用作各变量之间的间隔符。

[C]: /images/20230521/cbf505a4eb89446c9e9c5a987440ea18.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NVRkVFQ1I_size_16_color_FFFFFF_t_70_pic_center]: /images/20230521/44b6994d374c4027ad5a68c06147cd86.png
[20200416122916716.png_pic_center]: /images/20230521/9f32fac746d2466ca5a490b5bc2ec15e.png
[c program 0]: /images/20230521/745cfc79233c4b7c8c7fb014152f3c62.png
[20200416123446181.png_pic_center]: /images/20230521/378db21d9a0d4ee38facdaeb451259ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NVRkVFQ1I_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230521/2ca8e1659d774bb3a149ef9002c3886a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NVRkVFQ1I_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20230521/d8ed08c308f443fca61201382bd50e57.png