【C语言程序设计笔记】

C语言操作符详解与例程

/知识点汇总/
(1)概念：操作符就是说明特定操作的符号，它是构造C语言表达式的工具
(2)常见的三大类：算术运算符、关系运算符与逻辑运算符之外，还有一些用于完成特殊任务的运算符，比如位运算符等。

1、算数操作符

算术操作符：+，-，*，/，%
注意：
a、% 操作符不能用于浮点数，只能作用于整数，如果作用于浮点数将会报错。
b、当/ 两边的操作都是整数，执行的就是整数除法
c、 当/ 两边的操作数有一个数为浮点数的话，执行的是浮点数除法

1.1、算术操作符例程

/*例程1.1*/
#include <stdio.h>
int main()
{
	int a = 6 / 5;//0.6
	printf("%d\n",a);//1

	int e = 6.0 / 5.0;
	printf("%d\n",e);//1

	float b = 6 / 5;
	printf("%f\n",b);//1.000000

	float c = 6.0 / 5.0;
	printf("%f\n",c);//1.200000

	float d = 6.0 / 5;
	printf("%f\n", d);//1.200000

	int f = 6 % 5;
	printf("%d\n",f);//1
	//%操作符的两个操作数必须为整数
	return 0;
}

2、移位操作符

移位操作符：
<< 左移操作符
>> 右移操作符
左移操作符规则：左边抛弃，右边补0
右移操作符规则：1.算术右移 2.逻辑右移
右移正整数
1.算术右移：右边丢弃，左边补原符号位
2.逻辑右移：右移丢弃，左边补0
右移负整数
负数，存放在内存中，存放的是二进制的补码
原码：直接根据数值写出的二进制序列就是原码
反码：原码的符号位不变，其他位按位取反就是反码
补码：反码右边加1，就是补码
注意：被移动的数不可为负数,且为整数

2.1、移位操作符例程1

/*例程2.1*/
#include <stdio.h>
int main()
{
	int a = 2;
	//把a的二进制向左移动一位
	int b = a << 1;
	//左移N位，就增大2的N次方倍
	printf("b = %d\n",b);//4

	int c = 10;
	//把c的二进制位向右移动1位
	int d = c >> 1;
	//右移N位，就增大2的N次方倍
	printf("d = %d\n",d);//5
	return 0;
}

2.2、移位操作符例程2

/*例程2.2*/
#include <stdio.h>
int main()
{
	int a = -1;
	//-1原码：1000 0000 0000 0001
	//-1反码：1111 1111 1111 1110
	//-1补码：1111 1111 1111 1111
	//负数，存放在内存中，开头的1表示负数
	//正数，以二进制存放
	//原码、反码、补码
	//把a的二进制向右移动一位
	int b = a >> 1;
	//根据输出为-1，可知当前右移操作符默认为，算数右移
	//逻辑右移为1777
	printf("b = %d\n", b);//-1
	return 0;
}

3、位操作符

位操作符：
按位与 &
按位或 |
异或 ^
注意：
操作数需为整数
异或操作：a异或b异或b = a
a^a = 0

3.1、位操作符例程1

/*例程3.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	//&---按(二级制)位与
	//规则：有0为0，全1为1
	int c = a & b;
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	//C: 0000 0000 0000 0000 0000 0000 0000 0001----1
	printf("%d\n",c);//1

	//|---按(二级制)位或
	//规则：有1为1，全0为0
	int d = a | b;
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	//C: 0000 0000 0000 0000 0000 0000 0000 0111----7
	printf("%d\n", d);//7

	//^---按(二级制)位异或
	//规则：相同为0，相异为1
	int e = a ^ b;
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	//C: 0000 0000 0000 0000 0000 0000 0000 0110----6
	printf("%d\n", e);//6
	return 0;
}

3.2、位操作符例程2

/*例程3.2*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	printf("a = %d b = %d\n", a, b);
	//交换
	//3：0000 0000 0000 0000 0000 0000 0000 0011
	//5：0000 0000 0000 0000 0000 0000 0000 0101
	a = a ^ b;//3^5
	//a: 0000 0000 0000 0000 0000 0000 0000 0110--6
	b = a ^ b;//6^5
	//b: 0000 0000 0000 0000 0000 0000 0000 0011--3
	a = a ^ b;//6^3
	//a: 0000 0000 0000 0000 0000 0000 0000 0101--5
	printf("a = %d b = %d\n", a, b);
	return 0;
}

4、赋值操作符

赋值操作符：=
注意：区分 赋值= 与 判断 ==
一个赋值，一个判断

4.1、赋值操作符例程1

/*例程4.1*/
#include <stdio.h>
int main()
{
	//初始化赋值
	int weight = 120;
	int high = 175;
	float price = 666.66;
	//连续赋值
	int a = 10;
	int b = 0;
	int c = 20;

	a = b = c + 1;
	//等价写法
	b = c + 1;
	a = b;

	int x, y;
	int m = x + y;
	return 0;
}

