C语言——操作符大全

C语言中的操作符整理

（一）算术操作符

（+）（-）（*）（/）（%）
（1）%操作符的两个操作数必须为整数，返回整除之后的余数，余数也为整数。
（2）除%以外的运算符的操作数都可以是任何算术类型。
（3）对于/操作符，两个实数相除的结果是双精度实数，两个整数相除的结果是整数。
（二）关系操作符——6种

1____> (大于）
2____>=（大于等于）
3____<（小于）
4____<=（小于等于）
5____==（等于）
6____!=（不等于）
优先级比较：
前四个(>,>=,<,<=)的优先级相同，后两个的优先级相同，但前者比后者优先级高。
关系操作符的应用——关系表达式

·表达式的值是逻辑值，非真即假——0为假，非0为真。
注意！！！不要将 == （等于符号）和 = （赋值操作符）写错。

（三）位操作符

应用二进制的思想理解，数值在内存中以二进制补码的形式存在。
正数的补码为原码，负数的补码为：符号位不变，原码取反加一。

&（按位与）——全1为1，否则为0
|（按位或)——有1为1，否则为0
^（按位异或）——相同为0，不同为1
注意：位操作符的操作数都为整数。

举例代码如下：

 int a = 1;
 int b = 2;
 int c = a & b;
 int d = a | b;
 int e = a ^ b;
 printf("c = %d\nd = %d\ne = %d\n", c, d, e);
 
   //        a——00000000000000000000000000000001
   //        b——00000000000000000000000000000010
   //c = a & b——00000000000000000000000000000000——0
   //d = a | b——00000000000000000000000000000011——3 
   //e = a ^ b——00000000000000000000000000000011——3

运行结果如下：

（四）移位操作符

应用二进制的思想理解，数值在内存中以二进制补码的形式存在。
正数的补码为原码，负数的补码为：符号位不变，原码取反加一。
（<<） 左移操作符
（>>) 右移操作符

！！！

注意：移位数不能为负数。

（1）左移操作符
移位规则：左边抛弃，右边补0

 int a = 10;
 int b = a << 1;
 printf("a = %d\nb = %d\n", a, b);
 
 //     00000000000000000000000000001010--a在内存中的二进制
 //  (0)00000000000000000000000000010100--a左移一位产生的结果，
 //左移出去的0抛弃

运算结果如下：

实际上，a没有被赋值，自身的值不会变化。
（2）右移操作符
移位规则：
右移运算符分为两种：
1，逻辑移位：左边补0，右边抛弃
2，算术移位：左边用原该值的符号位填充 ，右边丢弃。

举例代码如下：

 int a = -1;
 int b = a >> 1;
 printf("a = %d\nb = %d\n", a, b);
 //  -1原码——10000000000000000000000000000001
 //  -1补码——11111111111111111111111111111111
  //逻辑右移——01111111111111111111111111111111（1）
         //——右边抛弃，左边补0
  //算术右移——11111111111111111111111111111111（1）
           ——左边用原该值的符号位填充，右边抛弃

在VS编译器下运行结果为：
为算术右移

（五）赋值操作符

（ = )
复合赋值符：

（+=）
（-=）
（*=）
（/=）
（%=）
(>>=)
(<<=)
(&=)
(|=)
(^=)
举例代码如下：

 int a = 2;
//下面两行代码所表示的意义一样
 a = a + 1;     //a = 3
 a += 1;           //a = 3

（六）逻辑操作符

1.&& (逻辑与）——a && b（如果a，b都为真，则结果为真）
2.||（逻辑或）——a|| b（只要有一个以上为真，则为真，否则为假）
3.！（逻辑非）——！a

优先级比较：

！ 的优先级高于 && 和 ||
逻辑操作符的应用——逻辑表达式

·表达式的值有真假——0为假，非0为真
举例代码如下：

int a = 3;
int b = 6;
int c = 0;
a && b;
//3 && 6---1
a && b && c;
//3 && 6 && 0---0
a || b;
//3 || 6---1
a || b || c;
//3 || 6 || 0---0

注意： 在逻辑表达式的求解中 ，并不是所有的逻辑运算符都被执行！！！
只是在必须执行下一个逻辑运算符才能求出表达式的解时，才执行该运算符。

（1）在逻辑与（&&）的表达式求解中，从左到右依次求解，遇 0 则停。后面的逻辑运算符不执行。
（2）在逻辑或（||）的表达式求解中，从左到右依次求解，遇 1 则停。后面的逻辑运算符不执行。
举例代码如下：
逻辑与（&&）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a = 3;
int b = 6;
int c = 0;

//执行下面一句代码时，先执行c = 0，先用c参与逻辑表达式的计算，结果为假
//则后面的逻辑运算符都不用求解，再执行c++,则c=1，a=3，b=6
int i = c++ && ++a && ++ b;
printf("c = %d\na = %d\nb = %d\n", c, a, b);
system("pause");
return 0;
}

