目录
1. 操作符分类
算术操作符移位操作符位操作符赋值操作符单目操作符关系操作符逻辑操作符条件操作符逗号表达式下标引用、函数调用和结构成员
2. 算术操作符
+ - * / %1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
3. 移位操作符
<< 左移操作符
>> 右移操作符
注：移位操作符的操作数只能是整数。3.1 左移操作符
移位规则：左边抛弃、右边补0
int main()
{
int a = 4;
//00000000000000000000000000000100 - 4的补码
//
int b = a << 1;//把a向左移动一位
//00000000000000000000000000001000 -b
printf("a=%d b=%d\n", a, b);//4 8
return 0;
}
int main()
{
int a = -4;
//10000000000000000000000000000100 - -4的原码
//11111111111111111111111111111011 - -4的反码
//11111111111111111111111111111100 - -4的补码
int b = a << 1;//把a向左移动一位
//11111111111111111111111111111000 - b中存储的补码
//11111111111111111111111111110111 - b的反码
//10000000000000000000000000001000 - b的原码
//-8
printf("a=%d b=%d\n", a, b);//-4 -8
return 0;
}总结：
左移一位，有扩大2倍的效果（扩大一个二进制位）
3.2 右移操作符
移位规则：首先右移运算分两种：1. 逻辑移位左边用0填充，右边丢弃2. 算术移位（绝大部分的编译器采用算数右移）左边用原该值的符号位填充，右边丢弃
int main()
{
int a = -4;
//10000000000000000000000000000100 - -4的原码
//11111111111111111111111111111011 - -4的反码
//11111111111111111111111111111100 - -4的补码
int b = a >> 1;//
//11111111111111111111111111111100
//11111111111111111111111111111110 - b在内存中的补码
//11111111111111111111111111111101 - b的反码
//10000000000000000000000000000010 - b的原码
//-2
printf("a=%d b=%d\n", a, b);// -4 -2
return 0;
}
int main()
{
int a = 4;
//00000000000000000000000000000100 补码
//
int b = a >> 1;//
//00000000000000000000000000000010 补码
printf("a=%d b=%d\n", a, b);//4 2
return 0;
}总结：
右移一位，有缩小2倍的效果（缩小一个二进制位）
警告 ⚠ ：对于移位运算符，不要移动负数位，这个是标准未定义的。
int num = 10;
num>>-1;//error4. 位操作符
& //按位与 （同1为1）
| //按位或 （有1为1）
^ //按位异或 （相同为0，相异为1）
注：他们的操作数必须是整数。看下面代码：
int main()
{
int a = 3;
int b = -5;
int c = a & b;//& - 按（2进制）位与
printf("%d\n", c);//3
//
//00000000000000000000000000000011 - 3的补码
//10000000000000000000000000000101 -5的原码
//11111111111111111111111111111010 -5的反码
//11111111111111111111111111111011 -5的补码
//
//00000000000000000000000000000011
//11111111111111111111111111111011
//00000000000000000000000000000011 - 3
//
return 0;
}int main()
{
int a = 3;
int b = -5;
int c = a | b;//& - 按（2进制）位或
printf("%d\n", c);//-5
//
//00000000000000000000000000000011 -> 3的补码
//10000000000000000000000000000101 -5的原码
//11111111111111111111111111111010 -5的反码
//11111111111111111111111111111011 -5的补码
//
//00000000000000000000000000000011
//11111111111111111111111111111011
//11111111111111111111111111111011
//11111111111111111111111111111010
//10000000000000000000000000000101 -> -5
return 0;
}int main()
{
int a = 3;
int b = -5;
int c = a ^ b;//& - 按（2进制）位异或
printf("%d\n", c);
//异或的运算：相同为0，相异为1
//
//00000000000000000000000000000011 -> 3的补码
//10000000000000000000000000000101 -5的原码
//11111111111111111111111111111010 -5的反码
//11111111111111111111111111111011 -5的补码
//
//00000000000000000000000000000011
//11111111111111111111111111111011
//11111111111111111111111111111000
//11111111111111111111111111110111
//10000000000000000000000000001000
//-8
//
return 0;
}4.1练习
1.不创建临时变量，实现两个整数的交换
方法1：
int main()
{
int a = 3;
int b = 5;
a = a + b;//如果a b都很大，那么a+b可能会超过int的取值范围，因此存在一定的缺陷
b = a - b;
a = a - b;
printf("a=%d b=%d\n", a, b);// 5 3
return 0;
}
方法2：
//方法2
int main()
{
int a = 3;
int b = 5;
a = a ^ b;
b = a ^ b;//b=a ^ b ^ b
a = a ^ b;//a^b^a
printf("a=%d b=%d\n", a, b);//5 3
return 0;
}2.编写代码实现：求一个整数存储在内存中的二进制中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;
}
//方法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 x = 10;
x = x+10;
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。6. 单目操作符
6.1 单目操作符介绍
! 逻辑反操作- 负值+ 正值& 取地址sizeof 操作数的类型长度（以字节为单位）~ 对一个数的二进制按位取反-- 前置、后置 --++ 前置、后置 ++* 间接访问操作符(解引用操作符)(类型) 强制类型转换
//逻辑取反操作
int main()
{
int flag = 0;
//if (!flag)//取反操作符
if(flag == 0)
{
printf("hehe\n");
}
return 0;
}//取地址和解引用操作
int main()
{
int a = 10;//4
char c = 0;//1
printf("%p\n", &a);
printf("%p\n", &c);
int* pa = &a;//& - 取地址操作符
//*pa = 20;//* - 解引用操作符
*pa = 20;//int* <--- int
return 0;
}sizeof的分析：
//sizeof操作
int main()
{
short s = 10;
int a = 2;
s = a + 5;
printf("%zu\n", sizeof(s = a + 5));
printf("%d\n", s);//
//int a = 10;
//int* p;
//int arr[10];
//printf("%zu\n", sizeof(a));//int 4
//printf("%zu\n", sizeof a);//int 4
//printf("%zu\n", sizeof(int));//int 4
printf("%zu\n", sizeof int);//err
//printf("%zu\n", sizeof(p));//int* 4
//printf("%zu\n", sizeof(arr));//int [10] 40
//printf("%zu\n", sizeof(arr[10]));//int 4
return 0;
}//sizeof操作
#include <stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//(2)4
}
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//(4)4
}
int main()
{
int arr[10] = { 0 };
char ch[10] = { 0 };
printf("%d\n", sizeof(arr));//(1)40
printf("%d\n", sizeof(ch));//(3)10
test1(arr);
test2(ch);
return 0;
}
//问：
//（1）、（2）两个地方分别输出多少？
//（3）、（4）两个地方分别输出多少？//按位取反操作
int main()
{
int a = 0;
//00000000000000000000000000000000
//11111111111111111111111111111111 - 内存中-补码
//11111111111111111111111111111110
//10000000000000000000000000000001
//-1
printf("%d\n", ~a);
return 0;
}//++ --操作符
int main()
{
int a = 4;
//int b = ++a;//前置++，先++，后使用
//a=a+1;b=a;
//int b = a++;//后置++，先使用，再++
//b=a;a=a+1;
//int b = --a;//前置--，先--，后使用
//a=a-1;b=a;
//int b = a--;//后置--，先--，后使用
//printf("%d\n", b);//
//printf("%d\n", a);//
return 0;
}
//强制类型转换操作
int main()
{
int a = (int)3.14;
printf("%d\n", a);//3
return 0;
}7. 关系操作符
>>=<<=!= 用于测试 “ 不相等 ”== 用于测试 “ 相等 ”
警告：在编程的过程中== 和=不小心写错，导致的错误。
int main()
{
int a = 10;
if (a == 10)//怕写成赋值语句a = 10
{
}
if (10 == a)//建议
{
}
return 0;
}8. 逻辑操作符
&& 逻辑与(并且的意思)
|| 逻辑或（或者的意思）
只关注真假1 & 2 -----> 01 && 2 ----> 11 | 2 -----> 31 || 2 ----> 1
看一个笔试题（重点）
#include <stdio.h>
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
//i = a++||++b||d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);//1 2 3 4
return 0;
}
// a&&b 如果表达式a为假，表达式b就不计算了
// a||b 如果表达式a为真，表达式b就不计算了
//程序输出的结果是什么？ 9. 条件操作符
exp1 ? exp2 : exp3exp1为真的话，exp2计算，exp3不计算，整体表达式的值为exp2的值
exp1为假的话，exp2不计算，exp3计算，整体表达式的值为exp3的值
int main()
{
int a = 3;
int b = 0;
if (a > 5)
b = 3;
else
b = -3;
b = ((a > 5) ? 3 : -3);//是上面代码的换写
int m = (a > b ? a : b);
return 0;
}10. 逗号表达式
exp1, exp2, exp3, …expN逗号表达式，就是用逗号隔开的多个表达式。逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
//c是多少？//13
//代码2
if (a =b + 1, c=a / 2, d > 0)//起作用的表达式是: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)
{
//业务处理
}11. 下标引用、函数调用和结构成员
1. [ ] 下标引用操作符
操作数：一个数组名
+
一个索引值
int arr[10];//创建数组
arr[9] = 10;//实用下标引用操作符。
[ ]的两个操作数是arr和9。2. ( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
#include <stdio.h>
void test1()
{
printf("hehe\n");
}
void test2(const char* str)
{
printf("%s\n", str);
}
int main()
{
test1(); //实用（）作为函数调用操作符。
test2("hello");//实用（）作为函数调用操作符。
return 0;
}3. 访问一个结构的成员
. 结构体.成员名-> 结构体指针->成员名
struct Book
{
char name[20];
int price;
};
int main()
{
struct Book sb = {"好好学习", 55};
printf("%s %d\n", sb.name, sb.price);//结构体变量.结构体成员名
struct Book* ps = &sb;
printf("%s %d\n", (*ps).name, (*ps).price);
printf("%s %d\n", ps->name, ps->price);//结构体指针->结构体成员名
return 0;
}12. 表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
12.1 隐式类型转换(整型提升和截断)
C
的整型算术运算总是至少以
缺省整型类型
的精度来进行的。
为了获得这个精度，
表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为
整型提升。
整型提升的意义 ：表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。通用CPU是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以， 表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。
//实例1
char a,b,c;
...
a = b + c;
b和c的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。如何进行整体提升呢？
//负数的整形提升
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 = 5;//截断
char b = 126;//截断
char c = a + b;//截断
//00000000000000000000000000000101
//00000101 - a
//00000000000000000000000001111110
//01111110 - b
//整型提升
//00000000000000000000000000000101-a
//00000000000000000000000001111110-b
//00000000000000000000000010000011
//10000011 - c
printf("%d\n", c);
//%d 十进制的方式打印有符号整数
//11111111111111111111111110000011
//11111111111111111111111110000010
//10000000000000000000000001111101
//-125
//
return 0;
}//实例1
int main()
{
char a = 0xb6;
short b = 0xb600;
int c = 0xb6000000;
if(a==0xb6)
printf("a");
if(b==0xb600)
printf("b");
if(c==0xb6000000)
printf("c");
return 0;
}
实例1中的a,b要进行整形提升,但是c不需要整形提升
a,b整形提升之后,变成了负数,所以表达式 a==0xb6 , b==0xb600 的结果是假,但是c不发生整形提升,则表
达式 c==0xb6000000 的结果是真.
所程序输出的结果是:
c//实例2
int main()
{
char c = 1;
printf("%u\n", sizeof(c));
printf("%u\n", sizeof(+c));
printf("%u\n", sizeof(-c));
return 0;
}
实例2中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字
节.
表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof(c) ,就是1个字节.12.2 算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的
类型，否则操作就无法进行。
long doubledoublefloatunsigned long intlong intunsigned intint精度越来越低
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型（排名较高的类型）后执行运算
警告：但是算术转换要合理，要不然会有一些潜在的问题。float f = 3.14; int num = f;//隐式转换，会有精度丢失
12.3 操作符的属性
复杂表达式的求值有三个影响的因素。1. 操作符的优先级2. 操作符的结合性3. 是否控制求值顺序。
两个相邻的操作符先执行哪个？
取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
| 操作符 | 描述 | 用法 |
|
（）
| 聚组 |
（表达式）
|
|
（）
|
函数调用
|
rexp
（
rexp
，
...,rexp
）
|
|
[ ]
|
下标引用
|
rexp[rexp]
|
|
.
|
访问结构成员
|
lexp.member_name
|
|
->
|
访问结构指针成员
|
rexp->member_name
|
|
++
|
后缀自增
|
lexp ++
|
|
--
|
后缀自减
|
lexp --
|
|
!
|
逻辑反
|
! rexp
|
|
~
|
按位取反
|
~ rexp
|
|
+
|
单目，表示正值
|
+ rexp
|
|
-
|
单目，表示负值
|
- rexp
|
|
++
|
前缀自增
|
++ lexp
|
|
--
|
前缀自减
|
-- lexp
|
|
*
|
间接访问（解引用）
|
* rexp
|
|
&
|
取地址
|
& lexp
|
|
sizeof
|
取其长度，以字节表示
|
sizeof rexp sizeof(
类
型
)
|
|
(
类型）
|
类型转换
|
(
类型
) rexp
|
|
*
|
乘法
|
rexp * rexp
|
|
/
|
除法
|
rexp / rexp
|
|
%
|
整数取余
|
rexp % rexp
|
|
+
|
加法
|
rexp + rexp
|
|
-
|
减法
|
rexp - rexp
|
|
<<
|
左移位
|
rexp << rexp
|
|
>>
|
右移位
|
rexp >> rexp
|
|
>
|
大于
|
rexp > rexp
|
|
>=
|
大于等于
|
rexp >= rexp
|
|
<
|
小于
|
rexp < rexp
|
|
<=
|
小于等于
|
rexp <= rexp
|
|
==
|
等于
|
rexp == rexp
|
|
!=
|
不等于
|
rexp != rexp
|
|
&
|
位与
|
rexp & rexp
|
|
^
|
位异或
|
rexp ^ rexp
|
|
|
|
位或
|
rexp | rexp
|
|
&&
|
逻辑与
|
rexp && rexp
|
|
| |
|
逻辑或
|
rexp | | rexp
|
|
? :
|
条件操作符
|
rexp ? rexp : rexp
|
|
=
|
赋值
|
lexp = rexp
|
|
+=
|
以
...
加
|
lexp += rexp
|
|
-=
|
以
...
减
|
lexp -= rexp
|
|
*=
|
以
...
乘
|
lexp *= rexp
|
|
/=
|
以
...
除
|
lexp /= rexp
|
|
%=
|
以
...
取模
|
lexp %= rexp
|
|
<<=
|
以
...
左移
|
lexp <<= rexp
|
|
>>=
|
以
...
右移
|
lexp >>= rexp
|
|
&=
|
以
...
与
|
lexp &= rexp
|
|
^=
|
以
...
异或
|
lexp ^= rexp
|
|
|=
|
以
...
或
|
lexp |= rexp
|
|
，
|
逗号
|
rexp
，
rexp
|
12.4一些问题表达式的分析
//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f
注释：代码1在计算的时候，由于*比+的优先级高，只能保证，*的计算是比+早，但是优先级并不
能决定第三个*比第一个+早执行。
所以表达式的计算机顺序就可能是：
a*b
c*d
a*b + c*d
e*f
a*b + c*d + e*f
或者是
a*b
c*d
e*f
a*b + c*d
a*b + c*d + e*f//表达式2
c + --c;
操作符的优先级只能决定自减--的运算在+的运算的前面，但是我们并没有办法得
知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义
的。//代码3-非法表达式
int main()
{
int i = 10;
i = i-- - --i * ( i = -3 ) * i++ + ++i;
printf("i = %d\n", i);
return 0;
}
//表达式过于复杂，编译器识别有分歧，可读性也差//代码5
#include <stdio.h>
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf("%d\n", ret);
printf("%d\n", i);
return 0;
}
//尝试在linux 环境gcc编译器，VS2013环境下都执行，看结果都不一样
600
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