5、复合赋值操作符

赋值操作符：“+= -= *= /= %= >>= <<= &= |= ^=”

5.1、复合赋值操作符例程1

/*例程5.1*/
#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	a = a + b;
	//等价于
	a += b;

	a = a << b;
	//等价
	a <<= b;
	//均同理
	return 0;
}

6、单目操作符

单目操作符：！ -（负） +（正） & sizeof ~ – ++ *(解引用) ( )强制类型转换
单目运算符对应只有一个操作数

6.1、! 单目操作符例程1

/*例程6.1*/
#include <stdio.h>
int main()
{
	int flag = 0;
	printf("%d\n",!flag);
	//flag为假打印hehe
	if (flag)
	{
		printf("hehe\n");
	}
	//flag为假打印哈哈
	if (!flag)//！取反
	{
		printf("haha\n");
	}
	return 0;
}

6.2、 -(逻辑负号) 单目操作符例程2

/*例程6.2*/
#include <stdio.h>
int main()
{
	int a = 10;
	a = -a;//-逻辑负号
	printf("%d\n", a);//-10
	a = -a;
	printf("%d\n",a);//10
	a = a - (-a);
	printf("%d\n", a);//20
	return 0;
}

6.3、sizeof单目操作符例程3

sizeof是操作符，不是函数，C语言唯一的单词形式的单目操作符

/*例程6.3*/
#include <stdio.h>
int main()
{
	int a = 10;
	char arr[10] = { 0 };
	printf("%d\n", sizeof(a));//4
	//计算a所占用的空间大小，单位是字节
	printf("%d\n", sizeof(int));//4

	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(arr));//10---char数组字节1---10个就是1*10 = 10
	//int类型那么就是10*4 = 40
	//计算a所占用的空间大小，单位是字节
	return 0;
}

6.4、sizeof易错单目操作符例程4

sizeof()易错例程

/*例程6.4*/
#include <stdio.h>
int main()
{
	short s = 5;
	int a = 10;
	printf("%d\n",sizeof(s = a + 2));
	//2,大的放不进小的，数据截断，仍为short类型，且a+2不会运算
	//且sizeof(参数)，参数的计算不对参数外起作用
	printf("%d\n",s);//5
	return 0; 
}

6.5、~ 单目操作符例程5

~取反例程

/*例程6.5*/
#include <stdio.h>
int main()
{
	int a = -1;
	//1000 0000 0000 0000 0000 0000 0000 0001---原码--开头的1表示负号，0正号
	//1111 1111 1111 1111 1111 1111 1111 1110---反码
	//1111 1111 1111 1111 1111 1111 1111 1111---补码
	//~取反
	//1111 1111 1111 1111 1111 1111 1111 1111---负数的原码等于补码-1
	//1000 0000 0000 0000 0000 0000 0000 0000---取反--0
	int b = ~a;
	printf("%d\n",b);//0
	return 0;
}

6.6、++ --单目操作符例程6

++ --例程

