? ? ? ?
?
目录
()函数调用操作符接收一个或多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
操作符的分类
算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员
算术操作符
+? ? ?-? ? ?*? ? ?/? ? ?%
注意事项：
1、除了%操作符外，其他几个操作符都可用于整数和浮点数的计算
2、/操作符，如果对整数进行运算，执行的是整数除法（得到的一定是整数）；如果对浮点数进行运算，执行的是浮点数除法。详细例子如下：
? ? ? ? ? ? ??
?从上面可以看出，5/2? 和? 5/2.0? 具有不同的含义。
3、%操作符进行计算两个整数相除后得到的余数。
? ?比如：5%2=1；? ? ? ? ? ? ? 5%2.0（错误）
移位操作符
<<? ? 左移操作符
>>? ? ?右移操作符
注意：对二进制位进行移位
左移操作符规则
左边抛弃，右边补零。
比如：1? ?
其二进制位：00000000000000000000000000000001
? ? ? ? ? 1<<1:??00000000000000000000000000000010
得到的结果：2
右移操作符
右移操作符分为：逻辑移位 、 算术移位
1、逻辑移位：左边用0填充，右边丢弃。
比如：-1? ?
其二进制位：原码：10000000000000000000000000000001
? ? ? ? ? ? ? ? ? ? ?反码： 11111111111111111111111111111110
? ? ? ? ? ? ? ? ? ? ? 补码：11111111111111111111111111111111
? ? ? ? ? ? ? ? ? ? ?-1>>1:? 01111111111111111111111111111111
得到的结果：2^32-1
2、算术移位：左边用该原值的符号位补充，右边丢弃。
比如：-1? ?
其二进制位：原码：10000000000000000000000000000001
? ? ? ? ? ? ? ? ? ? ?反码： 11111111111111111111111111111110
? ? ? ? ? ? ? ? ? ? ? 补码：11111111111111111111111111111111
? ? ? ? ? ? ? ? ? ? ?-1>>1:? 11111111111111111111111111111111
得到的结果：-1
注意：移位操作符不能移动负数位。
比如：
? ? ? ? ? ?a>>= -1;? ? ? ? 这种写法是错误的。
位操作符
位操作符有:
&? ? 按位与
|? ? ? 按位或
^? ? ?按位异或
注：它们的操作数必须是整数。
位操作符用法
int num1=1;? ? ?int num2=2;
&：当对应的二进制位都是1时，得到1。
num1：00000000000000000000000000000001
num2：00000000000000000000000000000010
? ? ? ?a：00000000000000000000000000000000? ? ?
|：当对应的二进制位只要有一个是1时，得到1。
num1：00000000000000000000000000000001
num2：00000000000000000000000000000010
? ? ? ?a：00000000000000000000000000000011
^：对应的二进制位相异为1，形同位0。
num1：00000000000000000000000000000001
num2：00000000000000000000000000000010
? ? ? ?a：00000000000000000000000000000011? ?
综上;代码运行结果：
? ? ??
? ?赋值操作符
=? ? ? 可以给一个变量进行赋值给自己想要的值。
int a=1;
a=2;? ? ? ? 在这里之后，a=2了。
复合赋值符
+=
-=
/=
%=
>>=
<<=
&=
|=
^=
比如：+=符号
int a=10;
a+=1;? ? 等价于a=a+1;
来看一下效果;
单目操作符
！? ? 逻辑反操作
-? ? ? ?负值
+? ? ? ?正值
&? ? ? 取地址
sizeof? ? 操作数的类型长度（以字节为单位）
~? ? ? ? ? 对一个数的二进制位按位取反
--? ? ? ?前置、后置--
++? ? ?前置、后置++
*? ? ? ? ?间接访问操作符（解引用操作符）
(类型)? ? 强制类型转换
具体用法
！：将真条件变成假（0），将假条件变成真（非0）
具体实操：
?- 和 +：? ? ? -，将一个数变成负数和数学上意义一样? ? ? ? ? ?+，和数学上意义一样
? ? ? ? &：? ??取出某块空间的地址。
? ? ? ? ?*：通常和&一起使用，找到地址所指向空间存储的数据。
sizeof：求变量（类型所占空间的大小，单位是字节。
sizeof（arr）：没有&，也没有+数字，在这里arr表示整个数组。大小为4*10=40
sizeof(ch)：1*10=10
test1(arr):通过传参传过去的是地址，地址的·大小是4（32位平台）个或8（64位平台）个字节。
test(ch):通过传参传过去的是地址，地址的·大小是4（32位平台）个或8（64位平台）个字节。
#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;
}~：比如：1
1的二进制位: 000000000000000000000001
~1：? ? ? ? ? ? ? 1111111111111111111111111110
则~1的反码：1111111111111111111111111101
? ?~1的原码：1000000000000000000000010? （-2）
--和++操作符：
#include<stdio.h>
int main()
{
?? ?int a = 10;
?? ?int b = a--; ? ?//先使用，再-- ? a先把10赋值给b，然后a--就变成了9
?? ?int c = --a; ? ?//先--，再使用 ? ?a先从9，++变成8，然后赋值给c
?? ?printf("%d\n", b); ?//10
?? ?printf("%d\n",c); ? //8------------------------------------------------------------------------------------------------------------------------
?? ?int a = 10;
?? ?int b = a++; ? ?//先使用，再++ ? ?a先把10赋值给b，然后a++就变成了11
?? ?int c = ++a; ? ?//先++，再使用 ? ?a先从11，++变成12，然后赋值给c
?? ?printf("%d\n", b); ?//10
?? ?printf("%d\n", c); ? //12
?? ?return 0;
}
（类型）：? a是浮点型，计算结果要得到整型，那么就（int）转换成整形
#include<stdio.h>
int main()
{
?? ?float a = 10.0;
?? ?int b =(int) (a / 3.0); ? ? ??
?? ?printf("%d\n", b);
?? ?return 0;
}注意：如果不进行强制类型转换，会出现警告。
比如：
#include<stdio.h>
int main()
{
float a = 10.0;
// int b =(int) (a / 3.0);
int b = a / 3.0;
printf("%d\n", b);
return 0;
}
?关系操作符
>
>=
<
<=
!=? ? 用于测试不相等
==? ?用于测试相等
在这里注意“==”和“=”的区别
逻辑操作符
&&? ? ?逻辑与
||? ? ? ? 逻辑或
区分逻辑与和按位与，逻辑或和按位或
非0表示真，&&? ||? 用来判断条件真假
1&2------------->0
1&&2----------->1? ? （真）&&（真）--->1
1|2-------------->3
1||2------------->1? ? ?（真）||（真）--->1
条件操作符
exp1 ? exp2 : exp3
exp1条件成立吗？如果成立返回exp2:如果不成立返回exp3
例如代码：
#include<stdio.h>
int main()
{
int a = 10;
int b = 20;
int c = (a > b) ? a: b;
printf("%d\n", c);
return 0;
}
逗号表达式
exp1, exp2, exp3, …expN
得到的结果是最后一个逗号的运算结果
具体例子：
#include<stdio.h>
int main()
{
int a = 1;
int b = 2;
int c = (a++, ++b, a + b); //=的优先级比 , 要高，所以=后面要加括号
printf("%d\n", c);
return 0;
}最后计算的结果是a+b的结果。
? ? ? ??
?下标引用、函数调用和结构成员
[]下标引用操作符
int arr[10] = { 0 }; //创建数组
arr[9]; //实用下标引用操作符
[]的操作数是arr和9()函数调用操作符接收一个或多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
#include <stdio.h>
void test1()
{
printf("hehe\n");
}
void test2(const char* str)
{
printf("%s\n", str);
}
int main()
{
test1(); //实用（）作为函数调用操作符。
test2("hello world."); //实用（）作为函数调用操作符。
return 0;
}结构成员
.? ?结构体.成员名
->? 结构体指针->成员名
具体内容如下：
#include<stdio.h>
#include<string.h>
struct Book
{
char name[30];
float price;
char ID[20];
};
//用结构体常量来接收
void print1(struct Book b) //结构体接收值
{
printf("书名：%s\n", b.name);
printf("价格：%f\n", b.price);
printf("ID：%s\n", b.ID);
}
//用指针接收
void print2(struct Book* pb)
{
printf("书名：%s\n", pb->name);
printf("价格：%f\n",pb->price);
printf("ID：%s\n", pb->ID);
//写法二：
printf("书名：%s\n", (*pb).name);
printf("价格：%f\n", (*pb).price);
printf("ID：%s\n", (*pb).ID);
}
int main()
{
struct Book b = { "C语言程序设计",55.5f,"470220040" };
//对结构体的内容进行修改
//strcpy(b.name, "数据结构"); //right
//strcpy(b.ID, "47022004"); //right
//------------------对数组内容进行修改，要是用strcpy
b.price = 100.0f; //right
// strcpy(b.price, 100.5f); //err
//-----------------对不是数组类型内容进行修改，要结构体.成员名进行赋值
//b.name = "数据结构"; //err
//b.ID = "4700"; //err
//strcpy((*pb).name, "数据结构"); //err
//strcpy(pb->name, "数据结构"); //err
print1(b);
print2(&b);
return 0;
}