C语言操作符和表达式详细讲解

1、操作符分类：

1、算术操作符 + - * / %
2、移位操作符 << >>
3、位操作符 & | ^
4、赋值操作符 = += -= …
5、单目操作符 sizeof ! ++ –
6、关系操作符 > >= < <= != ==
7、逻辑操作符 && ||
8、条件操作符 ?:
9、逗号表达式 ,
10、下标引用、函数调用和结构成员 [] -> () .

2、算术操作符

加+ 减- 乘* 除/ 取余%

+、-、*都非常简单，但要注意/和%

• 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
• 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。

int ret =9/2;    整数除法
double tmp=9/2.0 浮点数除法

• % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

3、移位操作符

3.1 操作符基础知识

• 移位操作符，移动的是二进制位(补码)
• 对于整数的二进制有3种表示形式：原码、反码、补码
• 正整数-原码、反码、补码相同
• 负整数
  1、原码-直接按照数字的正负写出的二进制序列
  2、反码-原码的符号位不变，其他位按位取反
  3、补码-反码+1
• 警告⚠ ： 对于移位运算符，不要移动负数位，这个是标准未定义的 。并且操作数要针对整数。

3.2 左移操作符<<：左边丢弃，右边补0

int a=5;
int b=a<<1;
//原00000000000000000000000000000101
//反00000000000000000000000000000101
//补00000000000000000000000000000101
//将a的二进制位向左移动一位,首位的0被丢弃，后面
//的空缺位置补0，如下图所示
//注意：在这个过程中a的值没变，只不过是对a进行了一种运算

3.3 右移操作符>>
1、逻辑移位：左边用0填充，右边丢弃

int a=-1;
int b=a>>1;
//11111111111111111111111111111111
//移位得到
//01111111111111111111111111111111

2、算术以为：左边用原该值的符号位填充，右边丢弃，大多数情况下编译器以此为主

int a=-1;
int b=a>>1;
//11111111111111111111111111111111
//移位得到
//11111111111111111111111111111111

4、位操作符

• 位操作符有

& //按位与
| //按位或
^ //按位异或
注：他们的操作数必须是整数

• &按位与，二进制位都为1为1，有一个0及以上时为0；

int main()
{
    int a=3;
    int b=-2;
    int c=a&b;
    //00000000000000000000000000000011  3的补码
    //11111111111111111111111111111110  -2的补码
    //00000000000000000000000000000010   按位与的结果
    //得到的结果是补码，要翻译成原码才是屏幕显示的
}

• |按位或 二进制位只要有1就为1

int main()
{
    int a=3;
    int b=-2;
    int c=a&b;
    //00000000000000000000000000000011  3的补码
    //11111111111111111111111111111110  -2的补码
    //11111111111111111111111111111111 按位或的结果

• ^异或 二进制位相同为0，相异为1

int main()
{
    int a=3;
    int b=-2;
    int c=a&b;
    //00000000000000000000000000000011  3的补码
    //11111111111111111111111111111110  -2的补码
    //11111111111111111111111111111101 按位异或的结果

• 位操作符的应用，交换两个变量

//方法0 交换变量常用的临时变量法
int main()
{
    int a=10;
    int b=90;
    int tmp=0;
     tmp=a;
     a=b;
     b=tmp;

}
//方法一 整型变量有最大上限，如果数值较大，会出现溢出
int main()
{
    int a=10;
    int b=90;
    a=a+b;
    b=a-b;
    a=a-b;
    return 0;
}
//方法二 
int main()
{
    int a=10;
    int b=90;
    a=a^b;
    b=a^b;
    a=a^b;
}
尽管方法二较为简便，但是在过程中使用较少，因为可读性低，且效率低于方法0。
对方法二的理解：a和b异或得到密码，b和密码异或能翻译出a，a和密码继续异或
能翻译出原来的b。
a^a=0 0^a=a
a^a^b=b a^b^a=b 所以异或是支持交换律的

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;//连续赋值
先将y+1的值赋给x，再将x的值赋给a。可读性低

拆分后的同义句：这样的写法更加清晰而且易于调试
x=y+1;
a=x;

6、符合赋值符

简单介绍一些赋值运算符

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

这些运算符都可以写成复合的效果。 比如：

int a=10;
a=a>>1;
a>>=1;//复合赋值

int x = 10;
x = x+10;
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁

7、单目操作符：只有一个操作数的操作符

• 一些单目操作符

!           逻辑反操作
 -           负值
 -           正值
&           取地址
sizeof      操作数的类型长度（以字节为单位）
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
 -           间接访问操作符(解引用操作符)
(类型)       强制类型转换

• ！逻辑反操作

！逻辑反操作，把真变成假，把假变成真
int main()
{
    int a=0;
    int b=!a;  //!a=1
    if(a) //a为真打印Hello
    {
        printf("Hello");
    }
     if(！a) //a为假打印Hello
    {
        printf("Hello");
    }
}

• *解引用操作符

int main()
{
    int a=10;
    itn *p=&a;
    int b=*p;
    *p=20
}
//对于任何变量都由所其空间和空间里的值构成
//左值用的是空间，右值用的是内容
//*p放在右边用的是指向空间里面的值，*p放在左边用的是指向的空间

• sizeof

//1、sizeof是操作符，不是函数
//2、sizeof是计算变量或者类型创建变量的内存大小，单位字节
//和内存中存放什么数据没有关系
int main()
{
   int a;
    printf("%d",sizeof(a));//4
    printf("%d",sizeof a);//4
//当是变量时可以省略，求的还是a的内存大小，说明sizeof不是函数
    printf("%d",sizeof(int));//4
    printf("%d",sizeof int)//4 有些编译器支持这种写法
       
    
    int b=5;
    short s=10;
    printf("%d",sizeof(s=a+2));//2
    printf("%d",s);//10
在正常情况下int类型的值放入short类型中会发生截断，在sizeof中
因为是将值放到short类型的s中，所以计算的值为2。
sizeof内部的表达式是不参与运算的，所以s的值仍为10
}

详解sizeof内部的表达式不产与运算：在编译期间就把sizeof的功能实现了，编译器一看s的类型取决于short就得到了2这个结果，即在链接的过程中没有机会执行a+2这个动作。所以sizeof内部的表达式不参与运算。

• 详解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};
 数组名单独放在sizeof内部，
 数组名表示整个数组，
 计算的是整个数组的大小，单位是字节
 printf("%d\n", sizeof(arr));//(1) 40    
 printf("%d\n", sizeof(ch));//(3) 10
 数组传参的时候，数组名会降级传过去首元素的地址，本质上是个指针。
 sizeof计算的指针的大小，在32位为4，64位为8
 test1(arr);
 test2(ch);
 return 0;
}

