【C】操作符详解

1. 操作符分类：

算术操作符 移位操作符 位操作符 赋值操作符 单目操作符 关系操作符 逻辑操作符 条件操作符 逗号表达式 下标引用、函数调用和结构成员

2. 算术操作符

+   -   *    /   %

下表显示了 C 语言支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

3. 移位操作符

左移操作符 << 右移操作符 >>

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

位移操作符移动的是二进制

为了跟好地进行位移操作符的讲解，这里我们需要对进制有初步的了解

关于移位操作符，需要认识源码，反码，补码，从而对移位操作进行深度理解：

3.1 左移操作符

移位规则：左边抛弃、右边补0

3.2 右移操作符

移位规则：首先右移运算分两种：

1. 逻辑移位左边用0填充，右边丢弃
2. 算术移位左边用原该值的符号位填充，右边丢弃

具体采用哪种移位，取决于编译器，一般编译器采用算数移位

警告⚠ ： 对于移位运算符，不要移动负数位，这个是标准未定义的。 例如

int num = 10;
num>>-1;//error

4. 位操作符

注：1.为操作符的操作数必须是整数。2.位操作符作用于二进制数列

位操作符	名称	作用
&	按位与	有0则0，同1则1
|	按位或	有1则1
^	按位异或	相同为0，相异为1

按位与示例：

按位或示例：

按位异或示例：

一道变态的面试题：

不能创建临时变量（第三个变量），实现两个数的交换一种巧妙的算法

如上算法存在缺陷，a+b若太大会溢出，下面让我们使用异或操作符来实现： 需要用到： 1.相同为0，0与任何数异或结果都为这个数 2.异或支持交换律

//3^3 = 0
//5^5=0
//3^5=6
//3^5^5=3
//3^5^3=5
//
//000
//011
//011 
//011
//101
//110
//a^a=0
//0^a=a
//异或是支持交换律
//3^5^3
//3^3^5
//
int main()
{
  int a = 3;
  int b = 5;

  a = a ^ b;
  b = a ^ b;//b=a ^ b ^ b
  a = a ^ b;//a^b^a

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

  printf("a=%d b=%d\n", a, b);

  return 0;
}

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

//方法1

#include <stdio.h>
int count_bit( int m)
{
  int count = 0;
  while (m)
  {
    if (m % 2 == 1)
      count++;
    m /= 2;
  }
  return count;
}
int main() {
  int n = 0;
  scanf("%d", &n);
  int num = count_bit(n);
  printf("%d\n", num);
  return 0;
}

这种方法明显是有错误的，如果输入的是负数，无法输出正确的值，因此我们可以联想到无符号

int count_bit(unsigned int m)

若将上述函数的自定义声明改为这个，则可以避免上述问题的出现。接下来我们运用操作符实现这个程序：

//方法2：
#include <stdio.h>
int count_bit(n) 
{
  int i = 0;
  int count = 0;
  for (i = 0; i < 32; i++)
  {
    if (1 == ((n >> i) & 1))
      count++;
  }
  return count;
}
int main() 
{
  int n = 0;
  scanf("%d", &n);
  int num = count_bit(n);
  printf("%d\n", num);
  return 0;
}

还能不能更加优化，上述两种方式都必须循环32次。//方法3：

int count_bit(int m)
{
  int count = 0;
  while (m)
  {
    m = m & (m - 1);
    count++;
  }
  return count;
}
int main() {
  int n = 0;
  scanf("%d", &n);
  int num = count_bit(n);
  printf("%d\n", num);
  return 0;
}
//n=11
//n = n&(n-1)
//1011 - n
//1010 - n-1
//1010 - n
//1001 - n-1
//1000 - n
//0111 - n-1
//0000 - n
//根据上述规律可知，有几个n&(n-1)就有多少个1

这种方式很好，达到了优化的效果，但是难以想到。

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;
  char c = 0;
//  printf("%p\n", &a);//取出地是二进制数列
//  printf("%p\n", &c);

  int* pa = &a;//& - 取地址操作符  pa是指针变量  int*是类型
  //*pa = 20;//* - 解引用操作符    把a拿出来进行赋值
  *pa = 20;

  return 0;
}

• sizeof操作符举例

int main()
{
  short s = 10;
  int a = 2;
  s = a + 5;

  printf("%zu\n", sizeof(s = a + 5));//输出结果为2，sizeof（）内部放的表达式不会计算

  printf("%d\n", s);//，输出结果为10


  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;
}

:star: 这里需要注意的是sizeof（数组名）是指数组整体的类型长度，而不是数组首元素的类型长度，sizeof（）内部放的表达式不会计算。

