c语言 运算符与表达式

C语言 数据类型、运算符与表达式

1. 关键字与标识符的概念、应用特点：

1.1 关键字

关键字是编程语言中预先定义好的具有特殊含义的单词，不能作为标识符（变量名、函数名等）使用。例如，在C语言中，if、for、while等都是关键字。

关键字不能被取做变量名、函数名等。

常见的关键字如下表所示：

c语言	常见	关键字	表
auto	double	int	struct
break	else	long	switch
case	enum	register	typedef
char	extern	return	union
const	float	short	unsigned
continue	for	signed	void
default	goto	sizeof	volatile
do	if	static	while

1.2 标识符

是由程序员自定义的名称，用于表示变量、函数、类等。标识符的命名要符合语言规范，通常由字母、数字和下划线组成，但不能以数字开头。

比如 a1是合法的标识符 但是1a不是合法的标识符

2. 数据类型的含义和常量、变量的分类：

2.1数据类型

定义了变量可以存储的数据类型及其操作。常见的数据类型包括整数（int）、浮点数（float）、字符串（string）、布尔值（boolean）等。

常见的数据类型如下表所示：

数据类型	描述	范围大小	占用大小
char	字符类型，用于表示单个字符	-128 到 127（有符号）或 0 到 255（无符号）	1 字节
signed char	有符号字符类型	-128 到 127	1 字节
unsigned char	无符号字符类型	0 到 255	1 字节
int	整数类型，通常表示整数值	-2147483648 到 2147483647（有符号）	4 字节
unsigned int	无符号整数类型	0 到 4294967295	4 字节
short	短整型，表示较小范围的整数值	-32768 到 32767（有符号）	2 字节
unsigned short	无符号短整型	0 到 65535	2 字节
long	长整型，表示更大范围的整数值	-9223372036854775808 到 9223372036854775807	8 字节
unsigned long	无符号长整型	0 到 18446744073709551615	8 字节
long long	长长整型，更大范围的整数值	-9223372036854775808 到 9223372036854775807	8 字节
unsigned long long	无符号长长整型	0 到 18446744073709551615	8 字节
float	单精度浮点数，用于表示带有小数部分的数值	1.2E-38 到 3.4E+38	4 字节
double	双精度浮点数，比float类型精度更高	2.3E-308 到 1.7E+308	8 字节
long double	长双精度浮点数，比double类型精度更高	3.4E-4932 到 1.1E+4932	16 字节
bool	布尔类型，表示逻辑真（true）或逻辑假（false）	true 或 false	1 字节
struct	结构体类型，用于定义包含多个不同类型成员的复合数据结构	视成员而定	视成员而定
enum	枚举类型，用于定义一组相关的命名常量	视定义而定	视定义而定
union	联合类型，用于定义一种特殊的数据结构，多个成员共享同一块内存	最大成员大小	最大成员大小
typedef	类型定义，用于为现有的数据类型创建一个新的名称	无法确定	无法确定

在大多数32位系统上，int类型通常占用4字节，而在64位系统上通常也是如此。
在大多数系统上，long类型通常在32位系统上占用4字节，在64位系统上占用8字节。
在大多数系统上，指针类型通常在32位系统上占用4字节，在64位系统上占用8字节。

2.2 常量

是不可变的值，其值在程序执行过程中保持不变。常量通常用于表示固定的数值或信息。

c语言中常常使用const关键字来修饰常量，表示这个被const修饰的变量在程序运行的时候不会有所改变。

  #include <stdio.h>
  
  int main() {
      // 整数常量
      const int x = 10;
      printf("整数常量 x 的值为：%d\n", x);
  
      // 浮点数常量
      const float pi = 3.14;
      printf("浮点数常量 pi 的值为：%f\n", pi);
  
      // 字符常量
      const char letter = 'A';
      printf("字符常量 letter 的值为：%c\n", letter);
  
      // 字符串常量
      const char *str = "Hello, World!";
      printf("字符串常量 str 的值为：%s\n", str);
  
      return 0;
  }

