操作符详解

1. 操作符分类：

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

2. 算术操作符

+ - * /%

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。

2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。

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

3. 移位操作符

<< 左移操作符

>> 右移操作符

注：移位操作符的操作数只能是整数。

操作的是二进制位

整数的二进制有3种形式：
原码

反码

补码

正整数的原反补都相同

负整数的原反补是要计算的

整数在内存中存的是补码的二进制序列

int main()
{
    int a = 5;
    int b = a << 1;
    //0000 0000 0000 0000 0000 0000 0000 0101

    //0000 0000 0000 0000 0000 0000 0000 1010
    printf("%d\n", b);
    return 0;
}

3.1 左移操作符

左移：左边丢弃，右边补0

如果是-10：

int main()
{
    int a = -5;
    int b = a << 1;
    //1000 0000 0000 0000 0000 0000 0000 0101(原码）
    //1111 1111 1111 1111 1111 1111 1111 1010（反码）
    //1111 1111 1111 1111 1111 1111 1111 1011（补码）
    //左移：
    //1111 1111 1111 1111 1111 1111 1111 0110（补码）
    //1111 1111 1111 1111 1111 1111 1111 0101（反码）
    //1000 0000 0000 0000 0000 0000 0000 1010（原码）
    //打印原码：-10
    printf("%d\n", b);
    return 0;
}

补码储存（被操作）

原码打印

 3.2 右移操作符

移位规则：

首先右移运算分两种：

1. 逻辑移位

左边用0填充，右边丢弃

2. 算术移位

左边用原该值的符号位填充，右边丢弃

int main()
{
    int a = -5;
    //1000 0000 0000 0000 0000 0000 0000 0101(原码）
    //1111 1111 1111 1111 1111 1111 1111 1010（反码）
    //1111 1111 1111 1111 1111 1111 1111 1011（补码）
    int b = a >> 1;
    // 111 1111 1111 1111 1111 1111 1111 1101(补码）
    // 111 1111 1111 1111 1111 1111 1111 1100（反码）
    // 000 0000 0000 0000 0000 0000 0000 0011（原码）
    //有两种方式补原来的位：1.逻辑右移（直接补0）2.算术右移（补原来的符号位）
    printf("%d\n", b);
    return 0;
}

用vs编译器可以看出我们采用的是算术右移，至于到底采用哪种右移取决于编译器。 

注：对于移位运算符，不要移动负数位，这个是标准未定义的

int num = 10;

num>>-1;//error

4. 位操作符

位操作符有

& //按（2进制)位与

| //按(2进制）位或

^ //按（2进制）位异或

注：他们的操作数必须是整数

int main()
{
    int a = 3;
    int b = -5;
    int c = a & b;
    int d = a | b;
    int e = a ^ b;
    //a:
    //0000 0000 0000 0000 0000 0000 0000 0011
    //b:
    //1000 0000 0000 0000 0000 0000 0000 0101(原码）
    //1111 1111 1111 1111 1111 1111 1111 1010(反码）
    //1111 1111 1111 1111 1111 1111 1111 1011（补码）
 //a&b0000 0000 0000 0000 0000 0000 0000 0011(按位与：都是1的话才行）
 //这里的符号位是0，证明是整数，原反补相同，则打印出来是3
 //a|b1111 1111 1111 1111 1111 1111 1111 1011(按位或：只要有1就是1，都是0才算0）
//这里符号位是1，打印的是原码：
    //1111 1111 1111 1111 1111 1111 1111 1010（反码）
    //1000 0000 0000 0000 0000 0000 0000 0101（原码）
    //则打印出的是-5
    //a^b
    //异或：对应的二进制位：相同为0，相异为1 
    //1111 1111 1111 1111 1111 1111 1111 1000(补码）
    //1111 1111 1111 1111 1111 1111 1111 0111（反码）
    //1000 0000 0000 0000 0000 0000 0000 1000（原码）
    //由此分析是-8
    printf("%d\n", c);
    printf("%d\n", d);
    printf("%d\n", e);
    return 0;
}

不能创建临时变量（第三个变量），实现两个数的交换

#include <stdio.h>
int main()
{
    int a = 10;
    int b = 20;

  //a = a + b;
  //b = a - b;
  //a = a - b;

  //（这里a跟b如果是两个很大的数字，他们的和如果超过了整型int就会发生数据丢失，无法计算）
    a = a ^ b;
    b = a ^ b;
    a = a ^ b；
    printf("a = %d b = %d\n", a, b);
    return 0;

}

编写代码实现：求一个整数存储在内存中的二进制中1的个数。

