和数学中的运算符一样, C语言中的运算符是告诉程序执行特定算术或逻辑操作的符号
- 例如告诉程序, 某两个数相加, 相减,相乘等
- 例如告诉程序, 某两个数相加, 相减,相乘等
什么是表达式
- 表达式就是利用运算符链接在一起的有意义,有结果的语句;
- 例如: a + b; 就是一个算数表达式, 它的意义是将两个数相加, 两个数相加的结果就是表达式的结果
- 注意: 表达式一定要有结果
- 按照功能划分:
- 算术运算符
- 赋值运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 按照参与运算的操作数个数划分:
- 单目运算
- 只有一个操作数 如 : i++;
- 双目运算
- 有两个操作数 如 : a + b;
- 三目运算
- C语言中唯一的一个,也称为问号表达式 如: a>b ? 1 : 0;
- 单目运算
- 早在小学的数学课本中,我们就学习过"从左往右,先乘除后加减,有括号的先算括号里面的", 这句话就蕴含了优先级和结合性的问题
- C语言中,运算符的运算优先级共分为15 级。1 级最高,15 级最低
- 在C语言表达式中,不同优先级的运算符, 运算次序按照由高到低执行
- 在C语言表达式中,相同优先级的运算符, 运算次序按照结合性规定的方向执行
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 3 | 乘法运算符 | * | 双目运算符,具有左结合性 |
| 3 | 除法运算符 | / | 双目运算符,具有左结合性 |
| 3 | 求余运算符 (模运算符) | % | 双目运算符,具有左结合性 |
| 4 | 加法运算符 | + | 双目运算符,具有左结合性 |
| 4 | 减法运算符 | - | 双目运算符,具有左结合性 |
- 注意事项
- 如果参与运算的两个操作数皆为整数, 那么结果也为整数
- 如果参与运算的两个操作数其中一个是浮点数, 那么结果一定是浮点数
- 求余运算符, 本质上就是数学的商和余"中的余数
- 求余运算符, 参与运算的两个操作数必须都是整数, 不能包含浮点数
- 求余运算符, 被除数小于除数, 那么结果就是被除数
- 求余运算符, 运算结果的正负性取决于被除数,跟除数无关, 被除数是正数结果就是正数,被除数是负数结果就是负数
- 求余运算符, 被除数为0, 结果为0
- 求余运算符, 除数为0, 没有意义(不要这样写)
#include<stdio.h>intmain(){ inta=10; intb=5; // 加法intresult=a+b; printf("%i\n", result); // 15// 减法result=a-b; printf("%i\n", result); // 5// 乘法result=a*b; printf("%i\n", result); // 50// 除法result=a / b; printf("%i\n", result); // 2// 算术运算符的结合性和优先级// 结合性: 左结合性, 从左至右intc=50; result=a+b+c; // 15 + c; 65;printf("%i\n", result); // 优先级: * / % 大于 + -result=a+b*c; // a + 250; 260;printf("%i\n", result); }#include<stdio.h>intmain(){ // 整数除以整数, 结果还是整数printf("%i\n", 10 / 3); // 3// 参与运算的任何一个数是小数, 结果就是小数printf("%f\n", 10 / 3.0); // 3.333333 }#include<stdio.h>intmain(){ // 10 / 3 商等于3, 余1intresult=10 % 3; printf("%i\n", result); // 1// 左边小于右边, 那么结果就是左边result=2 % 10; printf("%i\n", result); // 2// 被除数是正数结果就是正数,被除数是负数结果就是负数result=10 % 3; printf("%i\n", result); // 1result=-10 % 3; printf("%i\n", result); // -1result=10 % -3; printf("%i\n", result); // 1 }| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 14 | 赋值运算符 | = | 双目运算符,具有右结合性 |
| 14 | 除后赋值运算符 | /= | 双目运算符,具有右结合性 |
| 14 | 乘后赋值运算符 (模运算符) | *= | 双目运算符,具有右结合性 |
| 14 | 取模后赋值运算符 | %= | 双目运算符,具有右结合性 |
| 14 | 加后赋值运算符 | += | 双目运算符,具有右结合性 |
| 14 | 减后赋值运算符 | -= | 双目运算符,具有右结合性 |
- 简单赋值运算符
#include<stdio.h>intmain(){ // 简单的赋值运算符 =// 会将=右边的值赋值给左边inta=10; printf("a = %i\n", a); // 10 }- 复合赋值运算符
#include<stdio.h>intmain(){ // 复合赋值运算符 += -= *= /= %=// 将变量中的值取出之后进行对应的操作, 操作完毕之后再重新赋值给变量intnum1=10; // num1 = num1 + 1; num1 = 10 + 1; num1 = 11;num1+=1; printf("num1 = %i\n", num1); // 11intnum2=10; // num2 = num2 - 1; num2 = 10 - 1; num2 = 9;num2-=1; printf("num2 = %i\n", num2); // 9intnum3=10; // num3 = num3 * 2; num3 = 10 * 2; num3 = 20;num3 *= 2; printf("num3 = %i\n", num3); // 20intnum4=10; // num4 = num4 / 2; num4 = 10 / 2; num4 = 5;num4 /= 2; printf("num4 = %i\n", num4); // 5intnum5=10; // num5 = num5 % 3; num5 = 10 % 3; num5 = 1;num5 %= 3; printf("num5 = %i\n", num5); // 1 }- 结合性和优先级
#include<stdio.h>intmain(){ intnumber=10; // 赋值运算符优先级是14, 普通运算符优先级是3和4, 所以先计算普通运算符// 普通运算符中乘法优先级是3, 加法是4, 所以先计算乘法// number += 1 + 25; number += 26; number = number + 26; number = 36;number+=1+5*5; printf("number = %i\n", number); // 36 }- 在程序设计中,经常遇到“i=i+1”和“i=i-1”这两种极为常用的操作。
- C语言为这种操作提供了两个更为简洁的运算符,即++和--
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 2 | 自增运算符(在后) | i++ | 单目运算符,具有左结合性 |
| 2 | 自增运算符(在前) | ++i | 单目运算符,具有右结合性 |
| 2 | 自减运算符(在后) | i-- | 单目运算符,具有左结合性 |
| 2 | 自减运算符(在前) | --i | 单目运算符,具有右结合性 |
- 自增
- 如果只有单个变量, 无论++写在前面还是后面都会对变量做+1操作
#include<stdio.h>intmain(){ intnumber=10; number++; printf("number = %i\n", number); // 11++number; printf("number = %i\n", number); // 12 }- 如果出现在一个表达式中, 那么++写在前面和后面就会有所区别
- 前缀表达式:++x, --x;其中x表示变量名,先完成变量的自增自减1运算,再用x的值作为表达式的值;即“先变后用”,也就是变量的值先变,再用变量的值参与运算
- 后缀表达式:x++, x--;先用x的当前值作为表达式的值,再进行自增自减1运算。即“先用后变”,也就是先用变量的值参与运算,变量的值再进行自增自减变化
#include<stdio.h>intmain(){ intnumber=10; // ++在后, 先参与表达式运算, 再自增// 表达式运算时为: 3 + 10;intresult=3+number++; printf("result = %i\n", result); // 13printf("number = %i\n", number); // 11 }#include<stdio.h>intmain(){ intnumber=10; // ++在前, 先自增, 再参与表达式运算// 表达式运算时为: 3 + 11;intresult=3+++number; printf("result = %i\n", result); // 14printf("number = %i\n", number); // 11 }- 自减
#include<stdio.h>intmain(){ intnumber=10; // --在后, 先参与表达式运算, 再自减// 表达式运算时为: 10 + 3;intresult=number--+3; printf("result = %i\n", result); // 13printf("number = %i\n", number); // 9 }#include<stdio.h>intmain(){ intnumber=10; // --在前, 先自减, 再参与表达式运算// 表达式运算时为: 9 + 3;intresult=--number+3; printf("result = %i\n", result); // 12printf("number = %i\n", number); // 9 }- 注意点:
- 自增、自减运算只能用于单个变量,只要是标准类型的变量,不管是整型、实型,还是字符型变量等,但不能用于表达式或常量
- 错误用法:
++(a+b); 5++;
- 错误用法:
- 企业开发中尽量让++ -- 单独出现, 尽量不要和其它运算符混合在一起
- 自增、自减运算只能用于单个变量,只要是标准类型的变量,不管是整型、实型,还是字符型变量等,但不能用于表达式或常量
inti=10; intb=i++; // 不推荐或者intb=++i; // 不推荐或者inta=10; intb=++a+a++; // 不推荐- 请用如下代码替代
inti=10; intb=i; // 推荐i++; 或者; i++; intb=i; // 推荐或者inta=10; ++a; intb=a+a; // 推荐a++;- C语言标准没有明确的规定，
同一个表达式中同一个变量自增或自减后如何运算, 不同编译器得到结果也不同, 在企业开发中千万不要这样写
inta=1; // 下列代码利用Qt运行时6, 利用Xcode运行是5// 但是无论如何, 最终a的值都是3// 在C语言中这种代码没有意义, 不用深究也不要这样写// 特点: 参与运算的是同一个变量, 参与运算时都做了自增自减操作, 并且在同一个表达式中intb=++a+++a; printf("b = %i\n", b); sizeof可以用来计算一个变量或常量、数据类型所占的内存字节数
- 标准格式: sizeof(常量 or 变量);
sizeof的几种形式
- sizeof( 变量\常量 );
sizeof(10);char c = 'a'; sizeof(c);
- sizeof 变量\常量;
sizeof 10;char c = 'a'; sizeof c;
- sizeof( 数据类型);
sizeof(float);如果是数据类型不能省略括号
- sizeof( 变量\常量 );
sizeof面试题:
- sizeof()和+=、*=一样是一个复合运算符, 由sizeof和()两个部分组成, 但是代表的是一个整体
- 所以sizeof不是一个函数, 是一个运算符, 该运算符的优先级是2
#include<stdio.h>intmain(){ inta=10; doubleb=3.14; // 由于sizeof的优先级比+号高, 所以会先计算sizeof(a);// a是int类型, 所以占4个字节得到结果4// 然后再利用计算结果和b相加, 4 + 3.14 = 7.14doubleres=sizeofa+b; printf("res = %lf\n", res); // 7.14 }- 在C语言中逗号“,”也是一种运算符,称为逗号运算符。 其功能是把多个表达式连接起来组成一个表达式,称为逗号表达式
- 逗号运算符会从左至右依次取出每个表达式的值, 最后整个逗号表达式的值等于最后一个表达式的值
- 格式:
表达式1，表达式2，… …，表达式n;
- 例如:
int result = a+1,b=3*4;
#include<stdio.h>intmain(){ inta=10, b=20, c; // ()优先级高于逗号运算符和赋值运算符, 所以先计算()中的内容// c = (11, 21);// ()中是一个逗号表达式, 结果是最后一个表达式的值, 所以计算结果为21// 将逗号表达式的结果赋值给c, 所以c的结果是21c= (a+1, b+1); printf("c = %i\n", c); // 21 }- 为什么要学习关系运算符
- 默认情况下，我们在程序中写的每一句正确代码都会被执行。但很多时候，我们想在某个条件成立的情况下才执行某一段代码
- 这种情况的话可以使用条件语句来完成，但是学习条件语句之前，我们先来看一些更基础的知识：如何判断一个条件是否成立
- C语言中的真假性
- 在C语言中，条件成立称为“真”，条件不成立称为“假”，因此，判断条件是否成立，就是判断条件的“真假”
- 怎么判断真假呢？C语言规定，任何数值都有真假性，任何非0值都为“真”，只有0才为“假”。也就是说，108、-18、4.5、-10.5等都是“真”，0则是“假”
- 关系运算符的运算结果只有2种：如果条件成立，结果就为1，也就是“真”；如果条件不成立，结果就为0，也就是“假”
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 6 | 大于运算符 | > | 双目运算符,具有左结合性 |
| 6 | 小于运算符 | < | 双目运算符,具有左结合性 |
| 6 | 大于等于运算符 | >= | 双目运算符,具有左结合性 |
| 6 | 小于等于运算符 | <= | 双目运算符,具有左结合性 |
| 7 | 等于运算符 | == | 双目运算符,具有左结合性 |
| 7 | 不等于运算符 | != | 双目运算符,具有左结合性 |
#include<stdio.h>intmain(){ intresult=10>5; printf("result = %i\n", result); // 1result=5<10; printf("result = %i\n", result); // 1result=5>10; printf("result = %i\n", result); // 0result=10 >= 10; printf("result = %i\n", result); // 1result=10 <= 10; printf("result = %i\n", result); // 1result=10==10; printf("result = %i\n", result); // 1result=10!=9; printf("result = %i\n", result); // 1 }- 优先级和结合性
#include<stdio.h>intmain(){ // == 优先级 小于 >, 所以先计算>// result = 10 == 1; result = 0;intresult=10==5>3; printf("result = %i\n", result); // 0 }#include<stdio.h>intmain(){ // == 和 != 优先级一样, 所以按照结合性// 关系运算符是左结合性, 所以从左至右计算// result = 0 != 3; result = 1;intresult=10==5!=3; printf("result = %i\n", result); // 1 }- 练习: 计算result的结果
intresult1=3>4+7intresult2= (3>4) +7intresult3=5!=4+2*7>3==10- 注意点:
- 无论是float还是double都有精度问题, 所以一定要避免利用==判断浮点数是否相等
#include<stdio.h>intmain(){ floata=0.1; floatb=a*10+0.00000000001; doublec=1.0++0.00000000001; printf("b = %f\n", b); printf("c = %f\n", c); intresult=b==c; printf("result = %i\n", result); // 0 }| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 2 | 逻辑非运算符 | ! | 单目运算符,具有右结合性 |
| 11 | 逻辑与运算符 | && | 双目运算符,具有左结合性 |
| 12 | 逻辑或运算符 | || | 双目运算符,具有左结合性 |
- 逻辑非
格式:
! 条件A;运算结果: 真变假,假变真
运算过程:
- 先判断条件A是否成立，如果添加A成立, 那么结果就为0，即“假”；
- 如果条件A不成立，结果就为1，即“真”
- 使用注意:
- 可以多次连续使用逻辑非运算符
- !!!0;相当于(!(!(!0)));最终结果为1
#include<stdio.h>intmain(){ // ()优先级高, 先计算()里面的内容// 10==10为真, 所以result = !(1);// !代表真变假, 假变真,所以结果是假0intresult= !(10==10); printf("result = %i\n", result); // 0 }逻辑与
- 格式:
条件A && 条件B; - 运算结果:一假则假
- 运算过程:
- 总是先判断"条件A"是否成立
- 如果"条件A"成立，接着再判断"条件B"是否成立, 如果"条件B"也成立，结果就为1，即“真”
- 如果"条件A"成立，"条件B"不成立，结果就为0，即“假”
- 如果"条件A"不成立，不会再去判断"条件B"是否成立, 因为逻辑与只要一个不为真结果都不为真
- 使用注意:
- "条件A"为假, "条件B"不会被执行
- 格式:
#include<stdio.h>intmain(){ // 真 && 真intresult= (10==10) && (5!=1); printf("result = %i\n", result); // 1// 假 && 真result= (10==9) && (5!=1); printf("result = %i\n", result); // 0// 真 && 假result= (10==10) && (5!=5); printf("result = %i\n", result); // 0// 假 && 假result= (10==9) && (5!=5); printf("result = %i\n", result); // 0 }#include<stdio.h>intmain(){ inta=10; intb=20; // 逻辑与, 前面为假, 不会继续执行后面intresult= (a==9) && (++b); printf("result = %i\n", result); // 1printf("b = %i\n", b); // 20 }逻辑或
- 格式:
条件A || 条件B; - 运算结果:一真则真
- 运算过程:
- 总是先判断"条件A"是否成立
- 如果"条件A"不成立，接着再判断"条件B"是否成立, 如果"条件B"成立，结果就为1，即“真”
- 如果"条件A"不成立，"条件B"也不成立成立, 结果就为0，即“假”
- 如果"条件A"成立, 不会再去判断"条件B"是否成立, 因为逻辑或只要一个为真结果都为真
- 使用注意:
- "条件A"为真, "条件B"不会被执行
- 格式:
#include<stdio.h>intmain(){ // 真 || 真intresult= (10==10) || (5!=1); printf("result = %i\n", result); // 1// 假 || 真result= (10==9) || (5!=1); printf("result = %i\n", result); // 1// 真 || 假result= (10==10) || (5!=5); printf("result = %i\n", result); // 1// 假 || 假result= (10==9) || (5!=5); printf("result = %i\n", result); // 0 }#include<stdio.h>intmain(){ inta=10; intb=20; // 逻辑或, 前面为真, 不会继续执行后面intresult= (a==10) || (++b); printf("result = %i\n", result); // 1printf("b = %i\n", b); // 20 }- 练习: 计算result的结果
intresult=3>5||2<4&&6<1;- 三目运算符，它需要3个数据或表达式构成条件表达式
- 格式:
表达式1？表达式2(结果A)：表达式3(结果B)
- 示例:
考试及格 ? 及格 : 不及格;
- 求值规则:
- 如果"表达式1"为真，三目运算符的运算结果为"表达式2"的值(结果A)，否则为"表达式3"的值(结果B)
示例: inta=10; intb=20; intmax= (a>b) ? a : b; printf("max = %d", max); 输出结果: 20等价于: inta=10; intb=20; intmax=0; if(a>b){ max=a; }else { max=b; } printf("max = %d", max);- 注意点
- 条件运算符的运算优先级低于关系运算符和算术运算符,但高于赋值符
- 条件运算符?和:是一个整体,不能分开使用
#include<stdio.h>intmain(){ inta=10; intb=5; // 先计算 a > b// 然后再根据计算结果判定返回a还是b// 相当于int max= (a>b) ? a : b;intmax=a>b ? a : b; printf("max = %i\n", max); // 10 }#include<stdio.h>intmain(){ inta=10; intb=5; intc=20; intd=10; // 结合性是从右至左, 所以会先计算:后面的内容// int res = a>b?a:(c>d?c:d);// int res = a>b?a:(20>10?20:10);// int res = a>b?a:(20);// 然后再计算最终的结果// int res = 10>5?10:(20);// int res = 10;intres=a>b?a:c>d?c:d; printf("res = %i\n", res); }| 强制类型转换(显示转换) | 自动类型转换(隐式转换) |
|---|---|
| (需要转换的类型)(表达式) | 1.算数转换 2.赋值转换 |
- 强制类型转换(显示转换)
// 将double转换为intinta= (int)10.5;- 算数转换
- 系统会自动对占用内存较少的类型做一个“自动类型提升”的操作, 先将其转换为当前算数表达式中占用内存高的类型, 然后再参与运算
// 当前表达式用1.0占用8个字节, 2占用4个字节// 所以会先将整数类型2转换为double类型之后再计算doubleb=1.0 / 2;- 赋值转换
// 赋值时左边是什么类型,就会自动将右边转换为什么类型再保存inta=10.6;- 注意点:
- 参与计算的是什么类型, 结果就是什么类型
// 结果为0, 因为参与运算的都是整型doublea= (double)(1 / 2); // 结果为0.5, 因为1被强制转换为了double类型, 2也会被自动提升为double类型doubleb= (double)1 / 2;- 类型转换并不会影响到原有变量的值
#include<stdio.h>intmain(){ doubled=3.14; intnum= (int)d; printf("num = %i\n", num); // 3printf("d = %lf\n", d); // 3.140000 }最后，如果你有任何疑问，欢迎加微信 leader_fengy 拉你进学习交流群。
