1. 操作符分类：
2. 算术操作符
int main()
{
double a = 5 % 2;//商2余1
printf("a = %lf\n", a);
return 0;
}3. 移位操作符
3.1 左移操作符
左边抛弃、右边补0
3.2 右移操作符
首先右移运算分两种：
1. 逻辑移位 左边用0填充，右边丢弃
2. 算术移位 左边用原该值的符号位填充，右边丢弃
对于移位运算符，不要移动负数位，这个是标准未定义的。
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. 位操作符
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;
}不能创建临时变量（第三个变量），实现两个数的交换
^:相反为1，相同为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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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;
这样的写法是不是更加清晰爽朗而且易于调试。复合赋值符
int main()
{
//a = a + 2;
//a += 2;//复合赋值符
//
//a = a >> 1;
//a >>= 1;
//a = a & 1;
//a &= 1;
return 0;
}6. 单目操作符
6.1 单目操作符介绍
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 <stdio.h>
int main()
{
int a = 10;
int x = ++a;
//先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
int y = --a;
//先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
return 0;
}
//后置++和--
#include <stdio.h>
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;
}难点:&和|
注意点： & 1:一定可以得到最后一位
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
a = a & (~(1 << 2));
printf("%d\n", a);//11
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 <stdio.h>
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;
}
8. 关系操作符
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 <stdio.h>
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;
}
10 . 条件操作符
exp1 ? exp2 : expint 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 . 逗号表达式
12 . 下标引用、函数调用和结构成员
1. [ ] 下标引用操作符
操作数：一个数组名 + 一个索引值
int main()
{
int a[10] = { 0 };
a[4] = 10;
1 + 2;
return 0;
}
2. ( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
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;
}
13 . 表达式求值
13.1 隐式类型转换【难点--小类型转换大类型】
//实例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;
}
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;
}
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 算术转换【大类型转换小类型】
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类 型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运 算。
警告： 但是算术转换要合理，要不然会有一些潜在的问题
float f = 3.14;
int num = f;//隐式转换，会有精度丢失13.3 操作符的属性
复杂表达式的求值有三个影响的因素。
1. 操作符的优先级 2. 操作符的结合性 3. 是否控制求值顺序
一些问题表达式
1
//表达式的求值部分由操作符的优先级决定。
//表达式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;
}
4
//代码4
int fun()
{
static int count = 1;
return ++count;
}
int main()
{
int answer;
answer = fun() - fun() * fun();
printf( "%d\n", answer);//输出多少？
return 0;
}
5
//代码5
#include <stdio.h>
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf("%d\n", ret);
printf("%d\n", i);
return 0;
}
14.作业
注意点1：
#include <stdio.h>
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
short *p = (short*)arr;
int i = 0;
for (i = 0; i<4; i++)
{
*(p + i) = 0;
}
for (i = 0; i<5; i++)
{
printf("%d ", arr[i]);//0034
}
return 0;
}注意点2：
#include <stdio.h>
int main()
{
int a = 0x11223344;//实际上是倒着放-->地址上是：44332211
char *pc = (char*)&a;
*pc = 0;//实际上是将首元素位置上的值修改为:00
printf("%x\n", a);//11223300
return 0;
}注意点3：
#include <stdio.h>
int i;//全局变量-不初始化-默认是0
int main()
{
i--;
//-1
//10000000000000000000000000000001-->-1原码
//11111111111111111111111111111110--->-1反码
//11111111111111111111111111111111--->-1补码
// 👇
// 1111111111111111111111111111111【无穷大】
if (i > sizeof(i))//sizeof()-计算变量/类型所占内存的大小 >=0 返回的值是：无符号数
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}注意点4：
#include <stdio.h>
int main()
{
int a, b, c;
a = 5;
c = ++a;//c=6 a=6
// 7 8 6 7
b = ++c, c++, ++a, a++;//c=8 a=8 b=7
b += a++ + c;//b=b+(a++)+c=7+8+8=23
printf("a = %d b = %d c = %d\n:", a, b, c);//9 23 8
return 0;
}注意点5：写一个函数求a的二进制（补码）表示中有几个1【按位与】
int count_bit_one(int n)
{
int count = 0;
while (n)
{
if (n % 2 == 1)//存在问题：无法计算负数
{
count++;
}
n = n / 2;//去除为1的数值
}
return count;
}//改进1
//使用接收进来的是无符号数;unsigned,则忽略符号
int count_bit_one(unsigned int n)
{
int count = 0;
while (n)
{
if (n % 2 == 1)//存在问题：无法计算负数
{
count++;
}
n = n / 2;//去除为1的数值
}
return count;
}
//改进2
int count_bit_one(int n)
{
int count = 0;
int i = 0;
for (i = 0; i < 32; i++)
{
//(n >> i)：将输入的值向右移动1位
if (((n >> i) & 1) == 1)//全为1，则1
{
count++;
}
}
return count;
}最经典解法
//改进3
int count_bit_one(int n)
{
int count = 0;
while (n)
{
n = n & (n - 1);
count++;
}
return count;
}
//n = n&(n-1)-->每一次都会去除最右边的1消失
//n
//13
//1101 n
//1100 n-1
// n = n&(n-1)
// 👇
//1100 n
//1011 n-1
//1000 n
//0111 n-1
//0000 n注意点6：求二进制中不同的个数
int get_diff_bit(int m, int n)
{
//为1表示，有一个1和一个0
int tmp = m^n;//异或【相同为0，相反为1】
int count = 0;
//return count_bit_one(tmp);
while (tmp)
{
tmp = tmp&(tmp - 1);
count++;
}
return count;
}
int main()
{
int m = 0;
int n = 0;
scanf("%d%d", &m, &n);
int count = get_diff_bit(m, n);
printf("count = %d\n", count);
return 0;
}第37分钟左右
注意点7：打印二进制的奇数位和偶数位
第42分钟左右
void print(int m)
{
int i = 0;
printf("奇数位：\n");
//将二进制向右移动，每一次移动2位，可以将其奇数位放在第一位，与1进行比较
for (i = 30; i >= 0; i -= 2)
{
//& 按位与操作，按二进制位进行"与"运算。运算规则：（有 0 则为 0）
printf("%d ", (m >> i) & 1);// 注意点【任何数值与 &1 都可以得到最后一位】
}
printf("\n");
printf("偶数位：\n");
for (i = 31; i >= 1; i -= 2)
{
printf("%d ", (m >> i) & 1);
}
printf("\n");
}
int main()
{
int m = 0;
scanf("%d", &m);
print(m);
return 0;
}注意点8：交换两个变量，不使用第三位数【重点】
//不能创建临时变量（第三个变量），实现两个数的交换
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;
}注意点9：打印arr数组的内容，不使用数组下标
//打印arr数组的内容，不使用数组下标
void print(int *p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int sz = sizeof(arr) / sizeof(arr[0]);
print(arr, sz);
return 0;
}
扫一扫
402
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
