1. 操作符的分类
• 算术操作符: + 、- 、* 、/ 、%
• 移位操作符: << >> (用于二进制)
• 位操作符: & | ^ (用于二进制)
• 赋值操作符: = 、+= 、 -= 、 *= 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=
• 单⽬操作符: !、++、--、&、*、+、-、~ 、sizeof、(类型)
• 关系操作符: > 、>= 、< 、<= 、 == 、 !=
• 逻辑操作符: && 、||
• 条件操作符: ? :
• 逗号表达式: ,
• 下标引⽤: []
• 函数调⽤: ()
• 结构成员访问: . 、->
2. ⼆进制和进制转换
其实我们经常能听到 2进制、8进制、10进制、16进制 这样的讲法,那是什么意思呢?其实2进制、8进制、10进制、16进制是数值的不同表⽰形式⽽已。
⽐如:数值15的各种进制的表⽰形式:
15的2进制:1111
15的8进制:17
15的10进制:15
15的16进制:F
//16进制的数值之前写:0x
//8进制的数值之前写:0
⾸先我们还是得从10进制讲起,其实10进制是我们⽣活中经常使⽤的,我们已经形成了很多尝试:
• 10进制中满10进1
• 10进制的数字每⼀位都是0~9的数字组成
其实⼆进制也是⼀样的
• 2进制中满2进1
• 2进制的数字每⼀位都是0~1的数字组成
那么 1101 就是⼆进制的数字了
2.1 2进制转10进制
其实10进制的123表⽰的值是⼀百⼆⼗三,为什么是这个值呢?其实10进制的每⼀位是有权重的,10
进制的数字从右向左是个位、⼗位、百位....,分别每⼀位的权重是 10^0 , 10^1 , 10^2,10^3 ...
百位 | 十位 | 个位 | ||
十进制的位 | 1 | 2 | 3 | |
权重 | 10^2 | 10^1 | 10^0 | |
权重值 | 100 | 10 | 1 | |
求值 | 1*100+ | 2*10+ | 3*1= | 123 |
2进制和10进制是类似的,只不过2进制的每⼀位的权重,从右向左是: 2^0 , 2^1 , 2^2 ...
如果是2进制的1101,该怎么理解呢?
二进制的位 | 1 | 1 | 0 | 1 | |
权重 | 2^3 | 2^2 | 2^1 | 2^0 | |
权重值 | 8 | 4 | 2 | 1 | |
求职 | 1*8+ | 1*4+ | 0*2+ | 1*1= | 13 |
同理,八进制与十六进制转为二进制都是同样的操作
2.1.1十进制转二进制
例如十进制的125转位二进制的值为:1111101
由下往上依次所得的余数就是十进制转换成二进制的值:1111101
2.2二进制转八进制和十六进制
2.2.1二进制转八进制
8进制的数字每⼀位是0~7的,0~7的数字,各⾃写成2进制,最多有3个2进制位就⾜够了,⽐如7的⼆进制是111,所以在2进制转8进制数的时候,从2进制序列中右边低位开始向左每3个2进制位会换算⼀个8进制位,剩余不够3个2进制位的直接换算。
如:2进制的 01101011,换成8进制:0153,0开头的数字,会被当做8进制。
19会是八进制的数吗?很肯定,当然不是八进制由数字0~7组成,不可能会有超过7的数字。
2.2.2二进制转十六进制
16进制的数字每⼀位是0~9,a ~f 的,0~9,a ~f的数字,各⾃写成2进制,最多有4个2进制位就⾜够了,
⽐如 f 的⼆进制是1111,所以在2进制转16进制数的时候,从2进制序列中右边低位开始向左每4个2进制位会换算⼀个16进制位,剩余不够4个⼆进制位的直接换算。
如:2进制的01101011,换成16进制:0x6b,16进制表⽰的时候前面加0x
#include <stdio.h>
int main()
{
printf("%d\n", 153);
printf("%d\n", 0153);
printf("%d\n", 0x153);
return 0;
}
3. 原码、反码、补码
整数的2进制表⽰⽅法有三种,即原码、反码和补码
有符号整数的三种表⽰⽅法均有符号位和数值位两部分,2进制序列中,最⾼位的1位是被当做符号位,剩余的都是数值位。
符号位都是⽤0表⽰“正”,⽤1表⽰“负”。
正整数的原、反、补码都相同。
负整数的三种表⽰⽅法各不相同。
原码:直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
反码:将原码的符号位不变,其他位依次按位取反就可以得到反码。
补码:反码+1就得到补码。(取反加1)
补码得到原码也是可以使⽤:取反,+1的操作。
//int main()
//{
// //a是整型类型的,a是占4个字节的(32bit)位的
// int a = 10;
// //00000000000000000000000000001010 - 原码
// //00000000000000000000000000001010 - 反码
// //00000000000000000000000000001010 - 补码
//
// int b = -10;
// //10000000000000000000000000001010 - 原码
// //11111111111111111111111111110101 - 反码
// //11111111111111111111111111110110 - 补码(取反加1)
//
// //11111111111111111111111111110110 - 补码
// //10000000000000000000000000001001 - 反码
// //10000000000000000000000000001010 - 原码(取反加1)
//
// signed int c = -100;
//
// return 0;
//}
对于整形来说:数据存放内存中其实存放的是补码。
为什么呢?
在计算机系统中,数值⼀律⽤补码来表⽰和存储。原因在于,使⽤补码,可以将符号位和数值域统⼀处理;同时,加法和减法也可以统⼀处理(CPU只有加法器)此外,补码与原码相互转换,其运算过程是相同的,不需要额外的硬件电路。
CPU只能进行加法
那么1-1就转成1+(-1)
//int main()
//{
// int a = 1 - 1;//1+(-1)
// //00000000000000000000000000000001- 1的原码
// //10000000000000000000000000000001- -1的原码
// //10000000000000000000000000000010- -2
//
// //使用补码计算就正确了
// //00000000000000000000000000000001- 1的补码
// //10000000000000000000000000000001- -1的原码
// //11111111111111111111111111111110- -1的反码
// //11111111111111111111111111111111- -1的补码
// //00000000000000000000000000000001- 1的补码
// //00000000000000000000000000000000- 0
// //
// return 0;
//}
4. 移位操作符
<< 左移操作符
>> 右移操作符
注:移位操作符的操作数只能是整数。
4.1左移操作符
移位规则:左边抛弃、右边补0
#include <stdio.h>
int main()
{
int num = 10;
int n = num<<1;
printf("n= %d\n", n);
printf("num= %d\n", num);
return 0;
}
4.2 右移操作符
移位规则:⾸先右移运算分两种:
1、逻辑右移:左边⽤0填充,右边丢弃
2、 算术右移:左边⽤原该值的符号位填充,右边丢弃
右移到底是算术右移还是逻辑右移?
这个标准没有确定,取决于编译器实现的
#include <stdio.h>
int main()
{
int num = 10;
int n = num>>1;
printf("n= %d\n", n);
printf("num= %d\n", num);
return 0;
}
警告⚠️:
对于移位运算符,不要移动负数位,这个是标准未定义的。
例如:
int num = 10;
num>>-1;//error
5. 位操作符:&、|、^、~
位操作符有:
& //按位与
| //按位或
^ //按位异或
~ //按位取反
注:他们的操作数必须是整数。
//int main()
//{
// int a = 4;
// int b = -7;
// int c = a & b;
// //使用补码进行按位与
// //对应二进制位有0就是0,两个同时为1才为1
// //00000000000000000000000000000100 - 4的补码
// //10000000000000000000000000000111 -7的原码
// //11111111111111111111111111111000
// //11111111111111111111111111111001 -7的补码
// //00000000000000000000000000000100 - 4的补码
// //00000000000000000000000000000000 -0
// //
// printf("%d\n", c);
//
// return 0;
//}
//int main()
//{
// int a = 4;
// int b = -7;
// int c = a | b;
// //使用补码进行按位或
// //对应二进制位有1就是1,两个同时为0才为0
// //00000000000000000000000000000100 - 4的补码
// //10000000000000000000000000000111 -7的原码
// //11111111111111111111111111111000
// //11111111111111111111111111111001 -7的补码
// //00000000000000000000000000000100 - 4的补码
// //11111111111111111111111111111101 - c中的补码
// //10000000000000000000000000000010
// //10000000000000000000000000000011 - 原码
//
// printf("%d\n", c);
//
// return 0;
//}
//int main()
//{
// int a = 4;
// int b = -7;
// int c = a ^ b;
// //使用补码进行按位异或
// //规则:相同为0,相异位1
// //00000000000000000000000000000100 - 4的补码
// //10000000000000000000000000000111 -7的原码
// //11111111111111111111111111111000
// //11111111111111111111111111111001 -7的补码
// //00000000000000000000000000000100 - 4的补码
// //11111111111111111111111111111101 c中的补码
// //10000000000000000000000000000010
// //10000000000000000000000000000011 c的原码
//
// printf("%d\n", c);
//
// return 0;
//}
//int main()
//{
// int a = 0;
// int b = ~a;
// //
// //00000000000000000000000000000000 - 补码
// //11111111111111111111111111111111 - b中的补码
// //10000000000000000000000000000000
// //10000000000000000000000000000001 -- -1
// printf("%d\n", b);//-1
//
// return 0;
//}
接下来写一道题
不能创建临时变量(第三个变量),实现两个整数的交换。
//
//写一个代码,完成2个整数的交换
//
//int main()
//{
// int a = 3;
// int b = 5;
// int c = 0;//空
//
// printf("交换前:a=%d b=%d\n", a, b);
// c = a;
// a = b;
// b = c;
// printf("交换后:a=%d b=%d\n", a, b);
//
// return 0;
//}
//int main()
//{
// int a = 3;
// int b = 5;
// //
// //当a和b的值较大的时候,可能出现溢出的情况
// //
// printf("交换前:a=%d b=%d\n", a, b);
// a = a + b;//a=8 b=5
// b = a - b;//a=8 b=3
// a = a - b;//a=5 b=3
// printf("交换后:a=%d b=%d\n", a, b);
//
// return 0;
//}
//异或运算的一些特殊场景
//相同为0,相异为1
//a^a = 0
//a^0 = a
//3^3^5 = 5
//3^5^3 = 5
//011
//101
//110
//011
//101
//int main()
//{
// int a = 3;
// int b = 5;
//
// printf("交换前:a=%d b=%d\n", a, b);
// a = a ^ b;
// b = a ^ b;
// a = a ^ b;
//
// printf("交换后:a=%d b=%d\n", a, b);
//
// return 0;
//}
再来一道题,寻找单身狗
一个数组中只有一个数字是出现一次,其他所有数字都出现了两次。
编写一个函数找出这两个只出现一次的数字。
例如:
有数组元素是:1,2,3,4,5,1,2,3,4
只有5出现了一次,我们要找出5
#include<stdio.h>
int find_single_dog1(int arr[], int sz)
{
int ret = 0; //记录数组元素两两相互异或的结果,初始化为0
for (int i = 0; i < sz; i++)
{
ret ^= arr[i]; //将数组元素两两相互异或
}
return ret;
}
int main()
{
int arr[] = { 1,2,3,4,5,1,2,3,4 };
int sz = sizeof(arr) / sizeof(arr[0]); //得到数组中的元素个数
int dog = find_single_dog1(arr, sz);
printf("dog=%d\n", dog);
return 0;
}
再来个进阶版,寻找单身狗2.0
//一个数组中只有两个数字是出现一次,其他所有数字都出现了两次。
//编写一个函数找出这两个只出现一次的数字。
//例如:
//有数组的元素是:1,2,3,4,5,1,2,3,4,6
//只有5和6只出现1次,要找出5和6.
#include<stdio.h>
void find_dog(int arr[],int n)
{
int ret = 0; //记录数组元素两两相互异或的结果,初始化为0
for (int i = 0; i < n; i++)
{
ret ^= arr[i]; //将数组元素两两相互异或
}
int m=0;
while(m<32)
{
if(((ret>>m)&1)==1)//找出两只单身狗从右到左最近相异的一位
break;
else
m++;
}
int a=0,b=0;
for(int i=0;i<n;i++)
{
if(((arr[i]>>m)&1)==1)
b^=arr[i];//把两只单身狗分到两个地方,其余一对一对抵消为0,不用考虑
else
a^=arr[i];
}
printf("两个单身狗是%d和%d\n",a,b);
}
int main()
{
int arr[10]={1,2,3,4,5,6,1,2,3,4};
int num=sizeof(arr)/sizeof(arr[0]);
find_dog(arr,num);
return 0;
}
练习1:编写代码实现:求⼀个整数存储在内存中的⼆进制中1的个数。
//-1
//10000000000000000000000000000001
//11111111111111111111111111111110
//11111111111111111111111111111111
//int count_one_of_bit(unsigned int m)
//{
// int count = 0;
// while (m)
// {
// if (m % 2 == 1)
// count++;
//
// m = m / 2;
// }
// return count;
//}
//
//int main()
//{
// int n = 0;
// scanf("%d", &n);
// int ret = count_one_of_bit(n);
// printf("%d\n", ret);
// return 0;
//}
//
//嵌入式
//
//
//int count_one_of_bit(unsigned int m)
//{
// int count = 0;
// int i = 0;
// for (i = 0; i < 32; i++)
// {
// if (((m >> i) & 1) == 1)
// count++;
// }
// return count;
//}
//
//int main()
//{
// int n = 0;
// scanf("%d", &n);
// int ret = count_one_of_bit(n);
// printf("%d\n", ret);
// return 0;
//}
//int count_one_of_bit(unsigned int m)
//{
// int count = 0;
// while (m)
// {
// count++;
// m = m & (m - 1);
// }
// return count;
//}
//
//int main()
//{
// int n = 0;
// scanf("%d", &n);
// int ret = count_one_of_bit(n);
// printf("%d\n", ret);
// return 0;
//}
练习2:⼆进制位置0或者置1
编写代码将13⼆进制序列的第5位修改为1,然后再改回0
13的2进制序列: 00000000000000000000000000001101
将第5位置为1后:00000000000000000000000000011101
将第5位再置为0:00000000000000000000000000001101
#include <stdio.h>
int main()
{
int a = 13;
a = a | (1<<4);
printf("a = %d\n", a);
a = a & ~(1<<4);
printf("a = %d\n", a);
return 0;
}
6. 单⽬操作符
单⽬操作符有这些:
!、++、--、&、*、+、-、~ 、sizeof、(类型)
单⽬操作符的特点是只有⼀个操作数。
7. 逗号表达式
逗号表达式,就是⽤逗号隔开的多个表达式。
逗号表达式,从左向右依次执⾏。整个表达式的结果是最后⼀个表达式的结果。
//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
//c是多少?
//先计算a>b为0,接着计算a=b+10得a=12,接着a=12,最后计算b=a+1得b=13.把b=13的值赋给c,则c的值为13
//代码2
if (a =b + 1, c=a / 2, d > 0)
//代码3
a = get_val();
count_val(a);
while (a > 0)
{
//业务处理
//...
a = get_val();
count_val(a);
}
如果使⽤逗号表达式,改写:
while (a = get_val(), count_val(a), a>0)
{
//业务处理
}
8. 下标访问[]、函数调⽤()
8.1[ ] 下标引⽤操作符
操作数:⼀个数组名 + ⼀个索引值(下标)
arr[10]; //创建数组
arr[9] = 10; //实⽤下标引⽤操作符。
[ ]的两个操作数是arr和9。
8.2 函数调⽤操作符
接受⼀个或者多个操作数:第⼀个操作数是函数名,剩余的操作数就是传递给函数的参数。
#include <stdio.h>
void test1()
{
printf("hehe\n");
}
void test2(const char *str)
{
printf("%s\n", str);
}
int main()
{
test1(); //这⾥的()就是作为函数调⽤操作符。
test2("hello bit.");//这⾥的()就是函数调⽤操作符。
return 0;
}
9. 结构成员访问操作符
9.1 结构体
C语⾔已经提供了内置类型,如:char、short、int、long、float、double等,但是只有这些内置类型还是不够的,假设我想描述学⽣,描述⼀本书,这时单⼀的内置类型是不⾏的。描述⼀个学⽣需要名字、年龄、学号、⾝⾼、体重等;描述⼀本书需要作者、出版社、定价等。C语⾔为了解决这个问题,增加了结构体这种⾃定义的数据类型,让程序员可以⾃⼰创造适合的类型。
结构是⼀些值的集合,这些值称为成员变量。结构的每个成员可以是不同类型的变量,如:
标量、数组、指针,甚⾄是其他结构体。
9.1.1 结构的声明
描述一个学生类:
struct stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}; //分号不能丢
9.1.2 结构体变量的定义和初始化
//代码1:变量的定义
struct Point
{
int x;
int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2
//代码2:初始化。
struct Point p3 = {10, 20};
struct Stu //类型声明
{
char name[15];//名字
int age; //年龄
};
struct Stu s1 = {"zhangsan", 20};//初始化
struct Stu s2 = {.age=20, .name="lisi"};//指定顺序初始化
//代码3
struct Node
{
int data;
struct Point p;
struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化
9.2 结构成员访问操作符
9.2.1 结构体成员的直接访问
结构体成员的直接访问是通过点操作符(.)访问的。点操作符接受两个操作数。如下所⽰:
#include <stdio.h>
struct Point
{
int x;
int y;
}p = {1,2};
int main()
{
printf("x: %d y: %d\n", p.x, p.y);
return 0;
}
使⽤⽅式:结构体变量.成员名
9.2.2 结构体成员的间接访问
有时候我们得到的不是⼀个结构体变量,⽽是得到了⼀个指向结构体的指针。如下所⽰:
#include <stdio.h>
struct Point
{
int x;
int y;
};
int main()
{
struct Point p = {3, 4};
struct Point *ptr = &p;
ptr->x = 10;
ptr->y = 20;
printf("x = %d y = %d\n", ptr->x, ptr->y);
return 0;
}
使⽤⽅式:结构体指针->成员名
综合举例:
#include <stdio.h>
#include <string.h>
struct Stu
{
char name[15];//名字
int age; //年龄
};
void print_stu(struct Stu s)
{
printf("%s %d\n", s.name, s.age);
}
void set_stu(struct Stu* ps)
{
strcpy(ps->name, "李四");
ps->age = 28;
}
int main()
{
struct Stu s = { "张三", 20 };
print_stu(s);
set_stu(&s);
print_stu(s);
return 0;
}
10. 操作符的属性:优先级、结合性
C语⾔的操作符有2个重要的属性:优先级、结合性,这两个属性决定了表达式求值的计算顺序。
10.1 优先级
优先级指的是,如果⼀个表达式包含多个运算符,哪个运算符应该优先执⾏。各种运算符的优先级是不⼀样的。
3 + 4 * 5;
上⾯⽰例中,表达式 3 + 4 * 5 ⾥⾯既有加法运算符( + ),⼜有乘法运算符( * )。由于乘法
的优先级⾼于加法,所以会先计算 4 * 5 ,⽽不是先计算 3 + 4 。
10.2 结合性
如果两个运算符优先级相同,优先级没办法确定先计算哪个了,这时候就看结合性了,则根据运算符是左结合,还是右结合,决定执⾏顺序。⼤部分运算符是左结合(从左到右执⾏),少数运算符是右结合(从右到左执⾏),⽐如赋值运算符( = )。
5 * 6 / 2;
上⾯⽰例中, * 和 / 的优先级相同,它们都是左结合运算符,所以从左到右执⾏,先计算 5 * 6 ,再计算 6 / 2 。
运算符的优先级顺序很多,下⾯是部分运算符的优先级顺序(按照优先级从⾼到低排列),建议⼤概记住这些操作符的优先级就⾏,其他操作符在使⽤的时候查看下⾯表格就可以了。
• 圆括号( () )
• ⾃增运算符( ++ ),⾃减运算符( -- )
• 单⽬运算符( + 和 - )
• 乘法( * ),除法( / )
• 加法( + ),减法( - )
• 关系运算符( < 、 > 等)
• 赋值运算符( = )
由于圆括号的优先级最⾼,可以使⽤它改变其他运算符的优先级。
参考:https://zh.cppreference.com/w/c/language/operator_precedence