/*例程6.6*/
#include <stdio.h>
int main()
{
	int a = 10;
	int b = a++;//++后置，先用a后加++
	printf("%d\n",a);//11
	printf("%d\n", b);//10
	a = 10;
	int c = ++a;//++前置，先加++后用a
	printf("%d\n", a);//11
	printf("%d\n", c);//11
	a = 10;
	int d = a--;//++后置，先用a后加++
	printf("%d\n", a);//9
	printf("%d\n", d);//10
	a = 10;
	int e = --a;//++前置，先加++后用a
	printf("%d\n", a);//9
	printf("%d\n", e);//9
	a = 10;
	printf("%d\n",a++);//10
	printf("%d\n",a);//11
	a = 10;
	printf("%d\n", a--);//10
	printf("%d\n", a);//9
	return 0;
}

6.7、&/* 单目操作符例程7

&取地址，*解引用例程

/*例程6.7*/
#include <stdio.h>
int main()
{
	int a = 10;
	printf("%p\n",&a);//&--取地址
	//%p打印地址的格式符
	int* pa = &a;//pa是用来存放地址的，是指针变量
	*pa = 20;//*解引用操作符 -- 间接访问操作符
	printf("%d\n", a);
	return 0;
}

6.8、( ) 单目操作符例程8

( )强制类型转换
注意：（）括起来的是数据类型

/*例程6.8*/
#include <stdio.h>
int main()
{
	float a = 10.5;
	printf("%f\n", a);//10.500000
	int b = (int)a;//强制类型转换
	printf("%d\n",b);//10
	return 0;
}

/*例程6.8.1*/
#include <stdio.h>
void test1(int arr[])//int* arr数组首元素的地址
{
	printf("%d\n",sizeof(arr));//4
}
void test2(char ch[])//char* ch数组首元素的地址
{
	printf("%d\n", sizeof(ch));//4
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n",sizeof(arr));//40
	printf("%d\n", sizeof(ch));//10
	test1(arr);
	test2(ch);
	return 0;
}

7、关系操作符

关系操作符：> < >= <= != ==
注意：区分 赋值= 与 判断 ==
一个赋值，一个判断
比较两个字符串时，不能用== 来判断
用strcmp函数，它的形式是:strcmp(str1, str2) == 0(成立则两个字符串相等)

7.1、关系操作符例程1

/*例程7.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	if (a == b)
	{
		printf("hehe\n");
	}
	if (a != b)
	{
		printf("hehe\n");
	}
	if (a < b)
	{
		printf("hehe\n");
	}
	return 0;
}

8、逻辑操作符

逻辑操作符：&& ||
注意：逻辑只看真假

8.1、逻辑操作符例程1

/*例程8.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 0;
	if (a && b)//逻辑与，条件均满足成立
	{
		printf("hehe");
	}
	if (a || b)//逻辑或，条件满足一个则成立
	{
		printf("haha");
	}
	return 0;
}

8.2、逻辑操作符例程2

/*例程8.2*/
#include <stdio.h>
int main()
{
	//int i = 0, a = 0, b = 2, c = 3, d = 4;
	//i = a++ && ++b && d++;
	//printf("i = %d\n",i);//0
	//printf("a = %d\nb = %d\nc = %d\nd = %d\n",a,b,c,d);//1,2,3,4
	
	//int i = 0, a = 1, b = 2, c = 3, d = 4;
	//i = a++ && ++b && d++;
	//printf("i = %d\n", i);//1
	//printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);//2,3,3,5

	//int i = 0, a = 0, b = 2, c = 3, d = 4;
	//i = a++ || ++b || d++;//从前往后，满足条件后，后面未使用的条件就默认不执行了
	//printf("i = %d\n", i);//1
	//printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);//1,3,3,4

	int i = 0, a = 1, b = 2, c = 3, d = 4;
	i = a++ || ++b || d++;//从前往后，满足条件后，后面未使用的条件就默认不执行了
	printf("i = %d\n", i);//1
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);//2,2,3,4
	return 0;
}

9、条件（三目）操作符

三目操作符：exp1 ? exp2 : exp3
注意：前真后假

9.1、条件操作符例程1