2.3 变量

是可变的值，其值可以在程序执行过程中改变。变量通常用于存储需要在程序中操作或处理的数据。
即不使用const修饰的其他任何量都是变量。

  #include <stdio.h>
  
  int main() {
      // 整数变量
      int x = 10;
      printf("整数变量 x 的值为：%d\n", x);
  
      // 浮点数变量
      float pi = 3.14;
      printf("浮点数变量 pi 的值为：%f\n", pi);
  
      // 字符变量
      char letter = 'A';
      printf("字符变量 letter 的值为：%c\n", letter);
  
      // 字符串变量
      char str[] = "Hello, World!";
      printf("字符串变量 str 的值为：%s\n", str);
  
      return 0;
  }
  

3. 各类运算符的含义、优先级，各类表达式的表示方法、运算特点、值的类型和计算方法：

3.1 运算符

用于执行各种操作，例如算术运算、比较、逻辑运算等。常见的运算符包括加减乘除（算术运算符）、大于小于等于（比较运算符）、与或非（逻辑运算符）等。

运算符	描述
+	加法运算符，用于将两个数相加
-	减法运算符，用于将一个数减去另一个数
*	乘法运算符，用于将两个数相乘
/	除法运算符，用于将一个数除以另一个数
%	取模运算符，用于取得两个数相除的余数
++	自增运算符，用于将变量的值增加1
–	自减运算符，用于将变量的值减少1
=	赋值运算符，用于将右侧表达式的值赋给左侧变量
+=	加等于运算符，相当于 a = a + b
-=	减等于运算符，相当于 a = a - b
*=	乘等于运算符，相当于 a = a * b
/=	除等于运算符，相当于 a = a / b
%=	取模等于运算符，相当于 a = a % b
==	等于运算符，用于比较两个值是否相等
!=	不等于运算符，用于比较两个值是否不相等
>	大于运算符，用于比较左侧值是否大于右侧值
<	小于运算符，用于比较左侧值是否小于右侧值
>=	大于等于运算符，用于比较左侧值是否大于或等于右侧值
<=	小于等于运算符，用于比较左侧值是否小于或等于右侧值
&&	逻辑与运算符，用于逻辑与操作
||	逻辑或运算符，用于逻辑或操作
!	逻辑非运算符，用于逻辑非操作
&	按位与运算符，用于执行按位与操作
|	按位或运算符，用于执行按位或操作
^	按位异或运算符，用于执行按位异或操作
~	按位取反运算符，用于执行按位取反操作
<<	左移运算符，用于将二进制数向左移动指定位数
>>	右移运算符，用于将二进制数向右移动指定位数

3.2 短路运算符

在C语言中，短路逻辑运算符有两个：逻辑与运算符（&&）和逻辑或运算符（||）。这两个运算符都具有短路求值的特性，即在第一个操作数确定整个表达式的结果时，就不再计算第二个操作数。

逻辑与运算符（&&）：当第一个操作数为假时，整个表达式的结果就是假，此时不再计算第二个操作数。只有当第一个操作数为真时，才会继续计算第二个操作数。
逻辑或运算符（||）：当第一个操作数为真时，整个表达式的结果就是真，此时不再计算第二个操作数。只有当第一个操作数为假时，才会继续计算第二个操作数。

  #include <stdio.h>
  
  int main() {
      int a = 5;
      int b = 0;
  
      // 使用逻辑与运算符
      if (a > 0 && b != 0) {
          printf("a 大于 0 并且 b 不等于 0\n");
      } else {
          //由于a大于0，但b等于0，不判断后续！=0，直接短路，运行else部分
          printf("a 不大于 0 或者 b 等于 0\n");
      }
  
      // 使用逻辑或运算符
      if (a > 0 || b != 0) {
          //由于a大于0，不进行b的判断，直接短路，运行if部分
          printf("a 大于 0 或者 b 不等于 0\n");
      } else {
          printf("a 不大于 0 并且 b 等于 0\n");
      }
  
      return 0;
  }
  

