C 语言-运算符(算术运算符,类型转换,赋值运算符,自增,自减,sizeof 运算符,逗号运算符,关系运算符,逻辑运算符,三目运算符)

时间  2020-12-01
标签 数组 函数 性能 spa 指针 code 对象 blog 内存 开发 栏目 C&C++ 繁體版
原文   原文链接

目录数组

运算符划分

  • 按照功能划分：函数

    • 算术运算符
    • 关系运算符
    • 逻辑运算符
    • 按位运算符

  • 按照参与运算的操做个数进行划分性能

    • 单目运算符spa

      • 只有一个操做数 如：i++

    • 双目运算符指针

      • 有两个操做数 如：a+b

    • 三目运算符code

      • 有三个操做数 如：a > b ? 1:0 若是a>b时，a = 1，若是a<b时，a = 0

运算符的优先级表

  • 运算符的优先级分为15级别，1级最高，15级最低对象

  • 在表达式中优先级高的优先于优先级低的先运算blog

  • 在一个运算量两侧的，优先级同样时按照运算符的结合性所规定的方向进行运算内存

    优先级 运算符 名称或含义 使用形式 结合方向 说明
    1 [] 数组下标 数组名[常量表达式] 左到右  
      () 圆括号 （表达式）/函数名(形参表)    
      . 成员选择（对象） 对象.成员名    
      -> 成员选择（指针） 对象指针->成员名    
    2 - 负号运算符 -表达式 右到左 单目运算符
      (类型) 强制类型转换 (数据类型)表达式    
      ++ 自增运算符 ++变量名/变量名++ 单目运算符  
      -- 自减运算符 --变量名/变量名-- 单目运算符  
      * 取值运算符 *指针变量 单目运算符  
      & 取地址运算符 &变量名 单目运算符  
      ! 逻辑非运算符 !表达式 单目运算符  
      ~ 按位取反运算符 ~表达式 单目运算符  
      sizeof 长度运算符 sizeof(表达式)    
    3 / 除 表达式/表达式 左到右 双目运算符
      * 乘 表达式*表达式 双目运算符  
      % 余数（取模） 整型表达式/整型表达式 双目运算符  
    4 + 加 表达式+表达式 左到右 双目运算符
      - 减 表达式-表达式 双目运算符  
    5 << 左移 变量<<表达式 左到右 双目运算符
      >> 右移 变量>>表达式 双目运算符  
    6 > 大于 表达式>表达式 左到右 双目运算符
      >= 大于等于 表达式>=表达式 双目运算符  
      < 小于 表达式<表达式 双目运算符  
      <= 小于等于 表达式<=表达式 双目运算符  
    7 == 等于 表达式==表达式 左到右 双目运算符
      != 不等于 表达式!= 表达式 双目运算符  
    8 & 按位与 表达式&表达式 左到右 双目运算符
    9 ^ 按位异或 表达式^表达式 左到右 双目运算符
    10 | 按位或 表达式|表达式 左到右 双目运算符
    11 && 逻辑与 表达式&&表达式 左到右 双目运算符
    12 || 逻辑或 表达式||表达式 左到右 双目运算符
    13 ?: 条件运算符 表达式1? 表达式2: 表达式3 右到左 三目运算符
    14 = 赋值运算符 变量=表达式 右到左  
      /= 除后赋值 变量/=表达式    
      *= 乘后赋值 变量*=表达式    
      %= 取模后赋值 变量%=表达式    
      += 加后赋值 变量+=表达式    
      -= 减后赋值 变量-=表达式    
      <<= 左移后赋值 变量<<=表达式    
      >>= 右移后赋值 变量>>=表达式    
      &= 按位与后赋值 变量&=表达式    
      ^= 按位异或后赋值 变量^=表达式    
      |= 按位或后赋值 变量|=表达式    
    15 , 逗号运算符 表达式,表达式,… 左到右 从左向右顺序运算

  • 虽说运算符有不少，可是不用记住，使用小括号（）扩起来就行了开发

