目录
1.操作符分类
• 算术操作符： + 、- 、* 、/ 、%
• 移位操作符: << >> (移动的是二进制位)
• 位操作符: & | ^ (用二进制位计算)
• 赋值操作符: = 、+= 、 -= 、 *= 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=
• 单目操作符： ！、++、--、&、*、+、-、~ 、sizeof、(类型)
• 关系操作符: > 、>= 、< 、<= 、 == 、 !=
• 逻辑操作符： && 、||
• 条件操作符： ? :
• 逗号表达式： ,
• 下标引用： []
• 函数调用： ()
• 结构成员访问： . 、->
上述的操作符，我们已经讲过算术操作符、赋值操作符、逻辑操作符、条件操作符和部分的单目操作符，今天继续介绍⼀部分，操作符中有⼀些操作符和⼆进制有关系，我们先铺垫⼀下⼆进制的和进制转换的知识。
2.二进制和进制转换
其实我们经常能听到 2进制、8进制、10进制、16进制 这样的讲法，那是什么意思呢？
其实2进制、8进制、10进制、16进制是数值的不同表示形式而已。
比如：数值15的各种进制的表示形式：
15的2进制：1111 15的8进制：17 15的10进制：15 15的16进制：F
2.1 二进制转十进制
其实10进制的123表⽰的值是⼀百二十三，为什么是这个值呢？其实10进制的每⼀位是有权重的，10进制的数字从右向左是个位、⼗位、百位....，分别每⼀位的权重是 10 , 10 , 10 ...
2.2 十进制转二进制
-
可以用除2取余的方法
-
也可以有更方便的方法(记住2的次幂数,然后对比十进制数,进行适当的加和)
2.3 二进制转八进制和十六进制
8进制的数字每⼀位是0~7的，0~7的数字，各自写成2进制，最多有3个2进制位就足够了，比如7的⼆进制是111，所以在2进制转8进制数的时候，从2进制序列中右边低位开始向左每3个2进制位会换算⼀个8进制位，剩余不够3个2进制位的直接换算。
-
如：2进制的 01101011，换成8进制：0153，0开头的数字，会被当做8进制。
001 101 011 三个二进制数位一组然后算出他们的值再相加 前面不够三位补0
int main() {
printf("%d\n", 153);//输出153
printf("%d", 0153);// 数字前有0 转成8进制了 输出107
}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
int main() {
printf("%d", 0x6b); // 输出 16进制 107
}3.原码 反码 补码
整数的2进制表示法有三种，即原码、反码和补码 ---->(小数没有)
有符号整数(signed int)的三种表示方法均有符号位和数值位两部分，2进制序列中，最高位的1位是被当做符号位，剩余的都是数值位。
符号位都是用0表示“正”，用1表示“负”。
无符号数(unsigned int),全是数值位,没有符号位 (原码 反码 补码都一样)
-
正整数的原、反、补码都相同。
-
负整数的三种表示方法各不相同。
-
原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
-
反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。
-
补码：反码+1就得到补码。
int main() {
int i = 10; //四个字节 32bit位
//0 0000000000000000000000000001010 源码
//0 0000000000000000000000000001010 反码
//0 0000000000000000000000000001010 补码
int i = -10;//负数
//1 0000000000000000000000000001010 源码
//1 1111111111111111111111111110101 反码
//1 1111111111111111111111111111110 源码
}
-
补码得到原码也是可以使用：取反，+1的操作。
-
对于整形来说：数据存放内存中其实存放的是补码。
为什么呢？在计算机系统中，数值⼀律⽤补码来表⽰和存储。原因在于，使⽤补码， 可以将符号位和数值域统⼀处理；同时，加法和减法也可以统⼀处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。
-
我们看一个 1 - 1 的例子 可以拆分成 1 + (-1)计算
-
分别用原码(算出错误的值:2) 和 补码(算出0 正确)去计算 看看出现什么问题
4.移位操作符
<< 左移操作符
>> 右移操作符
注：移位操作符的操作数只能是整数。
移动的是存储在内存中的二进制位(补码)
4.1左移操作符
移位规则：左边抛弃、右边补0 记住要化成补码 如果是负数,要先求出补码,再求回原码(取反码,再+1)
左移一位 有 ✖ 2的效果 2^n n是位数
int main() {
int a = 10;
int b = a << 1; //左移一位
printf("a = %d\n", a);//a的值不改变
a = a<<1//这样的话可以将a的值改变
printf("b = %d", b);//输出20 左移一位 有✖ 2的效果 2^n n是位数
return 0;
}
int main() {
int a = -10;
//1000000000000000000000000001010 原码
//1111111111111111111111111110101 反码
//1111111111111111111111111110110 补码
//
//1111111111111111111111111101100 向左移1位 左移符
//1000000000000000000000000010011 取反
//1000000000000000000000000010100 -20
a = a << 1;
printf("%d", a);
return 0;
}4.2右移操作符
移位规则：首先右移运算分两种：
-
逻辑右移：左边用0填充，右边丢弃
-
算术右移：左边用原该值的符号位填充，右边丢弃 (编译器一般是算数右移)
int main() {
int a = -10;
a = a >> 1;
printf("%d", a);//输出-5
return 0;
}警告⚠️：对于移位运算符，不要移动负数位，这个是标准未定义的。
5.位操作符：&、|、^、~
位操作符,按二进制位计算 (补码) 如果是负数最后结果要转回原码 (先取反后＋1)
& //按位与 && //逻辑与
| //按位或 || //逻辑或
^ //按位异或
~ //按位取反-
& 有0为0,同1为1 (双目操作符)
-
| 有0为1,同0为0
-
^ 相同为0,不同为1
-
~ 每一位都取反
#include <stdio.h>
int main()
{
int num1 = -3;
int num2 = 5;
printf("%d\n", num1 & num2);
printf("%d\n", num1 | num2);
printf("%d\n", num1 ^ num2);
printf("%d\n", ~0);
return 0;
}
/*输出
5
-3
-8
-1/*-
面试题
-
创建临时变量,进行两个值交换
int main() {
int a = 3;
int b = 4;
int c = 0; //c是空盘子
c = a; // c作为一个媒介 a先放到c a空了,把b放到a, b空了,把c放到b
a = b;
b = c;
printf("a=%d\n", a);
printf("b=%d", b);
return 0;
}-
如果不创建,进行两个值交换 也是有bug 因为整形有最大值,如果a b均不超过最大值
但是相加后会超过最大值,会造成溢出;
int main() {
int a = 5;
int b = 2;
printf("%d %d\n", a, b);
a = a + b;
b = a - b;
a = a - b;
printf("%d %d\n", a, b);
return 0;
}-
这种异或的方式不会有bug
int main() {
int a = 5;
int b = 3;
printf("%d %d\n", a, b);
//5^3^3
//101
//011
//结果为110
// 011 异或为101 = 5
a = a ^ b; //5^3
b = a ^ b ;//a^b^b 5^3^3 b变成5 两个b变a
a = a ^ b;// a^b^a 5^3^5 a变成3 两个a变b
printf("%d %d\n", a, b);
}-
求一个整数存储在内存中的二进制中1的个数 (用unsigned 解决负数的问题)
//求一个整数存储在内存中的二进制中1的个数
int count_bit(unsigned int n) {
int count = 0;
while (n) {
if ((n % 2) == 1) 假设输出15 二进制是1111 每次都%2 得到1 然后再将后面的一位去掉
count++;
n = n / 2;
}
return count;
}
int main() {
int n = 0;
scanf("%d", &n);
int ret = count_bit(n);
printf("%d",ret);
return 0;
}-
另外一种方法,可以有& 1 == 1 的方法(1 & 1肯定等于1 如果是0的话就不等于1),然后将该二进制数不断右移 & 1 用count 记录 1 的个数
int count_bit( int n) {
int count = 0;
int i = 0;
for (i = 0; i < 32; i++) {
if (((n >> i )&1) == 1)
{
count++;
}
}
return count;
}
int main() {
int n = 0;
scanf("%d", &n);
int ret = count_bit(n);
printf("%d",ret);
return 0;
}-
更高效的算法 ,去掉最右边的1(有几个1就算几次,更高效)
int count_bit( int n) {
int count = 0;
while (n) {
n = n & (n - 1);//将最右边的1去掉 去掉一次count++
count++;
}
return count;
}
int main() {
int n = 0;
scanf("%d", &n);
int ret = count_bit(n);
printf("%d",ret);
return 0;
}-
写一个代码,判断n是否是2的次方数?
因为2的次方数是0001 0010 二进制都是只有一个1,可以用上面的n & (n-1) == 0 那就可以判断是2的次方数
void if_erjinzhi(int n) {
if ((n & (n - 1)) == 0) {
printf("%d是二的次方数\n", n);
}
else {
printf("%d不是二的次方数\n", n);
}
}
int main() {
int n = 0;
scanf("%d", &n);
if_erjinzhi(n);
return 0;
}-
编写代码将13⼆进制序列的第5位修改为1，然后再改回0
13的2进制序列： 00000000000000000000000000001101 将第5位置为1后：00000000000000000000000000011101 将第5位再置为0：00000000000000000000000000001101
int main() {
int i = 13;
int n = 0;
scanf("%d", &n);
i = i | (1 << (n - 1));//将1的二进制位左移4位然后和13的二进制位或运算就能得到1
printf("修改后的数为:%d\n", i);
i = i & ~(1 << (n - 1));
printf("修改后的数为:%d", i);
return 0;
}6.单目操作符
！、++、--、&、*、+、-、~ 、sizeof、(类型)
-
& 取地址操作符 * 解引用操作 指针
7.逗号表达式
exp1, exp2, exp3, …expN
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后⼀个表达式的结果(不是一上来看最后一个,前面的表达式要依次左往右计算,再取最后的结果)
分析: a>b(不大于返回0) a = b+10(12) , a(12), b=a+1(12+1=13)
int main() {
int a = 1;
int b = 2;
int c = (a > b, a = b+10,a ,b=a+1);//逗号表达式
printf("%d", c);
return 0;
}
int main() {
int a = 0;
int b = 0;
int c = 0;
int d = 0;
if (a = b + 1, c = a / 2, d > 0) { //if表达式中也可以使用但是只取d>0这个条件
}
return 0
}-
可以更简化算法,
a = get_val(); count_val(a); 和 while循环里面的语句是一样的,可以用逗号表达式
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下标引用操作符
操作数：⼀个数组名 + ⼀个索引值(下标)
int arr[10];//创建数组 arr[9] = 10;//实⽤下标引⽤操作符。 [ ]的两个操作数是arr和9。
8.2 函数调用操作符
-
接受⼀个或者多个操作数：第⼀个操作数是函数名，剩余的操作数就是传递给函数的参数。
-
test2("hello bit.");//这⾥的()就是函数调⽤操作符。 test2 和 "hello bit." 这两个是操作数
-
至少一个操作数 test() 调用函数
#include <stdio.h>
void test1()
{
printf("hehe\n");// ( ) 函数调用操作符
}
void test2(const char *str)
{
printf("%s\n", str);
}
int main()
{
test1(); //这⾥的()就是作为函数调⽤操作符。
test2("hello bit.");//这⾥的()就是函数调⽤操作符。 test2 和 "hello bit."
return 0;
}9.结构成员访问操作符
9.1 结构体
C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学生，描述⼀本书，这时单⼀的内置类型是不行的。
描述⼀个学⽣需要名字、年龄、学号、身高、体重等；
描述⼀本书需要作者、出版社、定价等。C语言为了解决这个问题，增加了结构体这种⾃定义的数据类型，让程序员可以自己创造适合的类型。
结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如： 标量、数组、指针，甚⾄是其他结构体。
9.2结构的声明
struct tag {
member-list;(成员列表)
}
variable-list;(变量列表)
//学生类型
struct Student
{
//成员变量
char name[20];
int age;
float score;
}s1,s2,s3; //可以在这里创建全局变量
struct Point
{
int x;
int y;
};
struct S
{
char ch;
struct Point p; //在结构体里面嵌套一个初始化的结构体对象
};
int main() {
struct Student s4 = {"李四",20,98}; //局部变量 赋值
struct Student s5 = {"陈好",20,98}; //局部变量 赋值
struct S s = { 'a',{4,5} };//初始化,用一个大括号括上即可
return 0;
}9.3结构体成员的直接访问
-
结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数
-
结构体变量.成员名
//学生类型
struct Student
{
//成员变量
char name[20];
int age;
float score;
}s1,s2,s3; //可以在这里创建全局变量
struct Point
{
int x;
int y;
};
struct S
{
char ch;
struct Point p; //在结构体里面嵌套一个初始化的结构体对象
};
int main() {
struct Student s4 = {"李四",20,98}; //局部变量 赋值
struct Student s5 = {"陈好",20,98}; //局部变量 赋值
struct S s = { 'a',{4,5} };//初始化,用一个大括号括上即可
printf("%c\n", s.ch); //结构体变量 . 变量名
printf("%d %d", s.p.x, s.p.y);
return 0;
}9.4结构体成员的间接访问
有时候我们得到的不是⼀个结构体变量，而是得到了⼀个指向结构体的指针。(学到指针补充)
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 优先级
优先级指的是，如果⼀个表达式包含多个运算符，哪个运算符应该优先执行。各种运算符的优先级是不⼀样的。相邻的操作符 优先级高的先执行
3 + 4 * 5;//先算4*5在+3 (3+4)*5//加括号改变优先级
-
优先级排序
-
运算符的优先级顺序很多，下面是部分运算符的优先级顺序（按照优先级从⾼到低排列），建议⼤概记住这些操作符的优先级就行，其他操作符在使⽤的时候查看下⾯表格就可以了。
• 圆括号（ () ）
• ⾃增运算符（ ++ ），⾃减运算符（ -- ）
• 单⽬运算符（ + 和 - ）
• 乘法（ * ），除法（ / ）
• 加法（ + ），减法（ - ）
• 关系运算符（ < 、 > 等）
• 赋值运算符（ = ）
10.2结合性
-
如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，则根据运算符是左结合，还是右结合，决定执行顺序。大部分运算符是左结合（从左到右执行），少数运算符是右结合（从右到左执行），比如赋值运算符( =)
11.表达式求值
11.整形提升
C语言中整型算术运算总是至少以缺省（默认）整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
-
整形提升的意义
表达式的整型运算要在CPU的相应运算器件内执⾏，CPU内整型运算器(ALU)的操作数的字节⻓度⼀般就是int的字节⻓度，同时也是CPU的通⽤寄存器的⻓度。 因此，即使两个char类型的相加，在CPU执⾏时实际上也要先转换为CPU内整型操作数的标准⻓度。 通⽤CPU（general-purpose CPU）是难以直接实现两个8⽐特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种⻓度可能⼩于int⻓度的整型值，都必须先转换为int或unsigned int，然后才能送⼊CPU去执⾏运算
-
如何进行整体提升呢
-
有符号整数提升是按照变量的数据类型的符号位来提升的
-
无符号整数提升，高位补0
vs中char默认是 signed char 取值范围 -128~127
int main() {
//vs中char 是 signed char
char a = 20;
//00000000000000000000000000010100
//00010100 -a 取八个字节(8位)
char b = 130;
//00000000000000000000000010000010
//10000010 -b
char c = a + b;
//00000000000000000000000000010100 -a 看符号位往前补零
//11111111111111111111111110000010 -b 看符号位往前补1
//11111111111111111111111110010110 截断八个位置
-------------------------------------
//10010110 -c 提升
//11111111111111111111111110010110 再转成原码(取反 +1)
//10000000000000000000000001101001
//10000000000000000000000001101010 - 输出106
printf("%d", c);
return 0;
}11.2算术转换
讨论的是类型大于等于整形的类型的类型
-
向上转换,把小的往大的转换
long double
double
float
unsigned long int
long int
unsigned int
int11.3问题表达式解析
-
过于复杂的表达式可能会造成错误的运算顺序 避免写过于复杂的表达式
a * b + c * d + e * f
1 2 3 4 5
计算的顺序是 1 3 5 2 4 或 1 3 2 5 4-
可能会出现问题: 第一个c 不知道他的值是怎么样的
//表达式2
int c = 5;
c + --c; //c = 5 然后 --c =4 5+4 = 9
c + --c //一开始没赋值 先--c等于4 然后 4+4 =8 引起歧义-
第三个表达式在不同的编译器都有不一样的结果
int main()
{
int i = 10;
i = i-- - --i * ( i = -3 ) * i++ + ++i;
printf("i = %d\n", i);
return 0;
}-
表达式4
#include <stdio.h>
int fun()
{
static int count = 1;
return ++count;
}
int main()
{
int answer;
// 2 3 4
// 3 2 4
// 4 3 2
//不能保证函数执行的结果只能保证操作符的执行顺序
answer = fun() - fun() * fun();
printf("%d\n", answer);//输出多少？ 输出-10
return 0;
}-
表达式5,在不同的编译器有不同的结果,
-
上来先执行三次++i i变成4 所以计算结果是 4+4+4=12
//表达式5
#include <stdio.h>
int main()
{
int i = 1;
//上来先执行三次++i i变成4 所以计算结果是 4+4+4=12
int ret = (++i) + (++i) + (++i);
printf("%d\n", ret);//12
printf("%d\n", i);//4
return 0;
}
//尝试在linux 环境gcc编译器，VS2013环境下都执⾏，看结果。总结:
即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯⼀的计算路径，那这个表达式就是存在潜在险的，建议不要写出特别复杂的表达式。
扫一扫
1360
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
