1、操作符的分类
算数操作符:+、-、*、/、%
移位操作符:<<、>>
位操作符:&、|、^
赋值操作符:=、+=、-=、*=、/=、%=、<<=、>>=、&=、|=、^=
单目操作符:!、++、--、&、*、+、-、~、sizeof(类型)
关系操作符:>、>=、<、<=、==、!=
逻辑操作符:&&、||
条件操作符:?、:
逗号操作符:,
下标引用:[]
函数调用:()
结构成员访问:.、->
2、二进制和进制转换
2进制、8进制、10进制、16进制是数值的不同表达形式。
1 15的2进制:1111
2 15的8进制:17
3 15的10进制:15
4 15的16进制:F
5
6 //16进制的数值之前写0x
7 //8进制的数值之前写:0
说明:10进制是我们生活中常用的,10进制中满10进1,10进制的数字每一位都是0~9的数字组成,所以类如2进制也是一样,2进制中满2进1,2进制的数字每一位都是0~1的数字组成。
2.1 2进制转10进制
10进制的每一位是有权重的,10进制的数字从右向左是个位、十位、百位...,分别每一位的权重是10的0次幂,10的1次幂,10的2次幂...如下图:
2进制和10进制是类似的,2进制的每一位权重,从右向左是:2的0次幂,2的1次幂,2的2次幂...入例如2进制的1101,如下如所示:
2.1.1 十进制转换二进制
2.2 2进制转换成8进制和16进制
2.2.1 2进制转换成8进制
8进制的数字每一位是0~7的数字,各自写成2进制,最多有3个二进制位就足够了,例如7写成2进制位就是111,所以2进制换成8进制位,从右边开始数每3个2进制位就会转换成1个8进制位,剩余不足够3位的直接转换。
2.2.2 2进制转换成16进制
16进制的数字每一位是0~9,a~f的数字,各自写成2进制,最多有4位就足够了,例如f写成2进制位就是1111,所以2进制换成16进制是从右向左4个二进制位换成1个16进制,剩余不够4个二进制位的直接转换。
3、原码、反码、补码
整数的2进制表示方法有三种,即原码、反码和补码
有符号整数的三种表示方法均有符号位和数值位两部分,2进制序列中,最高位的1位是被当做符号位,剩余的都是数值位。
符号位都是用0表示正,用1表示负。
正整数的原、反、补码都相同。
负整数的三种表示方法各不相同。
原码:直接将数值正负数的形式翻译成二进制得到的就是原码。
反码:将原码的符号位不变,其他位依次按位取反就可以得到反码。
补码:反码+1就能得到补码
补码得到原码也是可以使用:取反,+1的操作。
对于整型来说:数据存放内存中其实存放的是补码。
在计算机系统中,数值一律用补码来表示和存储。原因在于使用补码,可以将符号位和数值域统一处理;同时,加法和减法也可以统一处理(CPU只有加法器)此外,补码与原码相互转换,其运算过程是相同的,不需要额外的硬件电路。
4、移位操作符
<<左移操作符
>>右移操作符
注意:移位操作符的操作数只能是整数。
4.1 左移操作符
位移规则:左边抛弃、右边补0
#include <stdio.h>
int main()
{
int num = 10;
int n = num << 1;
printf("%d\n",n);
printf("%d\n", num);
return 0;
}
由于 int num = 10;
num的2进制表示为:00000000000000000000000000001010
num<<1的结果为,但是num的值是不变的: 0000000000000000000000000000010100(红色为丢失的一位,蓝色为补的一位)。
4.2 右移操作符
移位规则:首先右移运算分两种:
1.逻辑右移:左边用0填充,右边丢弃
2.算术右移:左边用原该值的符号位填充,右边丢弃
#include <stdio.h>
int main()
{
int num = 10;
int n = num >> 1;
printf("%d\n",num);
printf("%d\n", n);
return 0;
}
警告:对于位移运算符,不要移动负数位,这个是标准未定义的。
例如:
int num=10;
num>>-1;//error
5、位操作符
位操作符有:
1 & //按位与
2 | //按位或
3 ^ //按位异或
4 ~ //按位取反
注:他们的操作数必须是整数
#include <stdio.h>
int main()
{
int num1 = 3;
int num2 = -1;
printf("%d\n", num1 & num2);
printf("%d\n", num1 | num2);
printf("%d\n", num1 ^ num2);
printf("%d\n", ~0);
return 0;
}
一道变态面试题:在不使用临时变量的情况下(第三个变量),交换两个整型的数值。代码如下:
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
a = a ^ b;
b = a ^ b;
a = a ^ b;
printf("a=%d\n",a);
printf("b=%d\n",b);
return 0;
}
思路:a^b逻辑异或是满足交换律的,而且例如:a^b^b得到的是a本身。
练习1,编写代码实现:求一个整数存储在2进制中的1的个数。
#include <stdio.h>
//方法1
int main()
{
int n = 13;
int count = 0;
while (n)
{
if (n % 2 == 1)
count++;
n = n / 2;
}
printf("二进制中1的个数:%d",count);
return 0;
}
//第二种方法
int main()
{
int n = -1;
int i = 0;
int count = 0;
for (i = 0; i < 32; i++)
{
if (n & (1 << i))
count++;
}
printf("二进制中1的个数为:%d",count);
return 0;
}
//第三种方法
int main()
{
int n = 0;
scanf("%d",&n);
int count = 0;
while (n)
{
n = n & (n - 1);
count++;
}
printf("二进制中1的个数为:%d\n",count);
return 0;
}
练习2:编写代码将13二进制序列的第5位修改为1,然后再改为0。
#include <stdio.h>
int main()
{
int num = 13;
num = num | (1 << 4);
printf("num=%d\n",num);
num = num | ~(1 << 4);
printf("num=%d\n", num);
return 0;
}
6、单目操作符
单目操作符如下所示:
!、++、--、&、|、~、+、-、*、/、sizeof、(类型)
7、逗号表达式
逗号表达式就是用逗号隔开的多种表达式
1 exp1,exp2,exp3,exp4.....expn
逗号表达式从左向右执行,整个表达式的结果是最右边表达式的结果
8、下标引用[]、函数调用()
8.1 下标引用操作符
操作数:一个数组名+一个索引值(下标)
1 int arr[10];//创建数组
2 arr[9]=10;//使用下标引用操作符
3 []两个操作符是arr和9
8.2函数引用操作符
接收一个或多个操作数,第一个操作数是函数名,剩余的操作数就是传给函数的参数。
#incldue <stdio.h>
void test1()
{
printf("hehe\n");
}
void test2(const char *str)
{
printf("%s",str);
}
int main()
{
test1();//这里()就是作为函数调用操作符
test2("haha\n");
return 0;
}
9、结构成员访问操作符
9.1 结构体
C语言已经提供了内置类型,如:char、short、int、long、float、double等,但是只有这些内置类型还是不够,类如描述一个学生需要名字、年龄、学号、身高、体重等。为了解决这个问题C语言中增加了结构体这种自定义的类型,让程序员可以自己创造合适的类型。
注:结构是一些值的集合,这些值称为成员变量。结构的每个成员可以是不同类型的变量,如:标量、数组、指针,甚至是其他结构体。
9.1.1 结构的声明
1 struct tag
2 {
3 member-list;
4 }variable-list;
描述一个学生:
1 struct Stu
2 {
3 char name[20];//名字
4 int age;//年龄
5 char sex[5];//性别
6 char id[20];//学号
7 };//分号不能丢
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;
}
使用方式:结构体指针->成员名
10.操作符的属性:优先级、结合性
C语言的操作数有2个重要的属性:优先级、结合性,这两个属性决定了表达式求值的计算顺序。
10.1 优先级
优先级指的是,如果一个表达式包含多个运算符,哪个运算符应该先执行,各种运算符的优先级是不一样的。
1 3+4*5;
如上所示,表达式里既有加法又有乘法,由于乘法优先级高于加法,所以会先计算4*5,再计算3+4。
10.2 结合性
如果两个运算符的优先级相同,计算的顺序就看结合性了,大部分运算符的左结合(从左到右执行),少数运算符是右结合(从右到左执行),比如赋值运算符(=)。
运算符优先级如下图所示:
参考:C 运算符优先级 - cppreference.com
11.表达式求值
11.1整型提升
C语言中的整型运算,总是至少以默认整型类型的精度来进行的。
为了获得这个精度,在进入运算前,字符型和短整型的字符值会先转化为普通类型,这种转化被称为整型提升。
整型提升的意义:
表达式的整型运算要在CPU的相应运算器件内执行 ,CPU内整型运算器(ALU)的操作数的字节长度一 般就是int的字节长度 ,同时也是CPU的通用寄存器的长度。
因此 ,即使两个char类型的相加 ,在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通用CPU(general-purpose CPU)是难以直接实现两个8比特字节直接相加运算(虽然机器指令中 可能有这种字节相加指令) 。所以 ,表达式中各种长度可能小于int长度的整型值 ,都必须先转换为 int或unsigned int ,然后才能送入CPU去执行运算。
整数提升的方法:
1. 有符号整数提升是按照变量的数据类型的符号位来提升的
2.无符号整数提升,高位补0
11.2 算术转换
如果某个操作符的各个操作数属于不同的类型,那么除非其中一个操作数的转换为另一个操作数的类型,否则操作数就无法进行。下面的层次体系称为寻常算术转换。
1 long double
2 double
3 float
4 unsigned long int
5 long int
6 unsigend int
7 int
如果某个操作数的类型在上面这个列表中排名靠后,那么首先要转换为另外一个操作数的类型后执行运算。
11.3 问题表达式解析
11.3.1 表达式1
//表达式的求值部分由操作符的优先级决定
//表达式1
a*b+c*d+e*f
表达式1在计算的时候,由于*比+的优先级高,只能保证*的计算比+早,但是优先级并不能决定第三个*比第一个+早执行。
所以表达式的计算机顺序就可能是:
11.3.2 表达式2
//表达式2
c+ --c;
同上,操作符的优先级只能决定自减--的运算在+的运算的前面,但是我们并没有办法得知,+操作符的左操作数的获取在右操作之前还是之后求值,所以结果是不可预测的,是有歧义的。
11.3.3 表达式3
//表达式3
int main()
{
int i = 10;
i = i-- - --i * ( i = -3 ) * i++ + ++i;
printf("i = %d\n",i);
return 0;
}
表达式3在不同编译器中测试结果:⾮法表达式程序的结果
11.3.4 表达式4
#include <stdio.h>
int fun()
{
static int count = 1;
return ++count;
}
int main()
{
int answer;
answer = fun() - fun() * fun();
printf("%d\n",answer);
return 0;
}
上述代码中answer=fun()-fun()*fun();我们只能通过操作符的有衔接得知:先算乘法,再算减法。
函数的调用先后顺序无法通过操作符的优先级确定。
11.3.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;
}
这段代码中的第一个+在执行的时候,第三个++是否执行,这个是不确定的,因为依靠操作符的有限级和结合性是无法决定第一个+和第三个前置++的先后顺序。
11.4 总结
即使有了操作符的优先级和结合性,我们写出的表达式依然有可能不能通过操作符的属性确定唯⼀的 计算路径,那这个表达式就是存在潜在⻛险的,建议不要写出特别复杂的表达式。