• 原理： 在文件转向可执行程序的时候在编译阶段，编译器就进行了判断，进行了截断把后面括号中两个字节的内容给了short类型

• ~按位取反操作符
• 代码与原理展示：

int main()
{
  int a = 0;
  /*00000000000000000000000000000000 - ~按位取反
  11111111111111111111111111111111 - 内存中-补码
  11111111111111111111111111111110 -反码（补码减1）
  10000000000000000000000000000001 -源码（反码符号位不变其他位按位取反）

  -1*/

  printf("%d\n", ~a);

  return 0;
}

上面的内容仅仅是铺垫，相信看完下面的内容你会对~（按位取反操作符）有更加深入的了解

int main()
{
  int a = 10;
  int n = 0;
  scanf("%d", &n);
  //把a的第n位置为1
  a = a | (1 << (n-1));
  printf("a=%d\n", a);

  //把a的第n位置为0
  a = a & ~(1 << (n - 1));
  printf("a=%d\n", a);

  //00000000000000000000000000001010
  //00000000000000000000000000010000
  //1<<2;
  //00000000000000000000000000011010
  //11111111111111111111111111101111
  //00000000000000000000000000010000
  //00000000000000000000000000001010
  return 0;
}

6.2 sizeof 和 数组

#include <stdio.h>
void test1(int arr[]) {
  printf("%d\n", sizeof(arr));//(结果4)
}
void test2(char ch[]) {
  printf("%d\n", sizeof(ch));//(结果4)
}
int main() {
  int arr[10] = { 0 };
  char ch[10] = { 0 };
  printf("%d\n", sizeof(arr));//(结果40)
  printf("%d\n", sizeof(ch));//(结果10)
  test1(arr);
  test2(ch);
  return 0;
}

参阅了如上代码是否有所疑惑，且看详解：

• ++ - -运算符关于++和--运算符，前面的文章中提到过，但下面的图片也是一目了然若图片看不太懂，还有代码供参考:smirk:

//++和--运算符
//前置++和--
#include <stdio.h>
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; }

• 强制类型转换如图，当我们将一个小数想要赋值给int型的变量时，编译器会报错，这里就需要用到强制类型转换，下面的代码中我们就运用了强制类型转换，只要认真观察区别，就可以学会

int main()
{
  int a = (int)3.14;
  printf("%d\n", a);

  return 0;
}

这里输出的值自然为整数3

7. 关系操作符

关系操作符\>\>=<

<= != 用于测试“不相等” == 用于测试“相等”

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

如图，如果因为少写了等号=，如果常量放在后面，编译器会认为是赋值语句而不报错，但常量放在前面，少写了等号，编译器必然会报错。因此，在判断变量和常量是否相等时建议使用 if(10==a);这种写法。

int main(){char arr[] = "abcdef"; \不能比较2个字符串的内容，实际上比较的是2个字符串的首字符的地址,所以这样写是错误的 if (arr \ "abcdef"){printf("\==\n");}return 0; }

8. 逻辑操作符

逻辑操作符有哪些：

&& 逻辑与|| 逻辑或

区分逻辑与和按位与区分逻辑或和按位或

1&2----->0
1&&2---->1
1|2----->3
1||2---->1

逻辑与和或的特点：若逻辑或运算符左边操作数的值为1，则就不继续执行其右边的操作数。"&&" 同理，若左边的操作数为0，则就不继续执行其右边的操作数

int main()
{
int a = 3;
int b = 0;
  if (a && b)  //这里的&&仅仅判断真假，如果两边都是真，则继续执行，非0即为真
  //if (a || b) //同样的，有真则为真
  {
  printf("呵呵\n");
  }
  return 0 ;
}

int main()
{
  int age = 20;
  18~36 青年
  if (age >= 18 && age <= 36)
  {
    printf("青年\n");
  }

int main()
{
  int year = 2000;
  if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
  printf("闰年");//这里的&&是并且的意思  ||是或的意思


  return 0;
}

360笔试题

#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);
    return 0;
   }

//程序输出的结果是什么？因为a++先使用a的值，a==0，&&只要有a就为假，所以后面不会运行，自然值也不变，而a最后还要++，所以运行结果如下

这里有几个变式，如果可以都计算正确，说明该知识点已经掌握，如果没有，则需要认真思考

输出结果为2335；

运行结果为2234，因为a是1，||后面不管是几都为真，所以后面不计算直接跳过，而a还要++

结果为1334

9. 条件操作符

exp1 ? exp2 : exp3

int main()
{
  int a = 3;
  int b = 0;
  if (a > 5)
    b = 3;
  else
    b = -3;
  return 0;
}

转换成条件表达式，是什么样？

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

2.使用条件表达式实现找两个数中较大值。