//思路：拿5举例子：
//5：0000 0000 0000 0000 0000 0000 0000 0101
//如何拿到二进制位呢？
//给它按位异或一个1
//5^1
//1：0000 0000 0000 0000 0000 0000 0000 0001
//得到：0000 0000 0000 0000 0000 0000 0000 0001
//之后使用右移操作符，每次去除最后一位，循环32次，就拿到了每个位
int main()
{
    int num = 0;
    scanf("%d", &num);
    int i = 0;
    int count = 0;
    for (i = 0; i < 32; i++)
    {
        if (1 == ((num >> i) & 1))//num每次都没变化，第一次移0位第二次移动1位，
        {
            count++;
        }
    }
    printf("%d\n", count);
    return 0;
}

 5. 赋值操作符

它可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。

赋值操作符可以连续使用，比如：

int a = 10;

int x = 0;

int y = 20;

a = x = y+1;//连续赋值

x=y+1=21；

a=21；

复合赋值符

+=

-=

*=

/=

%=

>>=

<<=

&=

|=

^=

这些运算符都可以写成复合的效果

int x = 10;

x = x+10;

x += 10;//复合赋值

//其他运算符一样的道理。这样写更加简洁。

6. 单目操作符

6.1 单目操作符介绍

!           逻辑反操作

-           负值

+           正值

&           取地址

sizeof      操作数的类型长度（以字节为单位）

//sizeof是一个操作符不是一个函数

//计算类型创建的变量所占内存的大小，单位是字节

~           对一个数的二进制按位取反

--          前置、后置--

++          前置、后置++

*           间接访问操作符(解引用操作符)

(类型)       强制类型转换

int main()
{
    int a = 10;
    short s = 0;
    printf("%d\n", sizeof(s = a + 2));
    printf("%d\n", s);
    return 0;
}

 sizeof（）中的表达式不参与计算，因为sizeof是在编译期间处理的，不会到可执行程序。就已经把表达式变成2，s=a+2想运行得到了程序运行期间才可以，那会儿sizeof的表达式已经不存在被数字替换了，所以就无法计算。这里把int跟强制转化为short，我们知道short是两个字节，short里面的表达式不计算，就是2.

void test1(int arr[])//这里本质上是int*arr[]是个整型指针四个字节
{
    printf("%d\n", sizeof(arr));//(2)
}
void test2(char ch[])//char也是char*也是四个字节
{
    printf("%d\n", sizeof(ch));//(4)
}
int main()
{
    int arr[10] = { 0 };
    char ch[10] = { 0 };
    printf("%d\n", sizeof(arr));//(1)
    printf("%d\n", sizeof(ch));//(3)
    test1(arr);
    test2(ch);
    return 0;
}
//（1）、（2）两个地方分别输出多少？
//（3）、（4）两个地方分别输出多少？

bool类型：

 

 ~：对一个二进制位按位取反

 

为什么while（~scanf（"%d",&n)可以终止循环？
while（scanf（"%d",&n）！=EOF）
{
    //……
}
scanf在读取失败的时候会返回一个EOF（-1）
这时给它按位取反就得到0，对于while来说while（0）就是终止循环 

//++和--运算符

//前置++和--

int main()

{  

    int a = 10;  

    int x = ++a;

//先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
int y = --a;
//先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
return 0;
}

//后置++和--
#include <stdio.h>
int main()
{
    int a = 10;
    int x = a++;
    //先对a先使用，再增加，这样x的值是10；之后a变成11；
    int y = a--;
    //先对a先使用，再自减，这样y的值是11；之后a变成10；
    return 0;
}
(类型)       强制类型转换

不推荐使用，容易出现数据丢失。

7. 关系操作符

>

>=

<

<=

!=   用于测试“不相等”

==      用于测试“相等

这里唯一要注意的是两个字符串是不能判断相等不相等

这里两个字符串是a b c d e\0跟a b b q \0进行比较a跟a的地址，这里就没有可比性。

strcmp--是专门用来比较字符串的大小

对应位置上的字符大小，不是比较长度。直到下一个谁的大就是比谁大。

就像abcf跟abdc比较，前两个一样，第三个d大就第二个字符串大

 8. 逻辑操作符

&&     逻辑与

||          逻辑或

区分逻辑与和按位与

区分逻辑或和按位或

1&2----->0

1&&2---->1

1|2----->3

1||2---->1

逻辑与我们只关心它的真假，不关心二进制位

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);
    return 0;
}
//程序输出的结果是什么？

对于并且操作符来说，左边如果为假，后面直接就不算了

对于或操作符来说，左边为真，后面也不执行了。

这里只是a++执行了

所以输出了1234

 9. 条件操作符

exp1 ? exp2 : exp3

if (a > 5)        

b = 3;

else        

b = -3; 转换成条件表达式，

a>5?3:-3;

10. 逗号表达式

exp1, exp2, exp3, …expN

逗号表达式，就是用逗号隔开的多个表达式。

逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

int a = 1;

int b = 2;

int c = (a>b, a=b+10, a, b=a+1);//a>b或者a<b这里不对ab的值产生影响，之后a=13，b=13；

//逗号表达式 c是多少？

c=13

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

1. [ ] 下标引用操作符

操作数：一个数组名 + 一个索引值

int arr[10];//创建数组

arr[9] = 10;//实用下标引用操作符。

[ ]的两个操作数是arr和9。

数组是连续存放的，数组名是数组首元素地址

以上这个例子更能证明【】是一个操作符 

2. ( ) 函数调用操作符

接受一个或者多个操作数：int add(int x, int y)
{
    return x + y;
}
int main()
{
    int ret=add(2, 3);//()函数调用操作符，操作数是：add，2，3；
    printf("%d\n", ret);
    return 0;
}第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

3. 访问一个结构的成员

.     结构体.成员名

->    结构体指针->成员名
 

struct stu
{
    char name[20];
    int age;
    float score;
};
void print(struct stu ss)
{
    printf("%s\n", ss.name);
    printf("%d\n", ss.age);
    printf("%.1f\n", ss.score);
}
int main()
{
    struct stu s = { "heidashuai",20,90.0 };
    print(s);
    return 0;
}

struct stu
{
    char name[20];
    int age;
    float score;
};
void print1(struct stu ss)
{
    printf("%s\n", ss.name);
    printf("%d\n", ss.age);
    printf("%.1f\n", ss.score);
}
void print2(struct stu * ps)
{
    printf("%s\n", ps->name);
    printf("%d\n", ps->age);
    printf("%.1f\n", ps->score);
    printf("%s\n", (*ps).name);
    printf("%d\n", (*ps).age);
    printf("%.1f\n", (*ps).score);
}
int main()
{
    struct stu s = { "heidashuai",20,90.0 };

//print(s);
    //print2(&s);
    //如果想把里面的名字改掉，不能这样写，这是一个字符串这样写相当于3=5，逻辑错误
    //s.name = "haha";//error
    //应该使用字符串拷贝
    strcpy(s.name, "haha");
    //用scanf直接输入也可以
    //scanf("%s", s.name);//数组名本来就是首元素地址；
    //print(s);
    print2(&s);
    return 0;
}

12. 表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型

12.1 隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型 提升

整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度 一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长 度。

通用CPU（general-purpose CPU）是难以直接实现两个8bit字节直接相加运算（虽然机器指令 中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转 换为int或unsigned int，然后才能送入CPU去执行运算。

int main()
{
    char c1 = 3;//(int)3:0000 0000 0000 0000 0000 0000 0000 0011 
    //存入char要发生截断
    //(char)0000 0011
    char c2 = 127;//(int)127:0000 0000 0000 0000 0000 0000 0111 1111
    //发生截断
    //(char)0111 1111
    //两个都是正数，原反补相同
    char c3 = c1 + c2;//先变成整型再加；
    //如何进行整体提升呢？
    //整形提升是按照变量的数据类型的符号位来提升的
    //c1：0000 0000 0000 0000 0000 0000 0000 0011
    //c2：0000 0000 0000 0000 0000 0000 0111 1111
    //c3：0000 0000 0000 0000 0000 0000 1000 0010
    //c3是char放进去要截断
    //1000 0010-负数
    // 要打印成%d，整型提升
    // 1111 1111 1111 1111 1111 1111 1000 0010（内存中存的补码）
    // 1111 1111 1111 1111 1111 1111 1000 0001（反码）
    // 1000 0000 0000 0000 0000 0000 0111 1110（原码）打印：-126
    printf("%d\n", c3);
    return 0;
}

整形提升的例子:

int main()
{
    char c = 1;//0000 0001
    printf("%u\n", sizeof(c));//这里是c的大小是1
    printf("%u\n", sizeof(+c));//+c就是开始计算了，要整型提升了 变成int 结果是4
    printf("%u\n", sizeof(-c));//这个跟上面相同变成int 答案是4
    return 0;
}

 以上是数据类型小于整型的时候会发生整型提升

如果大于整型的时候会发生算术转换

12.2 算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类 型，否则操作就无法进行。下面的层次体系称为 寻常算术转换

long double
double
float
unsigned long int
long int
unsigned int
int
这些是向上转换的

但是算术转换要合理，要不然会有一些潜在的问题

float f = 3.14; int num = f;//隐式转换，会有精度丢失

12.3 操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。 操作符优先级。

没必要刻意记住所有的表达式顺序，计算的时候可以加括号。

如果我们写的代码无法确定唯一计算路径的时候，这个代码就被认为是错误代码

例如：c+--c

如果c=2；我们知道--先于＋，但是如果--c之后跟c的优先级？

2+1/1+1两个结果