/*例程9.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 0;
	//写法一：
	//if (a > 5)
	//{
	//	b = 1;
	//}
	//else
	//{
	//	b = -1;
	//}
	//写法二：
	b = a > 5 ? 1 : -1;
	//a>5表达式1
	//1表达式2
	//-1表达式3
	return 0;
}

10、逗号表达式

注意：，从左向右依次计算，但注意，输出结果时最后一个表达式结果

10.1、逗号表达式例程1

/*例程10.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	int c = 0;
	
	//逗号表达式加括号
	//int d = (c = 5,a =c + 3,b = a - 4,c+= b);
	//printf("%d\n",d);//10
	//逗号表达式不加括号,就只会执行第一个表达式结束
	int e = 0;
	e = c = 5, a = c + 3, b = a - 4, c += b;
	printf("%d\n", e);//5
	return 0;
}

11、下标引用操作符

下标引用操作符：[ ]
操作数：一个数组名 + 一个索引值
注意：下标从0开始

11.1、下标引用操作符例程1

/*例程11.1*/
#include <stdio.h>
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	printf("%d\n",arr[0]);//0
	printf("%d\n", arr[1]);//1
	printf("%d\n", arr[6]);//6
	return 0;
}

12、函数调用操作符

函数调用操作符：（ ）
操作数：函数名+（ ）

12.1、函数调用操作符例程1

/*例程12.1*/
#include <stdio.h>
int add(int x, int y)
{
	return x + y;
}
int main()
{
	int a = 10;
	int b = 20;
	int ret = add(a,b);
	printf("%d\n",ret);//30
	return 0;
}

13、结构成员访问操作符

结构成员访问操作符：. ->
. 结构体.成员名
-> 结构体指针->成员名
结构体 – 相关成员变量，不同类型描述对象
比如描述书：书名、书的编号、价格、作者等
struct关键字，创建一个新的结构体类型
结构成员访问操作符例程1

13.1、结构成员访问操作符例程1

/*例程13.1*/
#include <stdio.h>
struct Book
{
	//结构体成员/变量
	char name[20];
	char ID[20];
	int price;
};//注意：分号不可少
int main()
{
	//int num = 0;
	b结构体变量名
	结构体成员初始化
	//struct Book b = {"C语言","CBS123456",55};
	//printf("书名：%s\n",b.name);//.操作符
	//printf("ID：%s\n", b.ID);//结构体变量名.成员名
	//printf("价格：%d\n", b.price);

	int num = 0;
	//b结构体变量名
	//结构体成员初始化
	struct Book b = { "C语言", "CBS123456", 55 };
	struct Book* pb = &b;
	//printf("价格：%s\n", (*pb).name);
	//printf("价格：%s\n", (*pb).ID);
	//printf("价格：%d\n", (*pb).price);

	printf("价格：%s\n", pb->name);//->操作符
	printf("价格：%s\n", pb->ID);//结构体指针->成员名
	printf("价格：%d\n", pb->price);
	return 0;
}

14、表达式求值

注意：表达式求值注意，运算的优先级
操作符优先级如图所示：

14.1、操作符优先级例程1

/*例程14.1*/
#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	int c = a + b * 7;//符号优先级
	printf("%d\n",c);//38
	return 0;
}

15、隐式类型转换

C的整型算数运算总是至少以缺省整型类型的精度来进行的。
为了获取精度，表达式中的字符和短整型在使用前被转换为普通类型
这种转换就是整型提升
整型提升的意义：
表达式的整型运算要在CPU的相应运算器内执行，CPU内整型运算器(ALU)的操作数的字节长度，一般就是int的字节长度，同时也是CPU的通用寄存器长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要转换为CPU内整型操作数的标准长度。
通用CPU是难以直接实现两个8比特字节直接相加运算(虽然机器指令中可能有这种字节相加指令)。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。
如何整型提升？
是按照变量的数据类型的符号位来提升的

15.1、隐式类型转换（整型提升）例程1