• ~将二进制位按位取反

//可以与其他操作符配合使用，进行二进制位改变。
int a=0;
//00000000000000000000000000000000
~a;
//11111111111111111111111111111111

• ++和–

int main()
{
//后置++，先使用，后++
    int a=10;
    int b=a++;
    printf("%d",a);//11
    printf("%d",b);//10
}
int main()
{
//前置++，先++，后使用
    int a=10;
    int b=a++;
    printf("%d",a);//11
    printf("%d",b);//11
}
//-- 也分为前置--和后置--，用法和++一样。
//注意：++和--不要写出过于复杂的表达式，比如下面代码：
int main()
{
    int a=1;
    int b=(++a)+(++a)+(++a);
    return 0;
}

• ()强制类型转换

int main()
{
    int a=3.14//默认写出的浮点数是double
    //直接这样写可能会出现丢失数据
    //正确写法
    int a=(int)3.14;
}

8、关系操作符

用在同类型的变量比较，时间和地址的比较没有意义
>
>=
<
<=
!=   用于测试“不相等”
==      用于测试“相等”

这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。
警告： 在编程的过程中== 和=不小心写错，导致的错误。

9、逻辑操作符

&&     逻辑与(表并且)
int main()
{
    int a=3;
    int b=5;
//逻辑与只关注真假，a为真并且b为真，那整体就为真
//a和b有一个为假就为假
    int c=a&&b;
}
||     逻辑或(表或者)
int main()
{
    int a=0;
    int b=5;
//a和b中有一个为真，表达式即为真
    int c=a||b;
}

真题
#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;//1 2 3 4 
先使用，a以0的值使用，因为前面为假，所以表达式整体为假，还没有到
++b部分，现在以0&&d++，为整体，前面为假，整体为假，d++也没有执行。
    i = a++||++b||d++//1 3 3 4
a++，先使用原先a的值，a为假，继续到++b，看真或假
    printf("a = %d\n b = %d\n c = %d\nd = %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++，先使用a的值1，为真，所以整个a++||++b为真，
得到结果1，++b被跳过，接着1||d++，1
的结果为真，整个表达式的为真，得到结果1，d++也被跳过
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
//2 2 3 4
    return 0;
}

10、条件操作符

• exp1? exp2 : exp3,也是唯一的三目操作符，如果表达式的结果为真，则表达式2的结果为整体表达式的结果，否则表达式3的结果为整体表达式的结果。可以看成if else选择语句。

转换成条件表达式
if (a > 5)
        b = 3;
else
        b = -3;

a>5?b=3:b=-3;

求两个数的最大值
int main()
{
    int a=10;
    int b=20;
    int m=((a>b)?(a):(b));//利用括号括起来，可读性高且语法安全
}

11、逗号表达式

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)
{
//解决了原有的代码冗余问题
         //业务处理
}

12、下标引用、函数调用和结构成员

1、[] 下标引用操作符
操作数：一个数组名+一个索引值

int arr[10];//创建数组
arr[9] = 10;//实用下标引用操作符。
arr[9]->*(arr+9)->*(9+arr)->9[arr]
//语法支持9[arr]形式，但一般不写成9[arr]的形式。
[]的两个操作数是arr和9
printf("%p---%p",&arr[8],arr+8);//这俩地址一样
//arr+i就是数组arr中，下标为i的元素的地址

2、()函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

#include <stdio.h>
 void test1()
 {
 printf("hehe\n");
 }
 void test2(const char *str)
 {
 printf("%s\n", str);
 }
 int main()
 {
 test1();            //实用（）作为函数调用操作符。
 test2("hello bit.");//实用（）作为函数调用操作符。
 return 0;
 }

3、结构成员的访问

. 用法：结构体.成员名

->用法：结构体指针->成员名

//自定义数据类型
struct Book
{
    char name[10];
    float price;
    char id[10];
};
void Print1(struct Book b)
{
    printf("书名:%s\n",b.name);
    printf("价格:%f\n",b.price);
    printf("书号:%s\n",b.id);
}
void Print2()
{
    printf("书名:%s\n",b->name);
    printf("价格:%f\n",b->price);
    printf("书号:%s\n",b->id);
}
int main()
{
    struct Book b={"C book","55.5f","c21415215"};
    b.name="数据结构";//错误写法，name是首元素的地址
    strcpy(b.name,"数据结构");//利用strcpy来实现改变
    Print1(b);
    Print2(&b);