结合性简单介绍

  • c语言中有两种结合性，一种是左结合型，一种是右结合性
  • 左结合性--自左至右运算，右结合性--自右至左运算
  • 左结合性 例如：x + y -z，先计算x+y，计算后的结果再减z
  • 右结合性 例如：x = y = z， 将z的值赋值给y，再将y的值赋值给x

算数运算符表

运算符 术语 示例 结果
+ 正号 +3 3
- 负号 -3 -3
+ 加 10 + 5 15
- 减 10 - 5 5
* 乘 10 * 5 50
/ 除 10 / 5 2
% 取模(取余) 10 % 3 1
++ 前自增 a=2; b=++a; a=3; b=3;
++ 后自增 a=2; b=a++; a=3; b=2;
-- 前自减 a=2; b=--a; a=1; b=1;
-- 后自减 a=2; b=a--; a=1; b=2; 
#include <stdio.h>

int main(int argc, const char * argv[]) {
    /*
     +  加法
     -  减法
     *  乘法
     /  除法
     %  取模（取余）
     */
    int result; result = 1 + 1; printf("加法结果：result = %i\n",result); result = 1 - 1; printf("减法结果：result = %i\n",result); result = 2 * 3; printf("乘法结果：result = %i\n",result); result = 10 / 2; printf("除法结果：result = %i\n",result); // result = 5 result = 10 % 3; printf("取模结果：result = %i\n",result); // result = 1 return 0; }

取模运算符的注意点

  • 注意：取模运算只能对整数取模，不能对实数取模
    // 注意取模运算只能是整数取模不能是实数取模
    // result = 10.5 % 3; // 直接报错
  • 注意：取模运算的正负性，取决于左边的操做数
    // 取模运算的正负性，取决于左边的操做数
    result = 10 % -3;
    printf("取模正负性结果：result = %i\n",result); // result = 1
    result = -10 % -3; printf("取模正负性结果：result = %i\n",result); // result = -1 result = -10 % 3; printf("取模正负性结果：result = %i\n",result); // result = -1 result = -0 % -3; printf("取模正负性结果：result = %i\n",result); // result = 0
  • 注意：若是取模运算中，左边操做数小于右边操做数，那结果直接就是左边操做数，不会进行计算了
 // 若是取模运算中，左边操做数小于右边操做数，那结果直接就是左边操做数，不会进行计算了
    result = 10 % 100;
    printf("取模结果：result = %i\n",result); // result = 10

 

算术运算符的结合性

 // 算术运算符的结合性
    result = 3 + 4 + 5 + 6;
    printf("result的值是%i",result);

算术运算符的优先级和结合性同时存在时

  • 先优先级，再按照结合性
 // 优先级+结合性
    result = 2 + 3 * 4 -4;
    printf("result的值是%i\n",result); // 先计算乘法，再从左至右的结合性计算

类型转换

  • 隐式转换
    // 系统自动进行的转换
    int number = 10.8;
    printf("number的值是%i\n",number); // number = 10,
    // 大类型的转换成小类型的，系统会自动进行转换，由大类型转换为小类型，丢失精度
  • 显式转换
    // 显式转换-只须要在值前面加（类型）
    int value = (int)10.8;
    printf("value的值是%i\n",value); // 10;
    // 大类型的转换成小类型的，系统会自动进行转换，由大类型转换为小类型，丢失精度
  • 在算术运算中，类型不一致时，系统会先将类型统一，统一成大类型进行计算
    // 在算术运算中，类型不一致时，系统会先将类型统一，统一成大类型进行计算
    int value2 = 10 + 9.9;
    // 10是int类型，9.9是double类型，int类型占4个字节，9.9占8个字节，因此先将int转为double类型
    // int value2 = 10.0 + 9.9
    // int value2 = 19.9
    // value2 是一个int类型，可是右边的19.9是double类型，这时候系统会作隐式转换，大类型转为小类型，既结果为19
    printf("value2的值是%i\n",value2); // 19;
  • 算术运算符的注意点-参与运算的操做数是什么类型，那么计算出来的结果就是什么类型
    // 算术运算符的注意点-参与运算的操做数是什么类型，那么计算出来的结果就是什么类型
    int value3 = 1 / 2;
    printf("value3的值是%i\n",value3); // 打印出来的是0
    // 此时你会不会以为是由于定义的变量是int类型致使的呢？那我就换成double类型的看看
    double value3 = 1 / 2; printf("value3的值是%lf\n",value3); // 打印出来的是0.000000 此时仍是0 // 是由于右侧参与运算的都是整数，那么计算的结果确定是整数 // 那么若是须要打印出0.5该怎么办呢？ double value4 = 1.0 / 2; // 此时一个double除以int类型，确定是都先转换为doublee类型，计算出的结果就是double类型，i定义的变量也是double类型不须要转换因此打印出的是0.500000 printf("value4的值是%.1lf\n",value4); int value5 = 1.0 / 2; printf("value5的值是%i\n",value5); // 0
  • 新手注意常犯的错误
    // 新手注意饭的错误
    double value6 = (double)(1 / 2);
    // 右边先计算括号中的1 / 2，那么两个整数相除，结果确定是整数，因此是0 ，由强转为double类型，为0.000000
    printf("value6的值是%lf",value6); // 0.000000
  • 在算术运算符中，实数的计算都是double类型，不是float类型

赋值运算符

  • 最简单的赋值运算符，将等号右边的值赋值给等号左边的变量
    • 赋值运算符的结合性是右结合性
int main(int argc, const char * argv[]) {
    // 最简单的赋值运算符，将等号右边的值赋值给等号左边的变量
    // 赋值运算符的结合性是右结合性
    int number = 10; int a; int b; a = b = 5; printf("a的值是%i,b的值是%i\n",a,b); return 0; }
  • 符合赋值运算符
    • 定义：在赋值符“=”加上其余的二目运算符可构成复合赋值运算符

赋值运算符的做用是将常量、变量或表达式的值赋给某一个变量。

运算符 术语 示例 结果
= 赋值 a=2; b=3; a=2; b=3;
+= 加等于 a=0; a+=2; a = a + 2 a=2;
-= 减等于 a=5; a-=3; a = a - 3 a=2;
*= 乘等于 a=2; a*=2; a = a * 2 a=4;
/= 除等于 a=4; a/=2; a = a / 2 a=2;
%= 模等于 a=3; a%2; a = a % 2 a=1; 
    int a = 0;
    a += 3; // 这种是直接进行赋值，运算效率要好
    a = a +3; // 这一种是否是先计算再赋值给a
    printf("a的结果是%i\n",a); // 复合赋值运算，会先进行右边的表达式获得的值在赋值给左边的变量

自增，自减运算符

  • 自增自减的第一种写法： 变量++，变量--
    int result = 10;
    result++; result++; printf("变量++，自增后的result值为：%i\n",result); // 12 // 若是想让某一个数减1，可使用变量--，--变量 int value = 5; value--; printf("变量--，自增后的value值为：%i\n",value); // 4
  • 自增自减的第二种写法： --变量，++变量
// 第二种写法：++变量，--变量
    int result1 = 10;
    ++result1; printf("++变量，自增后的result1值为：%i\n",result1); // 11 int result2 = 5; --result2; printf("++变量，自增后的result1值为：%i\n",result2); // 4
  • ​ ++,-- 在变量前面和++，-- 在变量后面的区别(在变量以前先运算再自增,在变量以后先自增再运算)
    // ++,-- 在变量前面和++，-- 在变量后面的区别
    // ++ , -- 在后面时，先参与运算而后再自增
    int a = 10;
    int b = a++; printf("a的值是%i，b的值是%i\n",a,b);// a的值是11，b的值是10 注意看b的值是10,而不是11,这里是a先赋值给b,而后再自增的 // ++ --在变量以前时,是先自增再赋值 int c = 10; int d = ++c; printf("c的值是%i，d的值是%i\n",c,d); // c的值是11,d的值是11 注意看这里d的值一样是11,因此c是先自增再赋值给d
  • 自增,自减练习
    // 练习
    /*
    int a = 10;
    int b = (a++) + (++a);
    //  b = a++ ,此时a++的结果是11, 后面++a在a=11的基础上再自增,那么a的值就是12了,10+12
    //  a =12
    printf("b的值是%i,a的值是%i\n",b,a);
    */
    /*
    int a = 10;
    int b = (a++) + (a++);
    printf("b的值是%i,a的值是%i\n",b,a); // b = 10 + 11 , a = 12
    */
    /*
    int a = 10;
    int b = (++a) + (++a);
    printf("b的值是%i,a的值是%i\n",b,a); // b = 11 + 12 ,a = 12
    */
    /*
    int a = 10;
    int b = (++a) + (a++);
    printf("b的值是%i,a的值是%i\n",b,a); // b = 11 + 11, a = 12
    */
    int a = 10;
    int b = (a++) + (a--); printf("b的值是%i,a的值是%i\n",b,a); // b = 10 + 11 , a = 10
  • 自增的拆分
    // 自增的拆分
    int a = 10;
    int b = a++; // 拆分: // 1, int b = a; // 2, int a = a+1; printf("b的值是%i,a的值是%i\n",b,a); // b = 10,a = 11 int c = 10; int d = ++c; // 拆分 // 1,int c = c + 1; // 2,int d = c; printf("d的值是%i,c的值是%i\n",d,c); // 拆分以后,只是两个表达式的顺序反了. 若是有时确实难懂的话不妨拆分一下

sizeof运算符

  • 介绍:sizeof运算符能够用来计算一个变量或一个常量,一种数据类型所占的内存节数

  • 格式:sizeof(变量/常量/数据类型)

  • 注意:sizeof 不是一个函数而是一个运算符(只要是运算符就会有一个返回值)

  • 计算常量的内存字节

    // 使用 sizeof 计算常量的内存字节
    int number = sizeof(10.9);
    printf("10.9的e内存字节是%i\n",number); // 8
  • 计算变量的内存字节
    int a = 10;
    // int number = sizeof(a); // 只要是运算符就会有返回值
    int number = sizeof a; // 不加s括号e也能够
    printf("a的内存字节是%i\n",number);
  • 计算数据类型的内存字节(sizeof的括号不能省略)
    // 使用 sizeof 计算数据类型的内存字节
    int numChar = sizeof(char);
    printf("char 数据类型占用%i个字节\n",numChar); // 1
    int numInt = sizeof(int); printf("int 数据类型占用%i个字节\n",numInt); // 4 int numDouble = sizeof(double); printf("double 数据类型占用%i个字节\n",numDouble); // 8 int numFloat = sizeof(float); printf("float 数据类型占用%i个字节\n",numFloat); // 8

逗号运算符

  • 在 C 语言中逗号也是一个运算符,称之为逗号运算符,其功能是把多个表达式链接起来组成一个表达式,成为逗号表达式

  • 格式: 表达式 1,表达式 2,表达式....表达式 n;

  • 例如:a = a + 1,b = 3*4;

  • 结合性:从左到右结合性

    // 逗号运算符,从左到右依次计算表达式的结果,只要是运算符就会有结果,逗号运算符也不例外
    int a = 10;
    int b = 5; int result; a = a + 10,b = b - 1,result = a + b; printf("a的值是%i,b的值是%i,result 的值是%i\n",a,b,result);
  • 逗号表达式的结果是最后一个表达式的结果
// 定一个一个变量 number 来接收逗号表达式的结果,每一个表达式用括号括起来,总体再括起来,逗号表达式的结果是最后一个逗号表达式的结果
    int number =  ((a = a + 10),(b = b - 1),(result = a + b));
    printf("a 的值是%i,b 的值是%i,result 的值是%i,number 的值是%i\n",a,b,result,number);

关系运算符

  • 在 c 语言中条件成立为真,条件不成立为假,判断条件是否成立就是判断条件的真假
  • 怎么判断条件的真假呢? C 语言中规定任何数值都有本身的真假性,任何非 0 的都为真,也就是说 100,-50,2.3这些都是真,只有 0 是假的
  • 关系运算符的结果只有两个结果,真和假

C 语言的比较运算中， “真”用数字“1”来表示， “假”用数字“0”来表示。

运算符 术语 示例 结果
== 相等于 4 == 3 0
!= 不等于 4 != 3 1
< 小于 4 < 3 0
> 大于 4 > 3 1
<= 小于等于 4 <= 3 0
>= 大于等于 4 >= 1 1
  • 关系运算符的返回值要么真要么假
    // > , < , >= , <= , == , !=
    int a = 10;
    int b = 5; // 怎么知道 a>b 呢? 任何的运算符都有结果
    int c = 20; int result = a > b; int result1 = a > c; printf("result的值是%i\n",result); // 1 printf("result1的值是%i\n",result1); // 0
  • 关系运算符的优先级: > < >= <=的优先级大于 == , !=
    // 关系运算符的优先级: > < >= <=的优先级大于 == , !=
    int a = 10;
    int b = 5; int result = 1 == a > b; // 先计算 a 是否大于 b,再拿这个结果与 1 是否相等, printf("result 的值是%i",result); // 1
  • 算术运算符的优先级大于关系运算符(比较运算符)
    // 算术运算符的优先级大于关系运算符
    int result = 1 + 1 > 2+2;
    printf("result 的值是%i\n",result);  // 0,先计算 1+1,在计算 2+2,再拿 2>4?
  • 关系运算符的结合性是左结合性
    // 关系运算符的结合性是左结合性
    int result = 10 > 5 > 20;
    printf("result 的值是%i\n",result); // 0,先计算 10>5,再拿这个值与 20作比较
  • 若是优先级和结合性同时存在,那就先优先级,再结合性
    // 若是优先级和结合性同时存在,那就先优先级,再结合性
    int result = 10 + 1 > 5 + 4 == 3 > 1;
    // 先计算 10+1,再计算 5+4,这两个算术运算符,得出 11 > 9 == 3>1
    // 再计算 11 > 9 ,和 3 > 1 这两个优先级比较高的比较运算符表达式,
    // 最后计算 1 == 1 等于的表达式
    printf("result 的值是%i\n",result); // 11 > 9 == 3 > 1 ---> 1 == 1 ---> 1
  • 开发中没有人会按照上面那么写的
    int result1 = (10+1) > (5+4) == (3>1);
    printf("result1 的值是%i\n",result1); // h实际开发中为了阅读,仍是加上括号

逻辑运算符

  • 有时候咱们须要知足多个条件同时成立才能执行代码,好比登陆:须要输入正确的用户名,和正确的密码,才能登陆.因此c 语言提供了逻辑运算符

  • C 语言中提供了三个逻辑运算符

    • && 逻辑与 表达式 1 && 表达式 2
    • || 逻辑非 表达式 1 || 表达式 2
    • ! 逻辑非 ! 表达式 2

  • 逻辑运算符的运算结果只有两个真和假

  • 逻辑与:只有表达式都为真,结果才是真,其他都是假

    • 结合性:从左至右
    // 逻辑与(一假则假)
    int result = 10 > 7 && 5 > 3; // 10>7为真,5>3 为真
    printf("result = %i\n",result); // 1
    int result1 = 10 > 90 && 8 >1; // 10 > 90为假
    printf("result1 = %i\n",result1); // 0
  • 逻辑或:只要有一个表达式为真,结果就是真,若是表达式都是假,结果才是假
    • 结合性:从左至右
    // 逻辑或 (一真则真)
    int result = 10 > 8 || 9 > 7;
    printf("result = %i\n",result); // 都为真--真
    
    int result1 = 10 > 8 || 9 > 10; printf("result1 = %i\n",result1); // 一个为真--真 int result2 = 10 > 11 || 9 > 10; printf("result2 = %i\n",result2); // 都为假--假 int result3 = 10 > 11 || 9 > 8; // 一个为真--真 printf("result3 = %i\n",result3);
  • 逻辑非(若是表达式为真,则为假,若是表达式为假,则为真)---取反
    • 结合性:从右至左
    // 逻辑非
    int result = ! 10; // 0
    int result1 = ! 0; // 1
    printf("result = %i\n",result);
    printf("result1 = %i\n",result1);
  • 注意点;C 语言规定,任何数值都有真假性,非 0 既真,全部的逻辑运算符能够直接约数值进行计算
  • 逻辑与的特色是一假则假,因此若是前面的表达式是假的话,那么后面的表达式就不会计算了
    int a = 10;
    int result = 10 < 8 && a++ > 5; // a = 10,result = 0
    // 因为 10 < 8 为假,因此后面的表达式就不会计算了,a++ 后,a 的值就没有自增
    int b = 20; int result1 = 10 > 8 && b++ >5; // 10 > 8 为真,后面的表达式继续计算,因此 b 的值是 21 printf("a = %i,result = %i\n",a,result); printf("b = %i,result1 = %i\n",b,result1);
  • 逻辑或的特色是一真则真,因此若是前面的表达式是真的话,那么后面的表达式就不会计算了
    int a = 10;
    int result = 10 > 8 || a++ > 5; // a = 10,result = 0
    // 因为 10 > 8 为真,因此后面的表达式就不会计算了,a++ 后,a 的值就没有自增
    int b = 20; int result1 = 10 < 8 || b++ >5; // 10 < 8 为假,后面的表达式继续计算,因此 b 的值是 21 printf("a = %i,result = %i\n",a,result); printf("b = %i,result1 = %i\n",b,result1);

  • 以上两个逻辑运算符的特色称之为:逻辑运算符的短路

  • 判断一个数值是否在一个范围内

    int a = 10;
    if (a > 3 && a < 100){ printf("a在 3-100 之间"); } else{ printf("a 不在 3-100 之间"); }

三目运算符

  • 格式: 条件表达式 ? 结果 A: 结果 B

    • 若是表达式为真,返回结果 A,若是表达式为假,返回结果 B

  • 结合性:左结合性

    // 三目运算符
    int a = 10;
    int b = 20; int result = a > b; printf("result = %i\n",result); // 若是我想获取两个数之间的最大数呢? if (a>b){ printf("a 和 b 之间最大数是%i\n",a); }else{ printf("a 和 b 之间最大数是%i\n",b); } // 但是上面的办法太麻烦了,x要写这么多行代码 int maxNum = a > b ? a:b; // 这句话的意思是,若是a> b,那就返回 a,若是 a 不大于 b 的话,那就返回 b printf("a 和 b 之间最大数是%i\n",maxNum);

 

  • 三目运算符练习
    // 从控制台输入三个整数,返回最大的整数
    printf("请输入三个整数以逗号隔开,回车结束\n");
    int num1,num2,num3; scanf("%i,%i,%i",&num1,&num2,&num3); int temp = num1 > num2 ? num1 : num2; // 比较 num1 和num2 中的最大值 int maxNum = temp > num3 ? temp : num3; // 拿到 num1 和 num2 的最大值再与 num3 作比较,返回最大值 printf("num1,num2,num3 之间的最大值是:%i\n",maxNum); int maxNum1 = (num1 > num2 ? num1 : num2) > num3 ? (num1 > num2 ? num1 : num2) : num3; // 不推荐这种写法是由于,问号以前计算了一次num1 和num2 的最大值,问号表达式以后又计算了一次,无疑消耗了性能 printf("num1,num2,num3 之间的最大值是:%i\n",maxNum1);
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程