C【操作符】

1. 操作符分类:

C【操作符】_第1张图片

2. 算术操作符

C【操作符】_第2张图片

int main()
{
	double a = 5 % 2;//商2余1
	printf("a = %lf\n", a);
	return 0;
}

3. 移位操作符

3.1 左移操作符

左边抛弃、右边补0

C【操作符】_第3张图片

3.2 右移操作符

首先右移运算分两种:

1. 逻辑移位 左边用0填充,右边丢弃

2. 算术移位 左边用原该值的符号位填充,右边丢弃

C【操作符】_第4张图片

对于移位运算符,不要移动负数位,这个是标准未定义的。

int main()
{
	int a = 16;
	//>> -- 右移操作符
	//移动的是二进制位
	//00000000000000000000000000010000
	int c = a >> 1;//8
	int b = a >> 2;//4
	printf("%d\n", c);
	printf("%d\n", b);
	return 0;
}


int main()
{
	int a = -1;
	//
	//整数的二进制表示有:原码、反码、补码
	//存储到内存的是补码
	//10000000000000000000000000000001 - 原码
	//11111111111111111111111111111110 - 反码【原码除符号位全部取反】
	//11111111111111111111111111111111 - 补码【反码+1】
	//
	int b = a >> 1;//-1
	printf("%d\n", b);
	return 0;
}
int main()
{
	int a = 5;
	int b = a << 1;
	//00000000000000000000000000000101
	printf("%d\n", b);//10
	return 0;
}

4. 位操作符

C【操作符】_第5张图片

int main()
{
	//& - 按2进制位与【全部为1才为1,其他为0】
	/*int a = 3;
	int b = 5;
	int c = a&b;*/
	//00000000000000000000000000000011
	//00000000000000000000000000000101
	//00000000000000000000000000000001
	//printf("%d\n", c);
 

	//| - 按2进制位或【只要有1,则为1】
	/*int a = 3;
	int b = 5;
	int c = a | b;
	printf("%d\n", c);*/
	//00000000000000000000000000000011
	//00000000000000000000000000000101
	//00000000000000000000000000000111
	
	//按2进制位异或【相同为0,相异为1】
	/*int a = 3;
	int b = 5;
	int c = a ^ b;
	printf("%d\n", c);
	*/
	//00000000000000000000000000000011
	//00000000000000000000000000000101
	//00000000000000000000000000000110
	//
	return 0;
}

不能创建临时变量(第三个变量),实现两个数的交换

//不能创建临时变量(第三个变量),实现两个数的交换
int main()
{
	int a = 3;
	int b = 5;
	//int tmp = 0;//临时变量
	printf("before: a=%d b=%d\n", a, b);
	//tmp = a;
	//a = b;
	//b = tmp;

	//加减法-可能会溢出
	/*a = a + b;
	b = a - b;
	a = a - b;*/

	//异或的方法
	a = a^b;
	b = a^b;
	a = a^b;

	printf("after : a=%d b=%d\n", a, b);

	return 0;
}

练习

编写代码实现:求一个整数存储在内存中的二进制中1的个数。

参考代码:
//方法1
#include 
int main()
{
 int num  = 10;
 int count=  0;//计数
 while(num)
 {
     if(num%2 == 1)
     count++;
     num = num/2;
 }
 printf("二进制中1的个数 = %d\n", count);
 return 0;
}
//思考这样的实现方式有没有问题?
//方法2:
#include 
int main()
{
  int num = -1;
  int i = 0;
  int count = 0;//计数
 for(i=0; i<32; i++)
 {
     if( num & (1 << i) )
         count++;
 }
     printf("二进制中1的个数 = %d\n",count);
 return 0;
}
//思考还能不能更加优化,这里必须循环32次的。
//方法3:
#include 
int main()
{
     int num = -1;
     int i = 0;
     int count = 0;//计数
 while(num)
 {
     count++;
     num = num&(num-1);
 }
 printf("二进制中1的个数 = %d\n",count);
 return 0;
}
//这种方式是不是很好?达到了优化的效果,但是难以想到。

5. 赋值操作符

int weight = 120;//体重
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值。
赋值操作符可以连续使用,比如:
int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//连续赋值
这样的代码感觉怎么样?
那同样的语义,你看看:
x = y+1;
a = x;
这样的写法是不是更加清晰爽朗而且易于调试。

复合赋值符

C【操作符】_第6张图片

int main()
{
	//a = a + 2;
	//a += 2;//复合赋值符
	//
	//a = a >> 1;
	//a >>= 1;

	//a = a & 1;
	//a &= 1;

	return 0;
}

6. 单目操作符

6.1 单目操作符介绍

C【操作符】_第7张图片