运行结果如图：

逻辑或（||）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a = 3;
int b = 6;
int c = 0;

//执行下面一句代码时，先执行c = 0，结果为假，逻辑表达式可以继续求解，再执行
//c++,然后执行++a，a = 4，结果为真，则后面的逻辑运算符不求解
int i = c++ || ++a || ++ b;
printf("c = %d\na = %d\nb = %d\n", c, a, b);
system("pause");
return 0;
}

运行结果如图：

（七）条件操作符

条件表达式的一般形式：表达式1 ？ 表达式2：表达式3
举例代码如下：

int a = 3;
int b = 6;
int c = 0;
c = a > b ? a : b;
//a > b 为表达式1，a为表达式2，b为表达式3
//该语句的意思为：如果a>b,则将a的值赋给c，否则将b的值赋给c

以上语句等价于下面的if…else语句

int a = 3;
int b = 6;
int c = 0;
if (a > b)
{
c = a;
}
else
{
c = b;
}

（八）单目操作符

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

（1）++，-- 操作符

前置：如++ i,-- i,在使用i之前，先使i 的值加，减1
后置：如i++，i–，先使用i，使用完之后，使i的值加，减1
简单代码举例：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int a = 1;
 int b = 2;
 int a1 = a++;        //a1 = 1，a = 2
 int a2 = ++a;        //a2 = 3，a = 3
 int b1 = b--;          //b1 = 2，b = 1
 int b2 = --b;          //b2 = 0，b = 0
 printf("a1 = %d\na2 = %d\nb1 = %d\nb2 = %d\n", a1,a2,b1,b2);
 system("pause");
 return 0;
}

运行结果如下：

（2）（类型）操作符——强制类型转换符

（类型名）（表达式）
表达式和类型名都应该用括号括起来
例如：
(double)a——（将a转换成double类型）
（int）（x+y）——（将x+y的值转换成int型）
（float）（5%4）——（将5%3的值转换成float型）
（3）sizeof

• sizeof可以求变量（类型）所占空间的大小。

• sizeof 不是函数，是操作符。

• sizeof后面是变量的话，后面的括号可省略；如果后面是类型，则括号不可省略。
  具体代码如下：

 int a = 10;
 printf("%d\n", sizeof(a));
 printf("%d\n", sizeof(int));
  printf("%d\n", sizeof a);

运行结果如下：

 int a = 10;
 printf("%d\n", sizeof int);

• sizeof后面的表达式不参与运算
  举例代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int a = 10;
 short b = 5;
 
 printf("%d\n", sizeof(b = a + 2));
//sizeof后的表达式不参与运算，因此此处只计算b的大小，且不执行a+2

 printf("b = %d\n", b);
 printf("a = %d\n", a);
 system("pause");
 return 0;
}

运行结果如下：

• sizeof和数组

在主函数中，sizeof可计算数组的大小，但如果数组作为参数，传入被调用函数，则sizeof计算的不是数组大小
在被调用函数中：sizeof（数组名）都为4
代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.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);

运行结果如下：

（九）逗号表达式

逗号表达式就是用逗号隔开的多个表达式。
逗号表达式从左到右依次执行。整个表达式的结果是最后一个表达式的结果。
举例代码如下：

 int a = 1;
 int b = 2;
 
 int c = (a > b, a = b + 10, a, b = a + 1);
//a>b为假，表达式值为0
//a=b+10-----a=2+10=12
//a=12
//b=a+1------b=12+1=13
//c=13

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

运行结果为：

（十）下标引用，函数调用和结构成员

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

int arr[10];   //创建数组
arr[8] = 2;  //下标引用

//[ ]的两个操作数为arr 和 8

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

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void test1(int arr[])
{
 printf("%d\n", sizeof(arr));
}
void test2(char ch[])
{
 printf("%d\n", sizeof(ch));
}
int main()
{
 int arr[10] = { 0 };
 char ch[10] = { 0 };
 printf("%d\n", sizeof(arr));
 printf("%d\n", sizeof(ch));
 test1(arr);//——————————使用（）作为函数调用操作符
 test2(ch);//——————————使用（）作为函数调用操作符
system("pause");
 return 0;
}

（3）访问一个结构的成员
结构名.成员名
（十一）左值 和 右值

左值——可以改变。变量可以作左值，算术表达式，常量不能作左值
右值——左值可以作为右值