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教程