int main()
{
	int a = 0;
	if (a)
	{
		printf("呵呵\n");
	}
	if (!a)
	{
		printf("呵呵\n");
	}

	return 0;
}
int main()
{
	int a = 10;
	int* p = &a;//取地址操作符
	//*p:是存放a的内容 p:是存放a的地址
	*p = 20;//解引用操作符
	return 0;
}
int main()
{
	int a = 10;
	//printf("%d\n", ++a);//前置++,先++,后使用
	printf("%d\n", a++);//后置++,先使用,再++
	
	return 0;
}

 

//++和--运算符
//前置++和--
#include 
int main()
{
    int a = 10;
    int x = ++a;
    //先对a进行自增,然后对使用a,也就是表达式的值是a自增之后的值。x为11。
    int y = --a;
    //先对a进行自减,然后对使用a,也就是表达式的值是a自减之后的值。y为10;
    return 0;
}
//后置++和--
#include 
int main()
{
    int a = 10;
    int x = a++;
    //先对a先使用,再增加,这样x的值是10;之后a变成11;
    int y = a--;
    //先对a先使用,再自减,这样y的值是11;之后a变成10;
    return 0;
}
int main()
{
	int a = (int)3.14;//int a = int(3.14);//err

	return 0;
}

难点:&和|

int main()
{
	int a = 11;
	a = a | (1 << 2);
	printf("%d\n", a);//15
	//要求想把第三位0变成1
	//0000000000000000000000000000001011-->11
	//0000000000000000000000000000000100-->1<<2【4】两者进行按位或,只要有1则为
	//0000000000000000000000000000001111
	//
	a = a & (~(1 << 2));
	printf("%d\n", a);//11
	//要求想把第三位1变成0
	//0000000000000000000000000000001111--->15
	// 0000000000000000000000000000000100<-【向右移动2位】---0000000000000000000000000000000001
	//             ||并且按位取反
	//             
	//1111111111111111111111111111111011--->~(1<<2)
	//0000000000000000000000000000001011
	//
	//
	//int a = 0;
	~ 按(2进制)位取反
	00000000000000000000000000000000
	11111111111111111111111111111111 - 补码=反码+1
	11111111111111111111111111111110 - 反码
	10000000000000000000000000000001 - 原码=补码-1+除符号位外全部取反
	//printf("%d\n", ~a);//-1

	return 0;
}

int a = 11;
a = a | (1 << 2);
printf("%d\n", a);//15

C【操作符】_第8张图片

a = a & (~(1 << 2));
printf("%d\n", a);//11

C【操作符】_第9张图片

7 sizeof 和 数组

sizeof

int main()
{
	int a = 10;
	char c = 'r';
	char* p = &c;
	int arr[10] = { 0 };
	//sizeof 计算的变量所占内存空间的大小,单位是字节
	printf("%d\n", sizeof a);//4
	printf("%d\n", sizeof(int));//4

	printf("%d\n", sizeof(c));//1
	printf("%d\n", sizeof(char));//1

	//指针大小4或者8
	printf("%d\n", sizeof(p));//4
	printf("%d\n", sizeof(char*));//4

	printf("%d\n", sizeof(arr));//40
	printf("%d\n", sizeof(int [10]));//40

	return 0;
}

注意点:sizeof中的算术不进行运算

int main()
{
	short s = 0;
	int a = 10;
	//siezof:表达式中不参与运算
	printf("%d\n", sizeof(s = a + 5));//2
	printf("%d\n", s);//0

	return 0;
}


#include 
void test1(int arr[])//首元素地址
{
	printf("%d\n", sizeof(arr));//(2)  4【32平台】
}
void test2(char ch[])//首元素地址
{
	printf("%d\n", sizeof(ch));//(4)  4【32平台】
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));//(1)
	printf("%d\n", sizeof(ch));//(3)
	test1(arr);
	test2(ch);
	return 0;
}

C【操作符】_第10张图片

8. 关系操作符

C【操作符】_第11张图片

9. 逻辑操作符

9.1 逻辑与&&

int main()
{
	int a = 0;
	int b = 5;
	int c = a && b;
	printf("%d\n", c);//true
	return 0;
}

9.2 逻辑或|

int main()
{
	int a = 0;
	int b = 5;
	int c = a || b;
	printf("%d\n", c);//true
	return 0;
}

9.3 难点

#include 
int main()
{
	int i = 0, a = 1, b = 2, c = 3, d = 4;
	i = a++||++b||d++;

	printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
	//
	return 0;
}

C【操作符】_第12张图片

10 . 条件操作符

exp1 ? exp2 : exp
int main()
{
	int a = 10;
	int b = 20;
	int max = 0;

	if (a > b)
		max = a;
	else
		max = b;
	//如果a>b,则结果取a,否则取b
	max = (a > b ? a : b);
	
	//if (a > 5)
	//	b = 3;
	//else
	//	b = -3;

	//b = (a > 5 ? 3 : -3);

	return 0;
}

11 . 逗号表达式

C【操作符】_第13张图片

C【操作符】_第14张图片

C【操作符】_第15张图片

12 . 下标引用、函数调用和结构成员

1. [ ] 下标引用操作符

操作数:一个数组名 + 一个索引值