3.3 表达式

由运算符和操作数组成的结构，用于表示特定的计算或操作。表达式的值可以是一个常量、一个变量或一个运算的结果。

  #include <stdio.h>
  
  int main() {
      int a = 5;
      int b = 3;
      int c;
  
      // 表达式示例：a + b
      c = a + b;
      printf("a + b 的值为：%d\n", c);
  
      // 表达式示例：a * b - 2
      c = a * b - 2;
      printf("a * b - 2 的值为：%d\n", c);
  
      // 表达式示例：(a + b) * (a - b)
      c = (a + b) * (a - b);
      printf("(a + b) * (a - b) 的值为：%d\n", c);
  
      // 表达式示例：a / b
      // 注意：整数除法，结果会取整，小数部分会被舍弃
      c = a / b;
      printf("a / b 的值为：%d\n", c);
  
      return 0;
  }
  

3.4 运算优先级

不同运算符具有不同的优先级，决定了它们在表达式中的计算顺序。例如，乘法通常优先于加法执行。

运算符的优先级越小，表示优先度越高，越先被运算。

对于同一级别优先级的运算符，会根据结合性（associativity）来确定执行顺序。结合性指的是运算符在表达式中的组合方式，有左结合性（left-associative）和右结合性（right-associative）两种情况。执行时对于同一优先级的运算符先执行左结合再执行右结合。

左结合性：运算符从左向右结合。例如，加法运算符（+）就是左结合性的，所以表达式 a + b + c 会先计算 a + b，然后再加上 c。
右结合性：运算符从右向左结合。例如，赋值运算符（=）就是右结合性的，所以表达式 a = b = c 会先计算 b = c，然后再将结果赋值给 a。

优先级	运算符	描述	结合性
1	()	括号	左
2	++ –	自增和自减	右
	+ -	正负号	右
	! ~	逻辑非和按位取反	右
	(类型)	类型转换	右
	*	指针解引用	右
	&	取地址	右
	sizeof	长度（字节数）	右
3	* / %	乘法、除法、取模	左
4	+ -	加法、减法	左
5	<< >>	左移、右移	左
6	< <=	小于、小于等于	左
	> >=	大于、大于等于	左
7	== !=	等于、不等于	左
8	&	按位与	左
9	^	按位异或	左
10	|	按位或	左
11	&&	逻辑与	左
12	||	逻辑或	左
13	?:	三元条件运算符	右
14	= += -= *= /= %= <<= >>= &=	赋值及复合赋值运算符	右
	^= |=
15	,	逗号	左

3.5 混合运算

指在一个表达式中同时包含多种类型的运算符和操作数，需要按照运算符的优先级和结合性进行计算。

   #include <stdio.h>
   
   int main() {
       int a = 5;  // 初始化变量a为5
       int b = 3;  // 初始化变量b为3
       int c = 2;  // 初始化变量c为2
       int result; // 定义结果变量
   
       // 计算表达式
       result = (++a + b--) * (c++ / 2) + (--a - b) % c;
       // 在结果中打印值
       printf("Result: %d\n", result);
   
       return 0;
   }
   

1. ++a：a 的值先自增为 6，然后返回新的值 6。

2. b–：b 的值先使用，然后再自减为 2，返回旧的值 3。

3. (c++ / 2)：c 的值先使用，然后再自增为 3，然后除以 2，结果为 1。

4. (6 + 3) * 1：把步骤1和2的结果相加，得到 9，然后乘以步骤3的结果 1，得到 9。

5. –a：a 的值先自减为 5，然后返回新的值 5。

6. –b：b 的值先自减为 1，然后返回新的值 2。

7. 5 - 2：把步骤5和6的结果相减，得到 3。

8. 3 % 3：把步骤7的结果同3取模，得到 0。

9. 9 + 0 ：步骤4的结果加上步骤8的结果，得到 9。

10. 最终的结果 result 是 9。

(6 + 3) * 1 + (5 - 2) % 3
= (9) * 1 + (3) % 3
= 9 + 0
= 9