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