C语言学习笔记

​「这是我参与2022首次更文挑战的第9天，活动详情查看：2022首次更文挑战」。

例：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(c));//1
	printf("%d\n", sizeof(p));//4
	printf("%d\n", sizeof(arr));//40
	return 0;
}

int main()
{
	short s = 0;
	int a = 10;
	printf("%d\n", sizeof(s = a + 5));//short只能存两个字节
	printf("%d\n", s);//sizeof括号内的表达式不参与运算
    return 0;
}

例 ：~

int main()
{
	int a = 0;
	//~按二进制位取反
	//000000000000000000000000
	//111111111111111111111111 -- 补码
	//111111111111111111111110 -- 反码
	//100000000000000000000001 -- 原码
	printf("%d\n", ~a);
	return 0;
}

关系操作符

运算符	名称	示例	功能	缩写
<	小于	a	a小于b时返回真；否则返回假	LT
<=	[小于等于	a	a小于等于b时返回真；否则返回假	LE
大于		a>b	a大于b时返回真；否则返回假	GT
>=	[大于等于]	a>=b	a大于等于b时返回真；否则返回假	GE
==	等于	a==b	a等于b时返回真；否则返回假	EQ
!=	不等于	a!=b	a不等于b时返回真；否则返回假	NE

逻辑操作符

&& 逻辑与：两个表达式必须都为 true(非0)，整个表达式才为 true

||    逻辑或：必须有一个或两个表达式为 true，才能使整个表达式为 true。

！  逻辑非：使一个表达式从 true 变成了 false，或者从 false 变成了 true

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 d=%d\n", a, b, c, d);
	//a=1,b=2,c=3,d=4
	return 0;
}

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\n d=%d\n", a, b, c, d);
	//a=2,b=3,c=3,d=5
	return 0;
}

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\n d=%d\n", a, b, c, d);
	//a=2,b=2,c=3,d=4
	return 0;
}

或者关系：左边为真，右边就不用计算

并且关系：左边为假，右边就不用计算了

注：&& (逻辑与) 优先级高于||（逻辑或）

条件操作符

exp1? exp2 ：exp3

(若exp1为真，则exp2要计算，否则exp3要计算)

int main()
{
	int a = 0;
	int b = 0;
	if (a > 5)
		b = 3;
	else
		b = -3;


	b = (a > 5 ? 3 : -3);
	return 0;
}

int main()
{
	int a = 10;
	int b = 20;
	int max = 0;
	if (a > b)
		max = a;
	else
		max = b;

	max = (a > b ? a : b);

	return 0;
}

逗号表达式

， 优先级别最低，它将两个及其以上的式子联接起来，从左往右逐个计算表达式，整个表达式的值为最后一个表达式的值。

下标引用，函数调用和结构成员

1.[  ]下标引用操作符

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

2.（）

调用函数时的（）就是函数调用操作符

3.访问一个结构的成员

. 操作符，用来访问结构的成员

struct Stu
{
	char name[20];
	int age;
	char id[20];
};

int main()
{
	int a = 10;
	//使用struct Stu这个类型创建了一个学生对象s1，并初始化
	struct Stu s1 = { "张三",20, "202101029"};
	printf("%s\n", s1.name);
	printf("%d\n", s1.age);
	printf("%s\n", s1.id);
	return 0;
}

 —>

struct Stu
{
	char name[20];
	int age;
	char id[20];
};

int main()
{
	int a = 10;
	//使用struct Stu这个类型创建了一个学生对象s1，并初始化
	struct Stu s1 = { "张三",20, "202101029"};
	struct Stu* ps = &s1;
	printf("%s\n", ps->name);
	printf("%d\n", ps->age);
	//结构体指针—>成员名
	return 0;
}

表达式求值

隐式类型的转换

C的整型算术运算总是至少已缺省整型类型的精度来进行。为了获得这种精度，表达式中的字符和短整型操作数在使用前辈转换为普通整型，这种转换被称为整型提升。整型算术运算要在计算机cpu内的整型运算器中进行。而整型运算器的操作数字节长度是整形int的字节长度。所以在整型计算时，要将所有数据提升至整形int的字节长度32位，即4字节。但即使是两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整形操作数的标准长度。

​