int main()
{
	int a[10] = { 0 };
	a[4] = 10;
	1 + 2;
	return 0;
}

2. ( ) 函数调用操作符

接受一个或者多个操作数:第一个操作数是函数名,剩余的操作数就是传递给函数的参数

C【操作符】_第16张图片

int get_max(int x, int y)
{
	return x > y ? x : y;
}

int main()
{
	int a = 10;
	int b = 20;
	//调用函数的时候的()就是函数调用操作符
	int max = get_max(a, b);
	printf("max = %d\n", max);
	return 0;
}

3. 访问一个结构的成员

. 结构体.成员名

-> 结构体指针->成员名

学生
int float

创建一个结构体类型-struct Stu
struct Stu
{
	//成员变量
	char name[20];
	int age;
	char id[20];
};

int main()
{
	int a = 10;
	//使用struct Stu这个类型创建了一个学生对象s1,并初始化
	struct Stu s1 = {"张三", 20, "2019010305"};
	struct Stu* ps = &s1;

	printf("%s\n", ps->name);
	printf("%d\n", ps->age);
	//结构体指针->成员名

	/*printf("%s\n", (*ps).name);
	printf("%d\n", (*ps).age);*/

	/*printf("%s\n", s1.name);
	printf("%d\n", s1.age);
	printf("%s\n", s1.id);*/
	//结构体变量.成员名
	return 0;
}

C【操作符】_第17张图片

13 . 表达式求值

13.1 隐式类型转换【难点--小类型转换大类型】

C【操作符】_第18张图片

//实例1
char a,b,c;
...
a = b + c;

b和c的值被提升为普通整型,然后再执行加法运算

如何进行整体提升呢?

整形提升是按照变量的数据类型的符号位来提升的

//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位:
1111111
因为 char 为有符号的 char
所以整形提升的时候,高位补充符号位,即为1
提升之后的结果是:
11111111111111111111111111111111
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位:
00000001
因为 char 为有符号的 char
所以整形提升的时候,高位补充符号位,即为0
提升之后的结果是:
00000000000000000000000000000001
//无符号整形提升,高位补0

例子

int main()
{
	char a = 3;
	//00000000000000000000000000000011-->3
	//00000011 - a
	//
	char b = 127;
	//‭00000000000000000000000001111111
	//‬01111111 - b

	//a和b如何相加
	//00000000000000000000000000000011
	//00000000000000000000000001111111
	//00000000000000000000000010000010  -->a+b
	//
	char c = a + b;
	//10000010-c
	//11111111111111111111111110000010 - 补码
	//11111111111111111111111110000001 - 反码
	//10000000000000000000000001111110- 原码
	//-126
	printf("%d\n", c);

	return 0;
}

C【操作符】_第19张图片

int main()
{
	char a = 0xb6;//0xb6:十六进制:b:1011 6:0110
	short b = 0xb600;
	int c = 0xb6000000;
	if (a == 0xb6)//类型转换
		printf("a");
	if (b == 0xb600)//类型转换
		printf("b");
	if (c == 0xb6000000)
		printf("c");//结果输出c
	return 0;
}

C【操作符】_第20张图片

int main()
{
	char c = 1;
	printf("%u\n", sizeof(c));//1
	//[+c]表示进行计算
	printf("%u\n", sizeof(+c));//4
	printf("%u\n", sizeof(!c));//1
	return 0;
}

13.2 算术转换【大类型转换小类型】

如果某个操作符的各个操作数属于不同的类型,那么除非其中一个操作数的转换为另一个操作数的类 型,否则操作就无法进行。下面的层次体系称为寻常算术转换。

C【操作符】_第21张图片

如果某个操作数的类型在上面这个列表中排名较低,那么首先要转换为另外一个操作数的类型后执行运 算。

警告: 但是算术转换要合理,要不然会有一些潜在的问题

float f = 3.14;
int num = f;//隐式转换,会有精度丢失

13.3 操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级 2. 操作符的结合性 3. 是否控制求值顺序

C【操作符】_第22张图片

C【操作符】_第23张图片

一些问题表达式

//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f

注释:代码1在计算的时候,由于*比+的优先级高,只能保证,*的计算是比+早,但是优先级并不 能决定第三个*比第一个+早执行。

2

//表达式2
c + --c;

3

//代码3-非法表达式
int main()
{
 int i = 10;
 i = i-- - --i * ( i = -3 ) * i++ + ++i;
 printf("i = %d\n", i);
 return 0;
}

C【操作符】_第24张图片

4

//代码4
int fun()
{
     static int count = 1;
     return ++count;
}
int main()
{
     int answer;
     answer = fun() - fun() * fun();
     printf( "%d\n", answer);//输出多少?
     return 0;
}

C【操作符】_第25张图片

C【操作符】_第26张图片

5

//代码5
#include 
int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0;
}

C【操作符】_第27张图片

C【操作符】_第28张图片

你可能感兴趣的:(c语言,开发语言)