操作符详解
分类：
算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员
算术操作符
- - * / %
#include<stdio.h>
int main()
{
int a = 5 / 2;//取商
int b = 5 % 2;//取余数
printf("%d %d",a,b);
return 0;
}//结果为2 1- 除了 % 操作符只能作用于整数之外，其他的几个操作符可以作用于整除和浮点数
- 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数，执行的就是浮点数除法。
移位操作符
<< 左移操作符
>> 右移操作符
- 右移操作符：
代码语言：c 复制算术右移：右边丢弃，左边补符号位。一般的编译器都采用这种方式。 逻辑右移：右边丢弃，左边补零
//右移操作符
#include<stdio.h>
int main()
{
int a = 16;
//>> --右操作符
//移动的是二进制位
//而a定义为整型，有四个字节，把它变为二进制为10000
//00000000000000000000000000010000
int b = a >> 1;
//而a>>1意为将a的二进制数向右移动
//若是算术右移
//00000000000000000000000000010000
// 0000000000000000000000000001000"0"该零丢弃
//"0"0000000000000000000000000001000 补符号位0是正数
printf("%dn",b);//8
return 0;
}//对于负数
#include<stdio.h>
int main()
{
int a = -1;
//整数的二进制表示有:原码、反码、补码，上方正整数的二进制数原反补码都相同
//存储到内存的是补码
//100000000000000000000000000000001 -- 原码
//111111111111111111111111111111110 -- 反码，符号位不变，其他的按原码位取反
//111111111111111111111111111111111 -- 补码，反码加一
int b = a>>2;
//若是逻辑右移则
// 11111111111111111111111111111111"1"丢弃
//"0"11111111111111111111111111111111 左边补零变为正数
printf("%d",b);// -1
return 0;
}- 左移操作符：
代码语言：c 复制左边丢弃，右边补0
#include<stdio.h>
int main()
{
int a = 5;
int b = a<<1;
printf("%d",b);//10
//a的补码为00000000000000000000000000000101
//左移后为'0'0000000000000000000000000000101'0'
// 该零丢弃 右边补零
}位操作符
- 按位与&
#include<stdio.h>
int main()
{
//& - 按2进制位与
int a = 4;
int b = 5;
int c = a&b;
printf("%d",&c);//4
//00000000000000000000000000000100 --a--4
//00000000000000000000000000000101 --b--5
//00000000000000000000000000000100 --c = 4
//按照对应的二进制位，两者都为1则该位取1否则取0
return 0;
}- 按位或|
#include<stdio.h>
int main()
{
// | - 按2进制位或
int a = 4;
int b = 5;
int c = a|b;
printf("%d",&c);//5
//00000000000000000000000000000100 --a--4
//00000000000000000000000000000101 --b--5
//00000000000000000000000000000101 --c = 5
//按照对应的二进制位，两者只要有一个为1则该位取1否则取0
return 0;
return 0;
}- 按位异或 ^
#include<stdio.h>
int main()
{
// ^ - 按2进制位异或
int a = 4;
int b = 5;
int c = a ^ b;
printf("%d",&c);//1
//00000000000000000000000000000100 --a--4
//00000000000000000000000000000101 --b--5
//00000000000000000000000000000001 --c = 1
//按照对应的二进制位，相同为0，相异为1
return 0;
return 0;
}//例，用按位异或的方法调换ab值
#include<stdio.h>
int main()
{
int a = 4;
int b = 5;
printf("a=%d b=%d",a,b);
a=a^b;
b=a^b;
a=a^b;
printf("a=%d b=%d",a,b);
return 0;
}//求二进制位中1的个数(使用移位操作符)
#include<stdio.h>
int main()
{
int num = -1;
int i = 0;
int count = 0;
while(num)
{
for((num>>1)&1)==1)
count ;
}
printf("二进制1的个数为：%d",count);
return 0;
}//使用位操作符求求二进制位中1的个数
#include<stdio.h>
int main()
{
int num = -1;
int i = 0;
int count = 0;
while(num)
{
count ;
num=num&(num-1);
}
printf("二进制1的个数为：%d",count);
return 0;
}赋值操作符
- 复合赋值符
代码语言：c 复制= , -= , *= , /= , %= , >>= , <<= , &= , |= , ^=
#include<stdio.h>
int main()
{
int a = 0;// '=' 赋值符
a = 2;
//等价于a=a 2,其他以此类推
return 0;
}单目操作符
代码语言：c 复制! 逻辑反操作
- 负值
正值
& 取地址
sizeof 操作数的类型长度
~ 对一个数的二进制按位取反
-- 前置、后置 --
前置、后置
* 间接访问操作符(解引用操作符)
(类型) 强制类型转换
// !
#include<stdio.h>
int mian()
{
int a=0;
if(!a)//a为零，零为假，!a为真
printf("peace");
return 0;
}// & *
#include<stdio.h>
int mian()
{
int a=0;
int*p=&a;//取地址操作符
*p;//"*"解引用操作符，通过p存放的地址找到该地址位置，即a
return 0;
}// sizeof
#inlude<stdio.h>
int main()
{
short b=0;
int a = 10;
char c = 'r';
char*p = &c;
int arr[10]={0};
//sizeof 计算变量所占空间大小，单位是字节
printf("%dn",sizeof(a));//4
printf("%dn",sizeof(int));//4
printf("%dn",sizeof(c));//1
printf("%dn",sizeof(char));//1
printf("%dn",sizeof(p));//8
printf("%dn",sizeof(char*));//8
printf("%dn",sizeof(arr));//40
printf("%dn",sizeof(int [10]));//40
printf("%dn",sizeof(b=a 5));//2 b为短整型
printf("%dn",b);//0
//sizeof()括号内部表达式不参与运算
return 0;
}// ~
#include<stdio.h>
int main()
{
int a=0;
//~ 按二进制位取反
//00000000000000000000000000000000 --a的补码
//11111111111111111111111111111111 -- 补码
//11111111111111111111111111111110 -- 反码
//10000000000000000000000000000001 -- 原码
printf("%d",~a);//-1
return 0;
}// example
#include<stdio.h>
int main()
{
int a = 11;
//00000000000000000000000000001'0'11让这一位为1
a=a|(1<<2);
//00000000000000000000000000001011 -- 11
//00000000000000000000000000000100 -- (1<<2)
//00000000000000000000000000001111 -- a|(1<<2)
printf("%dn",a);//15
//00000000000000000000000000001'1'11 这一位改为0
a=a&~(1<<2);
//11111111111111111111111111111011 -- ~(1<<2)
//00000000000000000000000000001011 -- a&~(1<<2)
printf("%d",a);//11
return 0;
}// -- 前后置
#include<stdio.h>
int main()
{
int a = 10;
printf("%dn", a);//前置 ,先 1,后使用,a为11
printf("%dn",a );//后置 ,先使用,后 1,a为11
printf("%d",a);//12
return 0;
}// --同理// (类型)将数据强制转换
#include<stdio.h>
int main()
{
double a = (int)3.14;
printf("%f",a);
return 0;// 3.000000
}关系操作符
< <= > >= != ==
!= 用于测试不相等 == 用于测试相等
没什么好讲的比较简单
逻辑操作符
代码语言：c 复制&& 逻辑与
|| 逻辑或
#include<stdio.h>
int main()
{
int a = 3;
int b = 5;
int c = a&&b;
printf("%d",c);//1
return 0;
}- 注意点
//&&
#include<stdio.h>
int main()
{
int i ,a = 0, b = 2, c = 3 , d = 4;
i = a && b&&d ;
printf("a=%dnb=%dnc=%dnd=%d",a,b,c,d);//1,2,3,4
//因为a初始值为0,在上面逻辑与判断中a先使用进行逻辑与判断，初始为0，所以后面全部不执行，此时a再加1
//所以在逻辑与判断中从，左往右判断，只有结果为真时才继续往后判断，否则后面全部不执行
return 0;
}//||
#include<stdio.h>
int main()
{
int i ,a = 1, b = 2, c = 3 , d = 4;
i = a || b||d ;
printf("a=%dnb=%dnc=%dnd=%d",a,b,c,d);//2 2 3 4
//同逻辑与类似，a初始值是1为真，所以后面的全部不执行
//所以在逻辑或判断中从，左往右判断，只有结果为假时才继续往后判断，否则后面全部不执行
return 0;
}条件操作符
代码语言：c 复制exp1 ? exp2 : exp3
表达式1为真则执行表达式2，不执行表达式3，若表达式1为假则相反
//例
#include<stdio.h>
int main()
{
int i;
for(i=0;i<2;i )
{
i?printf("hahan"):printf("hehen");
}
return 0;
}
//hehe
//haha逗号表达式
代码语言：c 复制exp1 , exp2 , exp3 , expN ;
使用多个逗号隔开的多个表达式，从左向右依次执行，整个表达式的结果是最后一个表达式的结果
//例
#include<stdio.h>
int main()
{
int a = 1;
int b = 2;
int c = (a>b,a=b 10,a,b=a 1);
printf("%d",c);//13
return 0;
}下标引用、函数调用和结构成员
代码语言：c 复制下标引用 number
用于数组中，指代第x个元素
#include<stdio.h>
int main()
{
int a[10]={0};
a[4]=10;//其中[]这里面的4指a数组里面的第五个元素
return 0;
}代码语言：c 复制函数调用（）
#include<stdio.h>
int get_max(int x,int y)
{
return x>y?x:y;
}
int main()
{
int a = 5;
int b = 10;
int max = get_max(a,b);//此处括号即为函数调用操作符
printf("%d",max);
return 0;
}代码语言：c 复制结构体成员
"." 结构体
"->" 结构体指针
#include<stdio.h>
struct Man
{
char name[20];
int age;
int weight;
};//对于struct Man 这是我们创建的一个类型，等价于int(整型)flooat(浮点型)，而这个相当于一个人(Man)的类型
int main()
{
struct Man M1={"LY",18,66};
printf("%sn",M1.name);
printf("%dn",M1.age);
printf("%dn",M1.weight);
//printf函数中的 “ . ”即为结构体成员
//对于结构体指针如下
struct Man* pM1 = &M1;
printf("%sn",pM1->name);
printf("%dn",pM1->age);
printf("%dn",pM1->weight);
//同理，该printf函数中“ -> ”即为结构体成员
//两种结构体成员都是找到变量所对应的我们创建的(Man)类型中的内容
return 0;
} - 
