文章目录
操作符
1. 操作符的分类
算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用,函数调用和结构成员
2. 算术操作符
+ - * / %
- 除
%
操作符外,其他几个操作符可用于整数和浮点数。 - 对于
/
操作符,如果两个操作数都是整数,执行整数除法,而只要有浮点数执行的就是浮点数除法。 %
操作符的两个操作数必须为整数,返回的是整除之后的余数。
3. 移位操作符
<< 左移操作符
>> 右移操作符
//位移操作符的操作数只能是整数,且操作的是内存中的补码。
3.1 左移操作符
位移规则:
左边抛弃,右边补零
3.2 右移运算符
移位规则:
- 逻辑移位
左边用0填充,右边丢弃
- 算术移位
左边用原该值的符号位填充,右边丢弃(编译器一般是算术移位)
int main()
{
int a = -1;
int b = a >> 1;
printf("b = %d\n", b);
return 0;
}
可发现结果为算术右移
a=-1 1111111111111111111111111111//补码
右移>>1 1111111111111111111111111111
输出原码 1000000000000000000000000001//结果为-1
注意:
对于移位运算符不要移动负数位,这个是标准未定义的,例如:
int num = 10;
num>>-1;//error
4. 位操作符
位操作符有:
& //按位与(都是1结果为1)
| //按位或(一个为1结果为1)
^ //按位异或(相同为0,相异为1)
//都是按二进制,且操作数必须为整数
例:
#include<stdio.h>
int main()
{
int a = 3;
int b = 5;
a & b;//0011 & 0101 = 0001
a | b;//0011 | 0101 = 0111
a ^ b;//0011 ^ 0101 = 0110
return 0;
}
注:
a ^ a = 0;
a ^ 0 = a;
4.1 不能创建临时变量(第三个变量),实现两个数的交换
#include<stdio.h>
int main()
{
int a = 3;
int b = 5;
a = a ^ b;
b = a ^ b;
a = a ^ b;
printf("a = %d,b = %d\n",a, b);
return 0;
}
4.2 求一个整数储存在内存中的二进制中1的个数
#include<stdio.h>
//方法1
int main()
{
int num = 10;
int count = 0;
while (num)
{
if (num % 2 == 1)
{
count++;
}
num /= 2;
}
printf("二进制中1的个数 = %d\n", count);
return 0;
}//写成函数用unsigned int接收可以计算负数中一的个数
//方法2
#include<stdio.h>
int main()
{
int num = 10;
int count = 0;
int i = 0;
for (i = 0;i < 32;i++)
{
if (num & (1<<i))
count++;
}
printf("二进制中1的个数 = %d\n", count);
return 0;
}
//方法3
#include<stdio.h>
int main()
{
int num = -1;//以补码形式计算
int count = 0;
int i = 0;
while (num)
{
count++;
num = num & (num - 1);
}
printf("二进制中1的个数 = %d\n", count);
return 0;
}
4.3 写一个代码判断一个数是不是2的n次方
//2的n次方的数字其中只有一个1
if(k&(k-1)==0)即为2的n次方数
4.4 求两个int(32位)整数m和n的二进制表达式中有多少个位(bit)不同
//方法1
#include<stdio.h>
int main()
{
int m = 0;
int n = 0;
scanf("%d%d", &m, &n);
int i = 0;
int count = 0;
for (i = 0;i < 32;i++)
{
if ((m & (1 << i) )!=( n & (1 << i)))
{
count++;
}
}
printf("%d", count);
return 0;
}
//方法2
#include<stdio.h>
int main()
{
int m = 0;
int n = 0;
scanf("%d%d", &m, &n);
int ret = m ^ n;//异或
int count = 0;
while (ret)
{
count++;
ret = ret & (ret - 1);
}
printf("%d\n", count);
return 0;
}
4.5 获取一个整数二进制序列中所有偶数位和奇数位,分别打印出二进制序列
#include<stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);
int i = 0;
//获取奇数位
for (i = 30;i >=0;i -= 2)//最后一位需移动0位到末尾
{
printf("%d ", (n >> i) & 1);
}
printf("\n");
//获取偶数位
for (i = 31;i>=1;i -= 2)//最后一位需移动1位到末尾
{
printf("%d ", (n >> i) & 1);
}
return 0;
}
4.6 替换二进制中的某一位
//如将a = 13,00001101中第5个0替换为1
#include<stdio.h>
int main()
{
int a = 13;
a = a | (1 << 4);
printf("a = %d\n", a);
return 0;
}
5.赋值操作符
复合赋值符
+= -= *= /= >>= <<= &= |= ^=
//连续赋值是把右边赋给左边,如b=a=a+5;但还是建议分开写便于调试
6.单目操作符
6.1 单目操作符介绍
! 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度(以字节为单位)
~ 对一个数的二进制按位取反
-- 前置、后置--
++ 前置、后置++
* 间接访问操作符(解引用操作符)
(类型) 强制类型转换
6.2 sizeof
和数组
#include <stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//(1)
}
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//(2)
}
int main()
{
int arr[10] = { 0 };
char ch[10] = { 0 };
printf("%d\n", sizeof(arr));//int类型为4个字节,所以4*10=40
printf("%d\n", sizeof(ch));//char类型为1个字节,所以1*10=10
test1(arr);
test2(ch);//(1)和(2)传递的都是数组首地址,地址都是4个字节
return 0;
}
//%zu专门用来接收sizeof的放回值
#include <stdio.h>
int main()
{
short s = 5;
int a = 10;
printf("%d\n", sizeof(s = a + 2));//赋值运算不会改变类型,编译阶段已经完成了sizeof的计算,赋值是在程序运行阶段
printf("%d\n", s);//sizeof括号内的表达式不参与运算
return 0;
}
6.3 ~操作符
//(1)如将a = 13,00001101中第5个0替换为1,(2)再将1替换回0
#include<stdio.h>
int main()
{
int a = 13;
a = a |(1 << 4);//(1)
a = a & ~(1 << 4);//(2)
printf("a = %d\n", a);
return 0;
}
//改某位数为1就对应位&1,改为0就对应位|0
6.4 ++和–运算符
#include<stdio.h>
int main()
{
int a = 10;
int b = a++;//后置++,先使用,再++
printf("a=%d b=%d\n",a, b);
return 0;
}
#include<stdio.h>
int main()
{
int a = 10;
int b = ++a;//前置++,先++,在使用
printf("a=%d b=%d\n",a, b);
return 0;
}
#include<stdio.h>
int main()
{
int a = 10;
printf("%d\n", a--);
printf("%d\n", a);
}
7. 关系操作符
> >= < <= != ==
8. 逻辑操作符
&& 逻辑与 || 逻辑或
区分逻辑与和按位与,逻辑或和按位或
1&2--->0
1&&2--->1
1|2--->3
1||2--->1
例:
#include<stdio.h>
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;//a初始为0,a&&后面结果必为0,所以后面不运算,i=0
printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c, d);
return 0;
}
#include<stdio.h>
int main()
{
int i = 0, a = 1, b = 2, c = 3, d = 4;
i = a++ || ++b || d++;//a初始为1,a||后面结果必为1,所以后面不运算,i=1
printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c, d);
return 0;
}
9. 条件操作符
exp1 ? exp2 : exp3
//例:
if(a>5)
b=3;
else
b=5;
//转化为条件操作符
b = ((a > 5) ? 3 : 5 )
10. 逗号表达式
exp1,exp2,exp3,...,expN
//例1:
int a = 1;
int b = 2;
int c = ( a > b , a = b + 10 , a ,b = a + 1)//结果为最后一个表达式的结果,b-13,第一个表达式的值为0
//例2:
a = get();
count(a);
while (a > 0)
{
//业务处理
a = get();
count(a);
}
//代码冗余,改成三木操作符
while (a = get(), count(a), a > )
{}
逗号表达式从左向右进行,整个表达式的结果是最后一个表达式的结果
11. 下标引用、函数调用和结构成员
- [ ]下标引用操作符
操作数:一个数组名+一个索引值
- ( )函数调用操作符
接受一个或多个操作数:第一个操作数是函数名,剩余的操作数就是传递给函数的参数
- 访问一个结构的成员
. 结构体变量名.成员名
-> 结构体指针->成员名
struct Book
{
char name[20];
char id[20];
int price;
};
//变量名访问
int main()
{
struct Book b = { "C语言","2022",18};
printf("书名:%s\n", b.name);
printf("书号:%s\n", b.id);
printf("价格:%d\n", b.price);
return 0;
}
//指针访问
int main()
{
struct Book b = { "C语言","2022",18};
struct Book* pb = &b;
printf("书名:%s\n", (*pb).name);
printf("书号:%s\n", (*pb).id);
printf("价格:%d\n", (*pb).price);
return 0;
}
struct Book b = { "C语言","2022",18};
struct Book* pb = &b;
printf("书名:%s\n", pb->name);
printf("书号:%s\n", pb->id);
printf("价格:%d\n", pb->price);
12. 表达式求值
表达式求值的顺序一部分由操作符的优先级和结合性决定,同样,有些表达式的操作数在求值过程中可能需要转化为其他类型。
12.1 隐式类型转换
C的整型算术运算总是至少以缺省整型类型的精度来进行的。 为了获得这个精度,表达式中的字符和短整型操作数在使用之前被转换为普通整型,这种转换称为整型提升。
整型提升的意义:
表达式的整型运算要在CPU的相应运算器件内执行,CPU内整型运算器(ALU)的操作数的字节长度 一般就是int的字节长度,同时也是CPU的通用寄存器的长度。
因此,即使两个char类型的相加,在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通用CPU(general-purpose CPU)是难以直接实现两个8比特字节直接相加运算(虽然机器指令 中可能有这种字节相加指令)。所以,表达式中各种长度可能小于int长度的整型值,都必须先转 换为int或unsigned int,然后才能送入CPU去执行运算。
如何进行整型提升
整型提升是按照变量的数据类型的符号位来提升的。
//负数的整型提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位:
1111111
因为 char 为有符号的 char
所以整形提升的时候,高位补充符号位,即为1
提升之后的结果是:
11111111111111111111111111111111
//正数的整型提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位:
00000001
因为 char 为有符号的 char
所以整形提升的时候,高位补充符号位,即为0
提升之后的结果是:
00000000000000000000000000000001
//无符号整型提升,高位补0
例1:
#include<stdio.h>
int main()
{
char a = 3;//00000011
char b = 127;//01111111
char c = a + b;//先提升,再截断
printf("%d\n", c);//%d打印,需要再次整型提升
return 0;
}
//先按符号位整型提升得c=11111111111111111111111110000010
//截断后c=10000010,打印成%d的形式又发生整型提升,并且返回原码
//先减1, 11111111111111111111111110000001
//再取反,10000000000000000000000001111110
//输出结果即为-126
例2:
#include<stdio.h>
int main()
{
char a = 0xb6;//10110110
short b = 0xb600;
int c = 0xb6000000;
if (a == 0xb6)
printf("a");
if (b == 0xb600)
printf("b");
if (c == 0xb6000000)
printf("c");
return 0;
}
实例2中的a,b(都达不到整型大小)要进行整型提升,但是c不需要整形提升 a,b整形提升之后,变成了负数,所以表达式 a=0xb6
,b=0xb600
的结果是假,但是c不发生整形提升,则表 达式 c==0xb6000000
的结果是真. 所程序输出的结果是: c。
例3:
int main()
{
char c = 1;
printf("%u\n", sizeof(c));
printf("%u\n", sizeof(+c));
printf("%u\n", sizeof(-c));
return 0;
}
//%u是无符号10进制数
实例3中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c)
是4个字 节. 表达式 -c 也会发生整形提升,所以 sizeof(-c)
是4个字节,但是 sizeof(c)
,就是1个字节
例4:
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
unsigned char a = 200;
unsigned char b = 100;
unsigned char c = 0;
//char类型只能存8个bit位
//11001000 -a
//01100100 -b
c = a + b;
//发生整型运算需要提升
//00000000000000000000000100101100 十进制为300
//00101100 -c 十进制为44
printf("%d %d", a + b, c);//a+b运算后直接输出,不需要截断,
//而c要先截断保留8bit位再提升
return 0;
}
12.2 算术转换
如果某个操作符的各个操作数属于不同的类型,那么除非其中一个操作数的转换为另一个操作数的类 型,否则操作就无法进行。下面的层次体系称为寻常算术转换。
long double
double
float
unsigned long int
long int
unsigned int
int
如果某个操作数的类型在上面这个列表中排名较低,那么首先要转换为另外一个操作数的类型后执行运算。
警告: 但是算术转换要合理,要不然会有一些潜在的问题。
float f = 3.14;
int num = f;//隐式转换,会有精度丢失
12.3 操作符的属性
复杂表达式的求值有三个影响的因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序。
两个相邻的操作符先执行哪个?取决于他们的优先级。如果两者的优先级相同,取决于他们的结合性。 操作符优先级。我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径,那这个表达式就是存在问题的。
#include<stdio.h>
int main()
{
int a, b, c;
a = 5;
c = ++a;//c=6,a=6
b = ++c, c++, ++a, a++;//c=8,b=7,a=8
b += a++ + c;//+=优先级低,实际上为 b += (a++ + c)先使用a再++ , a=9,c=8,b=23
printf("a = %d b = %d c = %d\n", a, b, c);
}
13. 练习
#include <stdio.h>
int i;//i是全局变量,不是初始化,默认为0
int main()
{
i--;
if (i > sizeof(i))
//sizeof操作符算出的结果的类型是unsigned int,比较时会将i转化成无符号型
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}
//故输出结果为 >
- 求
Sn=a+aa+aaa+aaaa+aaaaa
的前n项之和,其中a为一个数字。
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
int a = 0;
int n = 0;
scanf("%d%d", &a, &n);
int i = 0;
int sum = 0;
int ret = 0;
for (i = 0;i < n;i++)
{
ret = ret * 10 + a;
sum += ret;
}
printf("%d\n", sum);
return 0;
}
- 打印水仙花数,求出0~100000之间的所有水仙花数并输出。
水仙花数是指一个n位数,其各个位的n次方之和恰好等于该数本身,如153=13+53+33
#include <stdio.h>
#include<math.h>
int main()
{
int i = 0;
for (i = 0;i <= 100000;i++)
{
//计算i的位数
int n = 1;
int tmp = i;
while (tmp / 10)
{
n++;
tmp = tmp / 10;
}
//计算每一位的n次方之和
tmp = i;
int sum = 0;
while (tmp)
{
sum += pow(tmp % 10, n);
tmp /= 10;
}
if (sum == i)
{
printf("%d ", i);
}
}
printf("\n");
return 0;
}
4.变种水仙花数:把任意的数字,从中间拆分成两个数字,比如1461 可以拆分成(1和461),(14和61),(146和1),如果所有拆分后的乘积之和等于自身,则是一个Lily Number。
例如:
655 = 6 * 55 + 65 * 5
1461 = 1461 + 1461 + 146*1
求出 5位数中的所有 Lily Number。
#include <stdio.h>
#include<math.h>
int main()
{
int i = 0;
for (i = 10000; i <= 99999; i++)
{
int j = 0;
int sum = 0;
for (j = 1; j <= 4; j++)
{
int k = pow(10, j);
sum += (i / k) *( i % k);
}
if (i == sum)
{
printf("%d ",i);
}
}
return 0;
}