文章目录
- 了解什么是操作数、操作符
- 操作数：
- 操作符
- 操作符详解：
- 1.算术操作符： + 、- 、* 、/ 、%
- 2.移位操作符: << >>
- 3.位操作符: & | ^
- 4. 赋值操作符: = 、+= 、 -= 、 *= 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=
- 5. 单⽬操作符： ！、++、–、&、*、+、-、~ 、sizeof、(类型)
- 6.关系操作符: > 、>= 、< 、<= 、 == 、 !=
- 7. 逻辑操作符： && 、||
- 8. 条件操作符： ? :
- 9. 逗号表达式： ,
- 10. 下标引⽤： []
- 11. 函数调⽤： ()
- 12.结构体成员访问符
- 操作符的优先级与结合性
- 优先级
- 结合性
- 优先级与结合性表
- 整形提升
- 算术转换
了解什么是操作数、操作符
操作数：
操作数是用于运算的数字或者表达式
如：
1 . 1+1
2.（a+b）*3
操作符
操作符,也称运算符。是对数据进行操作处理的符号。
操作符有很多,常见操作符有:单目操作符、算数操作符、移位操作符、位操作符、赋值操作符、关系操作符、逻辑操作符、条件操作符、逗号表达式、下标引用、函数调用和结构体成员。
操作符详解：
1.算术操作符： + 、- 、* 、/ 、%
+、- 、* 、/ 、% 这些算术操作符分别对应数学上的加、减、乘、除、取余数
如：
int main() {
int a = 10, b = 4;
printf("a+b=%d\n", a + b);//加
printf("a-b=%d\n", a - b);//减
printf("a*b=%d\n", a * b);//乘
printf("a/b=%d\n", a / b);//除
printf("a%b=%d\n", a %b);//取余数
return 0;
}
运行结果：
注：除号 / ，因为求的结果是整数，舍掉小数点后面的数，所以10/4=2
2.移位操作符: << >>
这我在之前的文章讲过，这里放个链接需要的可以去看看哦：http://t.csdnimg.cn/JL6ao
3.位操作符: & | ^
这我在之前的文章讲过，这里放个链接需要的可以去看看哦：http://t.csdnimg.cn/JL6ao
4. 赋值操作符: = 、+= 、 -= 、 *= 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=
赋值操作符 =
当我们要对变量初始化时或者给变量赋一个值时就可以使用（注：这不是我们数学上的等于号噢）
如：
int main() {
int a = 10;//初始化,将10赋给a
int b;
b = 20;//赋值，将20赋给b
printf("a=%d b=%d", a,b);
return 0;
}
运行结果：
连续赋值：
如：
int main() {
int a,b;
a = b = 10;//将10赋给b，再将b赋给a
printf("a=%d b=%d", a, b);
return 0;
}
运行结果：
注意的是在初始化时不能进行连续赋值 如：int a = b = 10;//err
运行会报错，如：
复合赋值
就是将原来运算的过程简化，如：
int main() {
int a = 10;
int b = 20;
a += b;//等于a+b
printf("%d", a);
return 0;
}
运行结果：
不仅能和 +，还能和 -、*、/等操作符一起复合使用
5. 单⽬操作符： ！、++、–、&、*、+、-、~ 、sizeof、(类型)
- 在c语言中规定0为假，非0为真
- ! 逻辑取非运算符：在判断条件时使用，如：（！真 ） 那么它的结果就为假
如：
int main() {
int a = 1;
if (!3) {
printf("a为0");
}
else
printf("a不为0");
return 0;
}
运行结果：
++
++分为前置++和后置++
区别：前置++是先+1再使用，后置++是先使用后++
如：
int main() {
int a = 2;
int b = 2;
printf("a=%d\n", a++);//后置++，先使用，所以这里a的值不变 打印 a=2
printf("b=%d", ++b);//前置++，先+1，后使用，所以这里打印b=3
return 0;
}
运行结果：
** – **
–分为前置–和后置–
区别：前置–是先-1再使用，后置–是先使用后–
如：
int main() {
int a = 2;
int b = 2;
printf("a=%d\n", a--);//后置--，先使用，所以这里打印 a=2
printf("b=%d", --b);//前置--，先-1，后使用，所以这里打印b=1
return 0;
}
运行结果：
取地址操作符&
用于取变量在内存中的地址
如：
int main() {
int a = 10;
printf("%p", &a);//取出a的地址，%p用于打印地址
return 0;
}
运行结果：
解引用操作符 （ * )
（ * ）用于指针 ，放在指针变量的前面，如：*p，*p通过指针变量p中存放的地址，找到指向的空间
如：
int main() {
int a = 10;
int* p = &a;
*p = 5;//通过解引用符来找到p指向的空间，此时*p==a，改变*p即改变a
printf("a=%d", a);
return 0;
}
运行结果：
+、-
这个并不是算术运算符的 +、 -，而是取正负的操作符，+（正）、-（负）。
如：
int main() {
int a = 10;
printf("+a=%d\n", +a);//a不变
printf("-a=%d\n", -a);//a等于-10
return 0;
}
运行结果：
~按位取非
运算规则:将一个操作数全部取反（在二进制的基础上取非），不懂原码、反码、补码、进制的可以看看这个链接的内容：http://t.csdnimg.cn/JL6ao
如：将int a=1取反
sizeof（）
计算变量的所占内存空间大小，单位是字节，如果操作数是类型的话，计算的是使用类型创建的变量的所占空间的大小
如：
int main() {
int a = 10;
int arr[10];
printf("%d\n", sizeof(a));//变量
printf("%d\n", sizeof(int));//类型
printf("%d\n", sizeof(arr));//在计算数组大小时在（）输入数组名即可
return 0;
}
int类型的字节大小为4字节，arr[10],为10个int型的数据所以为40
(类型)
（）强制类型转换，如（int）9.8，将浮点数转化为整数
如：
int main() {
double a = 9.8;
printf("%d\n",(int)a);//
return 0;
}
运行结果：
转化之后舍掉小数
6.关系操作符: > 、>= 、< 、<= 、 == 、 !=
. > 、>= 、< 、<= 、 == 、 !=，这些符号分别是大于、大于等于、小于、小于等于、等于、不等于
注意：>=、<=这两是规定的写法，不要写成=<、=>这种形式
主要用于判断表达是的真假
如：
int main() {
int a = 0, b = 10;
if (a<b) {//这里b大于a，表达式为真，执行下面语句
printf("a<b");
}
return 0;
}
运行结构：
7. 逻辑操作符： && 、||
逻辑与操作符 &&：
1.简单来说就是并且的意思，判断两个表达式若都为真则为真，有一个或者都为假则为假
2.有个特点就是当判断第一个表达式为假时，就不会判断后面的了，直接判断为假
如：
int main() {
int a = 0, b = 2;
if (a && b) {
printf("yes");
}
else
printf("no");
return 0;
}
运行结果：
这里a=0，当判断a=0时，就不会去判断b了，这里直接就为假了
逻辑或操作符 ||：
1.可以简单理解为或者，判断两个表达式中有一个为真则为真，当两个表达式都为假时才判断为假
2.当判断第一个表达式为真时就不会判断后面的表达式了，直接判断为真
如：
int main() {
int a = 0, b = 2;
if (b || a) {
printf("yes");
}
else
printf("no");
return 0;
}
运行结果：
这里当判断b为真时就不会进行后面的判断了，直接判断为真
8. 条件操作符： ? :
条件操作符：
1.? : 为三目运算符
2. 格式：int c = (a > b)?a:b;//(表达式1)？（表达式2）：（表达式3）
3.当表达式1为真时就会执行表达式2，当表达式1为假时就会执行表达式3
如：
int main() {
int a = 0, b = 2;
int c = (a > b)?a:b;//(表达式1)？（表达式2）：（表达式3）
printf("%d", c);
return 0;
}
运行结果：
这里表达式1为假所以执行表达式3，将b赋给c
9. 逗号表达式： ,
逗号表达式：
1.格式：
c int d = a, b, c;//()表达式1），（表达式2），（表达式3）......,已最后一个为标准
2.逗号表达式，就是⽤逗号隔开的多个表达式。
3.逗号表达式，从左向右依次执⾏。整个表达式的结果是最后⼀个表达式的结果。
如：
i
nt main() {
int a = 0, b = 2;
int c = 10;
int d =(a++,b=a+b, c+b);//a++,a=1,b=a+b=3,c+b=13, d=13
printf("%d", d);
return 0;
}
运行结果：
10. 下标引⽤： []
下标引⽤：
1.格式：
arr [ a ]//arr为数组名，a为下标（索引值）
2.用于找到数组具体位置的值
如：
int main() {
int arr[] = { 1,2,3 };
printf("%d", arr[1]);//arr[1]=2;
return 0;
}
运行结果：
11. 函数调⽤： ()
函数调⽤：
1.接受⼀个或者多个操作数：第⼀个操作数是函数名，剩余的操作数就是传递给函数的参数。
2.add()//add（函数名）为第一个操作数，（）里可以放0个或者多个操作数（参数）
如：
int add(int x, int y) {
return x + y;
}
int main() {
int a = 10;
int b = 5;
int c = add(a, b);//add,a,b都为操作数
printf("%d", c);
return 0;
}
运行结果：
12.结构体成员访问符
直接访问: .
格式：结构体名 . 成员名
p.a
如：
struct tag {
int a;
int b;
};
int main() {
struct tag p = { 5,10 };
printf("a=%d b=%d", p.a,p.b);
return 0;
}
运行结果：
间接成员访问符：->
1.有时候我们得到的不是⼀个结构体变量，⽽是得到了⼀个指向结构体的指针,这时就要用到 ->
2.格式：结构体指针->成员名 p1->a
如：
struct tag {
int a;
int b;
};
int main() {
struct tag p= { 5,10 };
struct tag* p1 = &p;
printf("a=%d b=%d", p1->a,p1->b);
return 0;
}
运行结果：
13.圆括号（）
将括号内的看成一个整体，先算完括号内在算其他，在不确定优先级时可以用
操作符的优先级与结合性
优先级
简单来说就是先运算那一部分，和我们学的加减乘除意思差不多，在有加法和乘法的情况下，先算乘法再算加法
如：
int main() {
int a = 10, b = 2;
int c = b + -a * b;//这里有 -（负号） + * 三种运算符
printf("c=%d" ,c);
return 0;
}
因为 优先级 -（负号）> * >+，所以先算-a=-10，再-10 * b=-20,最后再加2，所以c=-18
运行结果：
结合性
简单来说就是操作数与操作符之间谁和谁先在一起，分为自左向右和自右向左两个方向
如：
int c = a + b;
- 是左向右结合：先跟a结合在与b，=赋值运算符是右向左结合，先跟（a+b）结合，再与c结合
优先级与结合性表
规律：
优先级有上到下递减
整形提升
什么是整形提升：
1.C语⾔中整型算术运算总是⾄少以缺省整型类型的精度来进⾏的。
2.为了获得这个精度，表达式中的字符和短整型操作数在使⽤之前被转换为普通整型，这种转换称为整型提升。
意义：
1.表达式的整型运算要在CPU的相应运算器件内执⾏，CPU内整型运算器(ALU)的操作数的字节⻓度⼀般就是int的字节⻓度，同时也是CPU的通⽤寄存器的⻓度。因此，即使两个char类型的相加，在CPU执⾏时实际上也要先转换为CPU内整型操作数的标准⻓度。通⽤CPU（general-purpose CPU）是难以直接实现两个8⽐特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种⻓度可能⼩于int⻓度的整型值，都必须先转换为int或unsigned
int，然后才能送⼊CPU去执⾏运算。
2.通过整形计算完后会进行截断
3.有符号和无符号在一起时，有符号转为无符号计算
4.char、short，转为int计算，就算完后截断
如何提升
- 有符号整数提升是按照变量的数据类型的符号位来提升的
- ⽆符号整数提升，⾼位补0
如：
int mian() {
char a = -1;//有符号
unsigned char b = -1;//无符号
printf("a=%d\nb=%d", a, b);
return 0;
}
char a=1
运行结果：
再如：
char a=1 ，char b=-2，计算a+b
int main() {
char a = 1;
char b = -2;
unsigned char c = a + b;
printf("a+b=%d，c=%d", a+ b，c);
return 0;
}
运行结果：
short也是如此，感兴趣的可以去试试
算术转换
如果某个操作符的各个操作数属于不同的类型，那么除⾮其中⼀个操作数的转换为另⼀个操作数的类型，否则操作就⽆法进⾏。下⾯的层次体系称为寻常算术转换。
long double
double
float
unsigned long int
long int
unsigned int
int
如果某个操作数的类型在上⾯这个列表中排名靠后，那么⾸先要转换为另外⼀个操作数的类型后执⾏运算
如：
int main() {
double a = 9.8;
int b=3;
printf("%lf", a + b);
return 0;
}
运行结果：
这里打印double类型的数，所以编译器会将a转为double类型的计算
以上就是我的分享了，如果由有错误的地方，欢迎在评论区留言
最后 谢谢大家的观看！
文章出处登录后可见！