/*例程15.1*/
#include <stdio.h>
int main()
{
	char a = 3;
	//0000 0000 0000 0000 0000 0000 0000 0011---3
	//char：0000 0011---a
	char b = 127;
	//0000 0000 0000 0000 0000 0000 0111 1111---127
	//char：0111 1111---b
	char c = a + b;
	//整型提升：
	//0000 0000 0000 0000 0000 0000 0000 0011---3---a最高位是0，那么表示正数，然后高位全补0
	//0000 0000 0000 0000 0000 0000 0111 1111---127-b最高位是0，那么表示正数，然后高位全补0
	//0000 0000 0000 0000 0000 0000 1000 0010
	//char截断：1000 0010--c
	//分析：c最高位为1，表示负数，提升后补1
	//发现a和b均是char类型，都没有达到一个int的大小
	//这里就会发生整型提升
	//char截断：1000 0010--c(-126)
	//1111 1111 1111 1111 1111 1111 1000 0010--补码
	//1111 1111 1111 1111 1111 1111 1000 0001--反码
	//1000 0000 0000 0000 0000 0000 0111 1110--补码
	printf("%d\n",c);//-126
	return 0;
}

15.2、隐式类型转换（整型提升）例程2

/*例程15.2*/
#include <stdio.h>
int main()
{
	char a = 0xb6;
	short b = 0xb600;
	int c = 0xb6000000;
	//a和b，char和short会整型提升，所以提升后会改变
	//c本身就是int型，所以不变
	if (a == 0xb6)
	{
		printf("a\n");
	}
	if (b == 0xb600)
	{
		printf("b\n");
	}
	if (c == 0xb6000000)
	{
		printf("c\n");
	}
	return 0;
}

15.3、隐式类型转换（整型提升）例程3

/*例程15.3*/
#include <stdio.h>
int main()
{
	char c = 1;
	printf("%u\n",sizeof(c));//1
	printf("%u\n",sizeof(+c));//4
	printf("%u\n",sizeof(-c));//4
	printf("%u\n",sizeof(!c));//4 gcc编译-4
	return 0;
}

16、算术转换

如果某个操作符的各个操作符属于不同的类型，那么除非其中一个操作数的转换为另外一个操作数的类型，否则操作就无法进行。
下面的层次体系称为寻常算术转换
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算，
注意：但是算术转换要合理，不然会有潜在问题报错。

16.1、算术转换例程1

/*例程16.1*/
#include <stdio.h>
int main()
{
	int a = 4;
	float f = 4.5f;//f表示为float类型的常量，没有f默认为double类型
	a + f;//int向下转换为float，再相加
	return 0;
}

17、操作符的属性

复杂表达式的求值有三个影响的因素
1.操作符优先级
2.操作符的结合性
3.是否控制求值顺序

17.1、操作符的属性例程1

/*例程17.1*/
#include <stdio.h>
int main()
{
	int a = 4;
	int b = 5;
	int c = a + b * c;//优先级决定运算顺序
	int d = a + b + c;//当优先级相同那么结合性决定运算顺序
	return 0;
}

18、问题表达式

编写代码的规范性问题，编译器问题以及逻辑问题的注意与约束
总结：如果我们写代码表达式不能通过操作符的属性确定唯一的计算路径，那么这个表达式就是存在问题的

18.1、问题表达式例程1

/*例程18.1*/
#include <stdio.h>
int main()
{
	int a, b, c, d, e, f;
	a*b + c*d + e*f;
	//这样写会影响运算步骤，不能确定唯一的执行顺序
	c + --c;//这种问题表达式，也不能确定顺序
	return 0;
}

18.2、问题表达式例程2

/*例程18.2*/
#include <stdio.h>
int main()
{
	int i = 10;
	i = i-- - --i * (i = -3)*i++ + ++i;
	printf("%d\n",i);//各编译器执行结果均不同
	//这样写会影响运算步骤，不能确定唯一的执行顺序
	//不提倡，无意义的代码
	return 0;
}

18.3、问题表达式例程3

/*例程18.3*/
#include <stdio.h>
int fun()
{
	static int count = 1;
	return ++count;
}
int main()
{
	int answer;
	//调用紊乱
	answer = fun() - fun() * fun();
	printf("%d\n", answer);//2-3*4
	//各编译器执行结果均不同
	//这样写会影响运算步骤，不能确定唯一的执行顺序
	//不提倡，无意义的代码
	return 0;
}