文章目录
运算符是一种告诉编译器执行特定的数字或逻辑操作的符号。C语言内设置了丰富的运算符，并提供了以下类型的运算符：
一.算数运算符
下表显示了 C 语言支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 把两个操作数相加 | A + B 将得到 30 |
| - | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
| * | 把两个操作数相乘 | A * B 将得到 200 |
| / | 分子除以分母 | B / A 将得到 2 |
| % | 取模运算符，整除后的余数 | B % A 将得到 0 |
| ++ | 自增运算符，整数值增加 1 | A++ 将得到 11 |
| – | 自减运算符，整数值减少 1 | A-- 将得到 9 |
实例
请看下面的实例，了解 C 语言中所有可用的算术运算符：
#include <stdio.h>
int main()
{
int a = 21;
int b = 10;
int c ;
c = a + b;
printf("Line 1 - c 的值是 %d\n", c );
c = a - b;
printf("Line 2 - c 的值是 %d\n", c );
c = a * b;
printf("Line 3 - c 的值是 %d\n", c );
c = a / b;
printf("Line 4 - c 的值是 %d\n", c );
c = a % b;
printf("Line 5 - c 的值是 %d\n", c );
c = a++; // 赋值后再加 1 ，c 为 21，a 为 22
printf("Line 6 - c 的值是 %d\n", c );
c = a--; // 赋值后再减 1 ，c 为 22 ，a 为 21
printf("Line 7 - c 的值是 %d\n", c );
}
//执行结果：Line 1 - c 的值是 31
//Line 2 - c 的值是 11
//Line 3 - c 的值是 210
//Line 4 - c 的值是 2
//Line 5 - c 的值是 1
//Line 6 - c 的值是 21
//Line 7 - c 的值是 22
- ++自增自减运算符
a++与++a都属于自增运算符，区别是对变量a的值进行自增的时机不同。
- a++是先进行取值，后进行自增
- ++a是先进行自增，后进行取值
eg1.
int i=10;
i=i++;
printf("%d",i);//输出为10
int i=10;
i++;
printf("%d",i);//输出为11
int i=10;
i=++i;
printf("%d",i);//输出为11
int i=10;
++i;
printf("%d",i);//输出为11
eg2.设x=3 y=4
- (x++)+(++x)=8
- (x++)/3+(- -y) *2-(x- -)%6+(y++) *3-(y- -)=8
题解：
- 3+5=8
- 1+6-4+9-4=8
(age1>=18)&((workyear1++)>5) 这么长一个式子自然有着像加减乘除一样的运算顺序，后面我们会讲，其实就是运算符的优先级。
注意：++、-- 操作数只能是变量， ++(a++)是不合法的
二.关系运算符
下表显示了 C 语言支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果相等则条件为真。 | (A == B) 为假。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 | (A > B) 为假。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 | (A < B) 为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (A >= B) 为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (A <= B) 为真 |
实例
请看下面的实例，了解 C 语言中所有可用的关系运算符：
#include <stdio.h>
int main()
{
int a = 21;
int b = 10;
int c ;
if( a == b )
{
printf("Line 1 - a 等于 b\n" );
}
else
{
printf("Line 1 - a 不等于 b\n" );
}
if ( a < b )
{
printf("Line 2 - a 小于 b\n" );
}
else
{
printf("Line 2 - a 不小于 b\n" );
}
if ( a > b )
{
printf("Line 3 - a 大于 b\n" );
}
else
{
printf("Line 3 - a 不大于 b\n" );
}
/* 改变 a 和 b 的值 */
a = 5;
b = 20;
if ( a <= b )
{
printf("Line 4 - a 小于或等于 b\n" );
}
if ( b >= a )
{
printf("Line 5 - b 大于或等于 a\n" );
}
}
运行结果：
Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a
三.逻辑运算符
逻辑运算符的作用是用于连接布尔表达式的。
bool（布尔）类型只有两个值：true =1 、false=0 。C语言里面是没有bool类型的，C++里面才有。但是，C99标准里面，又定义了bool类型变量。这时，只要引入头文件 <stdbool.h>，就能在C语言里面正常使用bool类型。当然，您也可以自己定义：
#define bool char #define true 1 #define false 0
-
&（与）
规律：只有左右变量同时为true，那么结果才是true，否则就false。
-
|（或）
规律：只要左右两边的布尔表达式一边为true,那么结果就为true,只有两边同时为false的时候，结果才是false。
-
^（异或）
规律：只要两边的布尔表达式结果不一致，那么结果就为true,如果左右两边的布尔表达式一致，那么就为false.
-
！（非）
用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其结果为假；反之亦然。
-
&&（短路与，双与）
短路与和单与符号的相同与不同点：
1）相同点： 运算的结果是一样的。
2）不同点： 使用短路与的时候，如果左边的布尔表达式为false，则不会在运算右边的布尔表达式，从而提高了效率。使用单与的时候，即使发现左边的布尔表达式为false，还是会运算右边的布尔表达式的.那么有这样一个问题：单与的效率高于双与？
错，只有左边的布尔表达式为false时，双与的效率才要高于单与的。
#include<stdio.h>
int main(){
int age1=17;
int age2=17;
int workyear1=5;
int workyear2=5;
printf("是否允许员工1入职：");
bool a=(age1>=18)&((workyear1++)>5);//单与，左边式子为false，运行右面表达式
printf("%d\n",a);
printf("员工1工作时间：%d\n",workyear1);
printf("是否允许员工2入职：");
bool b=(age1>=18)&&((workyear2++)>5);//双与：左边表达式为false，不运行右边表达式
printf("%d\n",b);
printf("员工2工作时间：%d\n",workyear2);
return 0;
}
//运行结果：是否允许员工1入职：0
//员工1工作时间：6
//是否允许员工2入职：0
//员工2工作时间：5
- ||（短路或，双或）
短路或与单或的相同点与不同点：
1）相同点：运算的结果是一致的。
2）不同点：使用短路或的时候，当发现左边的布尔表达式为true时，则不会运算右边的布尔表达式。使用单或的时候发现左边的布尔表达式为true，还是会运算右边布尔表达式。
四.位运算符
在现代计算机中，所有数据都以二进制形式存储，即 0 和 1 两种状态。计算机对二进制数据进行的运算（如加、减、乘、除）被称为位运算，即对二进制数的每一位进行操作的运算。
为了更好的理解位运算，举个简单的例子：假设我们有如下代码进行两个整数的加法运算：
int a = 35;
int b = 47;
int c = a + b;
//计算机会将这两个整数转换为二进制形式，然后进行加法运算：
35: 0010 0011
47: 0010 1111
----------------
82: 0101 0010
位运算符作用于位，并逐位执行操作。&，|，^的真值表如下所示：
| p | q | p&q | p|q | p^q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
按位运算符（&）
定义：对参与运算的两个数据的二进制位进行"与"运算。
运算规则：
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1
总结：只有两位同时为1时，结果才为1，否则结果为0。
例如：3 & 5即0000 0011 & 0000 0101 = 0000 0001，因此 3 & 5` 的值为1。
注意：负数按补码形式参与按位与运算。
用途：
- 清零：如果想将一个单元清零，只要与一个各位都为零的数值相与，结果为零。
- 取一个数的指定位：例如，取数
X = 1010 1110的低4位，只需另找一个数Y = 0000 1111，然后X & Y = 0000 1110即可得到X的指定位。 - 判断奇偶：通过判断最未位是0还是1来决定奇偶，可以用
if ((a & 1) == 0)代替if (a % 2 == 0)来判断a是否为偶数。
按位运算符（|）
定义：对参与运算的两个对象的二进制位进行"或"运算。
运算规则：
0 | 0 = 0
0 | 1 = 1
1 | 0 = 1
1 | 1 = 1
总结：只要有一个为1，其值为1。
例如：3 | 5 即 0000 0011 | 0000 0101 = 0000 0111，因此 3 | 5 的值为7。
注意：负数按补码形式参与按位或运算。
用途：
- 设置某些位为1：例如，将数
X = 1010 1110的低4位设置为1，只需另找一个数Y = 0000 1111，然后X | Y = 1010 1111即可得到。
异或运算符（^）
定义：对参与运算的两个数据的二进制位进行"异或"运算。
运算规则：
0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0
总结：相应位相同为0，相异为1。
注意：如果操作数A连续异或同一个操作数两次，那么结果还是操作数A
性质：
- 交换律
- 结合律：
(a ^ b) ^ c == a ^ (b ^ c) - 对于任何数
x，都有x ^ x = 0，x ^ 0 = x - 自反性：
a ^ b ^ b = a ^ 0 = a
用途：
- 翻转指定位：例如，将数
X = 1010 1110的低4位翻转，只需另找一个数Y = 0000 1111，然后X ^ Y = 1010 0001即可得到。 - 与0相异或值不变：例如
1010 1110 ^ 0000 0000 = 1010 1110 - 交换两个数：
void Swap(int &a, int &b) {
if (a != b) {
a ^= b;
b ^= a;
a ^= b;
}
}
取反运算符（~）
定义：对参与运算的一个数据的二进制位进行"取反"运算。
运算规则：
~1 = 1111 1110
~0 = 1111 1111
即：
~1 = -2
~0 = -1
总结：将 0 变 1，1 变 0。
用途：
- 使一个数的最低位为零：例如，使
a的最低位为0，可以表示为：a & ~1。~1的值为1111 1111 1111 1110，再按"与"运算，最低位一定为0。
位运算符与逻辑运算符的区别：
用于int类型数据时，就是位运算符。用于布尔表达式时就是逻辑运算符。
练习
假设A=60，B=13.现以二进制格式表示：
A=0011 1100,B=0000 1101
则A&B=0000 1100（与）
A|B=0011 1101（或）
A^B=0011 0001（异或）
-A=1100 0011（取反）
应用
- 使用异或对图片数据进行加密。（略）
- 交换两个变量的值
int a = 3; int b = 5; //方式1：定义第三方变量。 int temp = a; //3 a = b; //a = 5 b = temp; //方式2：相加法， 缺点：两个int类型的数据相加，有可能会出现超出int的表示范围。 a = a+b; // a =8 b = a-b; //b = 8 - 5 = 3 a = a-b; // a = 8 - 3 = 5 //方式3： 可以使用异或。 缺点： 逻辑不清晰。 a = a^b; // a = 3^5 b = a^b; // b = (3^5)^5 = 3 a = a^b; // a = (3^5)^3 = 5 注意：（3^5）和（5^3）是一样的
取出一个二进制数据的指定位数。要求读取该二进制数据的低4位
00000000-00000000-00010100-01001101
& 00000000-00000000-00000000-00001111
00000000-00000000-00000000-00001101
移位运算符
| 符号 | 描述 | 运算规则 |
|---|---|---|
| - | 取反 | 0变1,1变0 |
| << | 左移 | 各二进位全部左移若干位，高位丢弃，低位补0 |
| >> | 右移 | 各二进位全部右移若干位，高位补0或符号位补齐 |
- <<（左移）
定义：将一个运算对象的各二进制位全部左移若干位，高位丢弃，低位补0。
例如，设 a = 1010 1110，a = a << 2 将 a 的二进制位左移2位、右补0，即得 a = 1011 1000。
规律：若左移时舍弃的高位不包含1，则每左移一位，相当于该数乘以2。一个操作数进行左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移的位数。
3<<1 = 3 2(1) = 6;
3<<2 = 32(2) = 12
3<<3 = 3*2(3) = 24
2.>>（右移）
定义：将一个数的各二进制位全部右移若干位，高位补0或补符号位，右边丢弃。
例如，a = a >> 2 将 a 的二进制位右移2位，左补0 或补符号位，具体取决于数的正负。
操作数每右移一位，相当于该数除以2。
规律：一个操作数在做右移运算的时候，实际上就是等于该操作数除以2的n次方，n就是右移的位数。
3>>1 = 3 / 2(1) = 1
3>>2 = 3 / 2(2) = 0
3.>>>（无符号右移）
无符号右移与右移的区别：进行右移运算的时候，如果操作数是一个正数，那么左边的空缺位使用0补，如果操作数是一个负数，那么左边的空缺位使用1补。而使用无符号右移的时候，不管是正数还是负数都统一使用0补。
没有无符号左移，原因不用解释了吧。
注意：在C语言中是没有“无符号右移”运算符的，在Java中用“>>>”表示，C语言中可以利用((unsigned int) (-3))>>2来实现 无论是正数还是负数，其无符号右移都是在其补码的基础上右移，高位补0。
#include<stdio.h> int main(){ int a=-3>>2; int b=((unsigned int) (-3))>>2;//-3>>>2 printf("%d\n",a);//输出 -1 printf("%d\n",b);//输出 1073741823 return 0; }
使用最高的效率算出2乘以8的结果。
答：2<<3 = 2*2(3) = 16; 因为只有一个操作数（2），所以效率相对较高。
五.赋值运算符
下表列出了 C 语言支持的赋值运算符：
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，把右边操作数的值赋给左边操作数 | C = A + B 将把 A + B 的值赋给 C |
| += | 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 | C += A 相当于 C = C + A |
| -= | 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 | C -= A 相当于 C = C - A |
| *= | 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 | C *= A 相当于 C = C * A |
| /= | 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 | C /= A 相当于 C = C / A |
| %= | 求模且赋值运算符，求两个操作数的模赋值给左边操作数 | C %= A 相当于 C = C % A |
| <<= | 左移且赋值运算符 | C <<= 2 等同于 C = C << 2 |
| >>= | 右移且赋值运算符 | C >>= 2 等同于 C = C >> 2 |
| &= | 按位与且赋值运算符 | C &= 2 等同于 C = C & 2 |
| ^= | 按位异或且赋值运算符 | C ^= 2 等同于 C = C ^ 2 |
| |= | 按位或且赋值运算符 | C |= 2 等同于 C = C | 2 |
实例：
请看下面的实例，了解 C 语言中所有可用的赋值运算符：
#include <stdio.h>
int main()
{
int a = 21;
int c ;
c = a;
printf("Line 1 - = 运算符实例，c 的值 = %d\n", c );
c += a;
printf("Line 2 - += 运算符实例，c 的值 = %d\n", c );
c -= a;
printf("Line 3 - -= 运算符实例，c 的值 = %d\n", c );
c *= a;
printf("Line 4 - *= 运算符实例，c 的值 = %d\n", c );
c /= a;
printf("Line 5 - /= 运算符实例，c 的值 = %d\n", c );
c = 200;
c %= a;
printf("Line 6 - %%= 运算符实例，c 的值 = %d\n", c );
c <<= 2;
printf("Line 7 - <<= 运算符实例，c 的值 = %d\n", c );
c >>= 2;
printf("Line 8 - >>= 运算符实例，c 的值 = %d\n", c );
c &= 2;
printf("Line 9 - &= 运算符实例，c 的值 = %d\n", c );
c ^= 2;
printf("Line 10 - ^= 运算符实例，c 的值 = %d\n", c );
c |= 2;
printf("Line 11 - |= 运算符实例，c 的值 = %d\n", c );
}
执行结果：
Line 1 - = 运算符实例，c 的值 = 21
Line 2 - += 运算符实例，c 的值 = 42
Line 3 - -= 运算符实例，c 的值 = 21
Line 4 - *= 运算符实例，c 的值 = 441
Line 5 - /= 运算符实例，c 的值 = 21
Line 6 - %= 运算符实例，c 的值 = 11
Line 7 - <<= 运算符实例，c 的值 = 44
Line 8 - >>= 运算符实例，c 的值 = 11
Line 9 - &= 运算符实例，c 的值 = 2
Line 10 - ^= 运算符实例，c 的值 = 0
Line 11 - |= 运算符实例，c 的值 = 2
复合赋值运算符
位运算符与赋值运算符结合，组成新的复合赋值运算符，它们是：
&=例：a &= b相当于a = a & b|=例：a |= b相当于a = a | b>>=例：a >>= b相当于a = a >> b<<=例：a <<= b相当于a = a << b^=例：a ^= b相当于a = a ^ b
运算规则与前述的复合赋值运算符的运算规则相似。
不同长度的数据进行位运算：
如果两个不同长度的数据进行位运算，系统会将二者按右端对齐，然后进行位运算。
以"与运算"为例说明如下：
在C语言中，long 型占4个字节，int 型占2个字节。如果一个 long 型数据与一个 int 型数据进行"与运算"，右端对齐后，左边不足的位按以下三种情况补足：
- 如果整型数据为正数，左边补16个0。
- 如果整型数据为负数，左边补16个1。
- 如果整型数据为无符号数，左边也补16个0。
例如：
long a = 123;
int b = 1;
long result = a & b;
long a = 123;
unsigned int b = 1;
long result = a & b;
六.杂项运算符
下表列出了 C 语言支持的其他一些重要的运算符，包括 sizeof 和 ? :。
| 运算符 | 描述 | 实例 |
|---|---|---|
| sizeof() | 返回变量的大小。 | sizeof(a) 将返回 4，其中 a 是整数。 |
| & | 返回变量的地址。 | &a; 将给出变量的实际地址。 |
| * | 指向一个变量。 | *a; 将指向一个变量。 |
| ? : | 条件表达式 | 如果条件为真 ? 则值为 X : 否则值为 Y |
实例：
#include <stdio.h>
int main()
{
int a = 4;
short b;
double c;
int* ptr;
/* sizeof 运算符实例 */
printf("Line 1 - 变量 a 的大小 = %lu\n", sizeof(a) );
printf("Line 2 - 变量 b 的大小 = %lu\n", sizeof(b) );
printf("Line 3 - 变量 c 的大小 = %lu\n", sizeof(c) );
/* & 和 * 运算符实例 */
ptr = &a; /* 'ptr' 现在包含 'a' 的地址 */
printf("a 的值是 %d\n", a);
printf("*ptr 是 %d\n", *ptr);
/* 三元运算符实例 */
a = 10;
b = (a == 1) ? 20: 30;
printf( "b 的值是 %d\n", b );
b = (a == 10) ? 20: 30;
printf( "b 的值是 %d\n", b );
}
执行结果：
Line 1 - 变量 a 的大小 = 4
Line 2 - 变量 b 的大小 = 2
Line 3 - 变量 c 的大小 = 8
a 的值是 4
*ptr 是 4
b 的值是 30
b 的值是 20
sizeof运算符
三元运算符（三目运算符）
1、格式：布尔表达式？值1:值2 ;
2、注意：
使用三元运算符的时候，一定要使用该表达式返回的结果，或者是定义一个变量接收该表达式返回的结果。说简单点就是不能让还有三目运算符的语句自成一句，
例如：age>=18?“成年人”:“未成年人”; 这种报错。
应该是：result=(age>=18?“成年人”:“未成年人”);
或是：printf(age>=18?“成年人”:“未成年人”);
七.C中的运算符优先级
运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。
例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。
下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。
373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
