sizeof 使用
int main()
{
short s = 0;
int a = 10;
printf("%d\n", sizeof(s = a + 5));//2
printf("%d\n", s);//0
printf("%d\n", sizeof(int));//4
printf("%d\n", sizeof(short));//2
printf("%d\n", sizeof(long));//4
printf("%d\n", sizeof(char));//1
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof a ); 可以算出
printf("%d\n", sizeof int );不可以int short char 等括号不能去掉
return 0;
}
~ 符号按位取反
int main()
{
int a = 0;
//~按二进制位取反
//00000000000000000000000000000000 0
//11111111111111111111111111111111 按位取反
//11111111111111111111111111111110 反码
//10000000000000000000000000000001 原码 -1
printf("%d\n", ~a);//结果应该是-1
return 0;
}
~ & << >> 操作符综合使用
~按位取反
&按位与
<<左移操作符
// >> 右移操作符
int main()
{
int a = 11;
//0000 0000 0000 0000 0000 0000 0000 1011
//0000 0000 0000 0000 0000 0000 0000 0100 (1<<2)
//0000 0000 0000 0000 0000 0000 0000 1111
a = a | (1 << 2);
printf("%d\n", a);//15
a = a&(~(1 << 2));
/*
0000 0000 0000 0000 0000 0000 0000 0001
0000 0000 0000 0000 0000 0000 0000 0100
1111 1111 1111 1111 1111 1111 1111 1011
0000 0000 0000 0000 0000 0000 0000 1111
0000 0000 0000 0000 0000 0000 0000 1011
*/
printf("%d\n", a);//11
return 0;
}
前置++ 和后置++
int main()
{
int a = 10;
printf("%d\n", ++a);//11 //前置++ 先++ 后使用
printf("%d\n", a++); //11//后置++ 先使用 后++
return 0;
}
传参数组首元素地址 sizeof计算大小
#include<stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//这里打印的是指针变量，所以答案32位平台是4 64位平台是8
}
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面试题 逻辑操作符
```c
360的笔试题
#include<stdio.h>
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);
// 1 2 3 4
//首先 a++ 先使用后++ 所以a先是0 然后后边是逻辑与只要有一个为0 其它都是0 所以答案1，2，3，4
return 0;
}
int main()
{
int i = 1, 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);
因为逻辑与是必须三个都是真的才是真的，所以会执行完
这里的答案就是2335
}
int main()
{
int i = 1, 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++执行完了是真的所以后面都不执行了
//这里的答案就是2334
}
逗号表达式
#include<stdio.h>
int main()
{
int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式
printf("c = %d\n", c);//结果是13
//逗号表达式，结果是逗号表达式中最后一个表达式的结果，a是12 b是13所以结果是13
return 0;
}
逗号表达式的应用场景
int main()
{
a = get_val();
count_val(a);
while (a > 0)
{
//业务处理
a = get_val();
count_val(a);
// }
//如果使用逗号表达式
while (a = get_val(), count_val(a), a > 0)
{
//业务处理
}
return 0;
}
[]下标引用操作符
()函数调用操作符
#include<stdio.h>
/*[]下标引用操作符*/
操作数：一个数组名+一个索引值
int main()
{
int arr[10];//创建数组
arr[9] = 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
struct Stu
{
//成员变量
char name[20];
int age;
char id[20];
};
int main()
{
//使用struct Stu这个类型创建了一个学生对象s1，并初始化
struct Stu s1 = {
"张三" , 20 , "2s20202020"};
printf("%s\n", s1.name);
printf("%d\n", s1.age);
printf("%s\n", s1.id);
//结构体变量 . 成员名
//这里通过指针来访问结构体成员
struct Stu* ps = &s1;//这里的ps就是指针变量，它的类型是struct Stu*
printf("%s\n", (*ps).name);
printf("%d\n", (*ps).age);
printf("%s\n", (*ps).id);
//下面是更简单的通过指针来访问结构体成员
printf("%s\n", ps->name);//ps->name意思是指针指向的那个对象s1的成员name
printf("%d\n", ps->age); //ps->age意思是指针指向的那个对象s1的成员age
printf("%s\n", ps->id); //ps->id 意思是指针指向的那个对象s1的成员id
//->结构体指针操作符
//结构体指针 -> 成员名
return 0;
}
表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型
隐式类型转换
c的整型算术运算总是至少以缺省整型类型的精度来进行的
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升
整型提升的意义
如何进行整型提升呢
小于整形的
整型提升是按照变量的数据类型的符号位来提升的
负数的整型提升
-1 11111111111111111111111111111111char8位只拿走后面8位
char c1 = -1; char1个字节 8个比特位
变量c1的二进制位（补码）中只有8个比特位
-1的补码是 11111111
因为char为有符号的char
所以整型提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
正数的整型提升
char c2 = 1; 00000000000000000000000000000001
变量c2的二进制位（补码）中只有8个比特位
所以只拿走后8位 00000001
因为char为有符号的char
所以整型提升的时候，高位补充符号位，即为0
提升之后的结果是
高位 低位
00000000000000000000000000000001
无符号整型提升，高位补0
实例
#include<stdio.h>
int main()
{
char a = 3;
/*
a二进制本来是 00000000000000000000000000000011
但因为char1个字节8个比特位所以只拿后8位
a - 00000011
*/
char b = 127;
/*
127二进制本来是00000000000000000000000001111111
但因为char1个字节8个比特位所以只拿后8位
b - 01111111
*/
/*
a和b如何相加 a和b都是char没有达到整型大小为了提升计算精度,进行整型提升
a进行整型提升 00000000000000000000000000000011
b进行整型提升 00000000000000000000000001111111
相加 的结果 00000000000000000000000010000010
*/
char c = a + b;
c只有8个比特位 所以只能拿后面8个 10000010
/*
c - 10000010 要打印整型，所以进行整型提升
11111111111111111111111110000010 - 补码
11111111111111111111111110000001 - 反码
10000000000000000000000001111110 - 原码
结果就是 -126
*/
printf("%d\n", c);
return 0;
}
整型提升的例题
int main()
{
char a = 0xb6;
// 这个发生了整型提升 10110110 提升之后11111111111111111111111110110110
//所以提升之后不会跟以前一样
short b = 0xb600;
// 这个也发生了整型提升 ，也不会根以前一样
int c = 0xb6000000; //没有发生整型提升，所以结果就是c
if (a == 0xb6)
printf("a");
if (b == 0xb600)
printf("b");
if (c == 0xb6000000)
printf("c");
return 0;
}
int main()
{
char c = 1;
printf("%u\n", sizeof(c));//1
printf("%u\n", sizeof(+c));//4 这里应该会发生整型提升int 所以结果是4
printf("%u\n", sizeof(!c));//1
return 0;
}
算术转换
凡是>= 整形的
long double
double
float
unsigned long int
long int
unsigned int
int 由上到下，由大到小
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型
后执行运算
警告：但是算术转换要合理，要不然会有一些潜在的问题
小的跟大的进行运算，先把小的转换为大的 是比较合理的运算
一些问题表达式