int m = (a > b ? a : b);

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)
//代码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)
{
//业务处理
}

通过如上代码，我们可以看出，代码3中，相对于用while循环写出的代码，用逗号表达式写出来的代码更加简洁。

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

• 1. [ ] 下标引用操作符 注意：[ ]不是定义数组时的操作符，而是在要访问数组的第某个元素时所使用的操作符 arr[4];访问数组的第5个元素， 这里的[ ]就交下标引用操作符， 操作数是arr和4 操作数：一个数组名 + 一个索引值
• 2. ( ) 函数调用操作符 接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

void test(int x, int y)
{

}
void test2()
{}

int main()
{
  test2();
  //操作数：test2
  test(3, 4);//()函数调用操作符
  //操作数：test,3,4
  return 0;
}

• 3. 访问一个结构的成员

. 结构体.成员名-> 结构体指针->成员名//结构体成员//书：书名 + 定价

代码演示：

struct Book
{
  char name[20];
  int price;
};

int main() {
  struct Book sb = { "C语言", 55 };

  printf("%s %d\n", sb.name, sb.price);//结构体变量.结构体成员名

  struct Book* ps = &sb;
  printf("%s %d\n", (*ps).name, (*ps).price);//ps指向sb，*ps找到sb
  printf("%s %d\n", ps->name, ps->price);//结构体指针->结构体成员名
//->name找到了ps所指向的对象sb的name
  return 0;
}

运行结果：

12. 表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

12.1 隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长 度。通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转 换为int或unsigned int，然后才能送入CPU去执行运算。

如何进行整体提升呢？

整形提升是按照变量的数据类型的符号位来提升的//负数的整形提升char c1 = -1;变量c1的二进制位(补码)中只有8个比特位：1111111因为 char 为有符号的 char 所以整形提升的时候，高位补充符号位，即为1 提升之后的结果是： 11111111111111111111111111111111 //正数的整形提升 char c2 = 1; 变量c2的二进制位(补码)中只有8个比特位： 00000001 因为 char 为有符号的 char 所以整形提升的时候，高位补充符号位，即为0 提升之后的结果是： 00000000000000000000000000000001 //无符号整形提升，高位补0

//实例1
int main()
{
  char a = 5;
  char b = 126;
  char c = a + b;

  printf("%d\n", c);

  return 0;
}

b和c的值被提升为普通整型，然后再执行加法运算。加法运算完成之后，结果将被截断，然后再存储于a中。 整形提升是按照变量的数据类型的符号位来提升的 那么上面代码的结果是不是131呢？接下来让我们来细细分析一番： :star:例1:

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;
}

配图解

:star:例2:

int main()
{
  char a = 0xb6;
  //10110110
  //
  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整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表达式 c==0xb6000000 的结果是真.

需要注意的是无符号整型提升，高位直接补0

:star:例3:

int main()
{
char c = 1;
printf("%u\n", sizeof(c));
printf("%u\n", sizeof(+c));
printf("%u\n", sizeof(-c));
return 0;
}

实例3中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字节.表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof(c) ,就是1个字节

12.2 算术转换

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

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运 算。 警告： 但是算术转换要合理，要不然会有一些潜在的问题

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

12.3 操作符的属性

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

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。操作符优先级

一些问题表达式

//表达式的求值部分由操作符的优先级决定。//表达式1ab + cd + e*f

注释：代码1在计算的时候，由于*比+的优先级高，只能保证，的计算是比+早，但是优先级并不能决定第三个比第一个+早执行。

所以表达式的计算机顺序就可能是：abcdab + cdefab + cd + ef或者：abcdefab + cdab + cd + ef

//表达式2c + --c;

注释：同上，操作符的优先级只能决定自减--的运算在+的运算的前面，但是我们并没有办法得知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。

//代码3-非法表达式int main(){int i = 10;i = i-- - --i * ( i = -3 ) * i++ + ++i;printf("i = %d\n", i);return 0; }

表达式3在不同编译器中测试结果不同

//代码4
int fun()
{
     static int count = 1;
     return ++count;
}
int main()
{
     int answer;
     answer = fun() - fun() * fun();
     printf( "%d\n", answer);//输出多少？
     return 0;
}

这个代码有没有实际的问题？有问题！虽然在大多数的编译器上求得结果都是相同的。但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。函数fun（）的调用先后顺序无法通过操作符的优先级确定。

//代码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环境的结果：

VS2013环境的结果：

看看同样的代码产生了不同的结果，这是为什么？ 简单看一下汇编代码.就可以分析清楚.这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。 总结： 我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

希望以上内容对大家有所帮助:eyes:，如有不足望指出:pray: