2021-3-18操作符(下)

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
//int main()
//{
//	int a = 0;
//	char b = 'w';
//	int arr[10] = { 0 };
//	printf("%d\n", sizeof(a));
//	printf("%d\n", sizeof(int));
//	printf("%d\n", sizeof(b));
//	printf("%d\n", sizeof(char));
//	printf("%d\n", sizeof(arr));
//	return 0;
//}
//int main()
//{
//	short s = 0;
//	int a = 10;
//	printf("%d\n", sizeof(s = a + 5));//2
//	printf("%d\n", s);//0
//	return 0;
//}
//int main()
//{
//	//int a = 0;
//	~ 按(二进制）位取反
//	00000000000000000000000000000000
//	11111111111111111111111111111111-补码
//	10000000000000000000000000000001-原码
//	//printf("%d\n", ~a);
//	int a = 11;
//	a = a | (1 << 2);
//	printf("%d\n", a);
//	return 0;
//}

//强制类型转换
//int main()
//{
//	int a = (int)3.14;
//	printf("%d\n", a);
//	return 0;
//}
//void test1(int arr[])
//{
//	printf("%d\n", sizeof(arr));
//}
//void test2(char ch[])
//{
//	printf("%d\n", sizeof(ch));
//}
//int main()
//{
//	int arr[10] = { 0 };
//	char ch[10] = { 0 };
//	printf("%d\n", sizeof(arr));//40
//	printf("%d\n", sizeof(ch));//10
//	test1(arr);//4
//	test2(ch);//4
//	return 0;
//}

//360笔试题!
//逻辑与操作符的特点是只要左边为假，右边则不用计算
//int main()
//{
	//int i = 0, a = 0, b = 2, c = 3, d = 4;
	//i = a++ && ++b && d++;
	//printf("a=%d\n b=%d\n c=%d\n c=%d\n d=%d\n", a, b, c, d);//1 2 3 4

	//如果将a改为1
	//int i = 0, a = 1, b = 2, c = 3, d = 4;
	//i = a++ && ++b && d++;
	//printf("a=%d\n b=%d\n c=%d\n c=%d\n d=%d\n", a, b, c, d);//2 3 3 5

	//如果将逻辑与改为逻辑或，则结果为？
	//逻辑或只要最左边为真，则真个表达式为真，后面的部分不用计算
//	int i = 0, a = 1, b = 2, c = 3, d = 4;
//	i = a++ || ++b || d++;
//	printf("a=%d\n b=%d\n c=%d\n c=%d\n d=%d\n", a, b, c, d);//2 2 3 4
//	return 0;
//}

//条件操作符(三目操作符)
//int main()
//{
//	int a = 0;
//	int b = 0;
//	/*if (a > 5)
//		b = 3;
//	else
//		b = -3;*/
//	//用三木操作符描述这段逻辑
//	b = (a > 5 ? 3 : -3);
//	printf("%d\n", b);
//	return 0;
//}

//逗号表达式，就是用逗号隔开的多个表达式，逗号表达式从左到右依次执行，整个表达式的结果就是最后应一个表达式的结果
//int a = 1;
//int b = 2;
//int c = (a > b, a = b + 10, a, b = a + 1);
c为多少? 13

//下标引用操作符，函数调用操作符和结构成员
//int main()
//{
//	int a[10] = { 0 };
//	a[4] = 10;
//	return 0;
//}
//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;
//}

//结构体
//描述一个学生
//struct Stu//创建一个结构体类型
//{
//	char name [20];
//	int age;
//	char id[20];
//};
int main()
//{
//	int a = 10;
//	//使用struct Stu这个类型创建了一个学生对象并初始化
//	struct Stu s1 = { "张三",20,"20392209090" };
//	struct Stu* ps = &s1;
//	printf("%s\n", ps->name);
//	printf("%s\n", ps->age);
//	//->结构体指针操作符
//	//结构体指针->成员名
//	//printf("%s\n", s1.name);
//	//printf("%s\n", s1.id);
//	//printf("%s\n", s1.age);
//	结构体变量.成员名
//	return 0;
//}

//隐式类型转换
//c的整型算数运算总是至少以缺省型类型的精度来进行的
//为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升
//int main()
//{
//	char a = 3;
//	//00000000000000000000000000000011
//	//由于char类型只能存放一个字节故发生截断变为
//	//00000011 -a
//	char b = 127;
//	//00000000000000000000000001111111变为
//	//01111111 -b
//	//a和b如何相加？
//	//00000000000000000000000000000011-a
//	//00000000000000000000000001111111-b
//	//00000000000000000000000010000010-c
//	char c = a + b;
//	//10000010-c
//	printf("%d\n", c);//-126
//	return 0;
//}

//算术转换,先把小的类型转换成大的类型进行运算

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