運算符基本概念

• 和數(shù)學中的運算符一樣, C語言中的運算符是告訴程序執(zhí)行特定算術或邏輯操作的符號

  • 例如告訴程序, 某兩個數(shù)相加, 相減,相乘等

    
    

• 什么是表達式

  • 表達式就是利用運算符鏈接在一起的有意義,有結果的語句;
  • 例如: a + b; 就是一個算數(shù)表達式, 它的意義是將兩個數(shù)相加, 兩個數(shù)相加的結果就是表達式的結果
  • 注意: 表達式一定要有結果

運算符分類

• 按照功能劃分:
  • 算術運算符
  • 賦值運算符
  • 關系運算符
  • 邏輯運算符
  • 位運算符
• 按照參與運算的操作數(shù)個數(shù)劃分:
  • 單目運算
    • 只有一個操作數(shù) 如 : i++;
  • 雙目運算
    • 有兩個操作數(shù) 如 : a + b;
  • 三目運算
    • C語言中唯一的一個,也稱為問號表達式 如: a>b ? 1 : 0;

運算符的優(yōu)先級和結合性

• 早在小學的數(shù)學課本中,我們就學習過"從左往右,先乘除后加減,有括號的先算括號里面的", 這句話就蘊含了優(yōu)先級和結合性的問題
• C語言中,運算符的運算優(yōu)先級共分為15 級谒撼。1 級最高,15 級最低
  • 在C語言表達式中,不同優(yōu)先級的運算符, 運算次序按照由高到低執(zhí)行
  • 在C語言表達式中,相同優(yōu)先級的運算符, 運算次序按照結合性規(guī)定的方向執(zhí)行

算數(shù)運算符

• 注意事項
  • 如果參與運算的兩個操作數(shù)皆為整數(shù), 那么結果也為整數(shù)
  • 如果參與運算的兩個操作數(shù)其中一個是浮點數(shù), 那么結果一定是浮點數(shù)
  • 求余運算符, 本質上就是數(shù)學的商和余"中的余數(shù)
  • 求余運算符, 參與運算的兩個操作數(shù)必須都是整數(shù), 不能包含浮點數(shù)
  • 求余運算符, 被除數(shù)小于除數(shù), 那么結果就是被除數(shù)
  • 求余運算符, 運算結果的正負性取決于被除數(shù),跟除數(shù)無關, 被除數(shù)是正數(shù)結果就是正數(shù),被除數(shù)是負數(shù)結果就是負數(shù)
  • 求余運算符, 被除數(shù)為0, 結果為0
  • 求余運算符, 除數(shù)為0, 沒有意義(不要這樣寫)

#include <stdio.h>
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
    
    // 算術運算符的結合性和優(yōu)先級
    // 結合性: 左結合性, 從左至右
    int c = 50;
    result = a + b + c; // 15 + c;  65;
    printf("%i\n", result);
    
    // 優(yōu)先級: * / % 大于 + -
    result = a + b * c; // a + 250; 260;
    printf("%i\n", result);
}

#include <stdio.h>
int main(){
    // 整數(shù)除以整數(shù), 結果還是整數(shù)
    printf("%i\n", 10 / 3); // 3

    // 參與運算的任何一個數(shù)是小數(shù), 結果就是小數(shù)
    printf("%f\n", 10 / 3.0); // 3.333333
}

#include <stdio.h>
int main(){
    // 10 / 3 商等于3, 余1
    int result = 10 % 3;
    printf("%i\n", result); // 1

    // 左邊小于右邊, 那么結果就是左邊
    result = 2 % 10;
    printf("%i\n", result); // 2

    // 被除數(shù)是正數(shù)結果就是正數(shù),被除數(shù)是負數(shù)結果就是負數(shù)
    result = 10 % 3;
    printf("%i\n", result); // 1
    result = -10 % 3;
    printf("%i\n", result); // -1
    result = 10 % -3;
    printf("%i\n", result); // 1
}

賦值運算符

• 簡單賦值運算符

#include <stdio.h>
int main(){
    // 簡單的賦值運算符 =
    // 會將=右邊的值賦值給左邊
    int a = 10;
    printf("a = %i\n", a); // 10
}

• 復合賦值運算符

#include <stdio.h>
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
}

• 結合性和優(yōu)先級

#include <stdio.h>
int main(){
    int number = 10;
    // 賦值運算符優(yōu)先級是14, 普通運算符優(yōu)先級是3和4, 所以先計算普通運算符
    // 普通運算符中乘法優(yōu)先級是3, 加法是4, 所以先計算乘法
    // number += 1 + 25; number += 26; number = number + 26; number = 36;
    number += 1 + 5 * 5;
    printf("number = %i\n", number); // 36
}

自增自減運算符

• 在程序設計中,經(jīng)常遇到“i=i+1”和“i=i-1”這兩種極為常用的操作。
• C語言為這種操作提供了兩個更為簡潔的運算符,即++和--

• 自增
  • 如果只有單個變量, 無論++寫在前面還是后面都會對變量做+1操作

#include <stdio.h>
int main(){
    int number = 10;
    number++;
    printf("number = %i\n", number); // 11
    ++number;
    printf("number = %i\n", number); // 12
}

• • 如果出現(xiàn)在一個表達式中, 那么++寫在前面和后面就會有所區(qū)別
  • 前綴表達式:++x, --x;其中x表示變量名,先完成變量的自增自減1運算,再用x的值作為表達式的值;即“先變后用”,也就是變量的值先變,再用變量的值參與運算
  • 后綴表達式:x++, x--;先用x的當前值作為表達式的值,再進行自增自減1運算。即“先用后變”,也就是先用變量的值參與運算,變量的值再進行自增自減變化

#include <stdio.h>
int main(){
    int number = 10;
    // ++在后, 先參與表達式運算, 再自增
    // 表達式運算時為: 3 + 10;
    int result = 3 + number++;
    printf("result = %i\n", result); // 13
    printf("number = %i\n", number); // 11
}

#include <stdio.h>
int main(){
    int number = 10;
    // ++在前, 先自增, 再參與表達式運算
    // 表達式運算時為: 3 + 11;
    int result = 3 + ++number;
    printf("result = %i\n", result); // 14
    printf("number = %i\n", number); // 11
}

• 自減

#include <stdio.h>
int main(){
    int number = 10;
    // --在后, 先參與表達式運算, 再自減
    // 表達式運算時為: 10 + 3;
    int result = number-- + 3;
    printf("result = %i\n", result); // 13
    printf("number = %i\n", number); // 9
}

#include <stdio.h>
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++;
  • 企業(yè)開發(fā)中盡量讓++ -- 單獨出現(xiàn), 盡量不要和其它運算符混合在一起

int i = 10;
int b = i++; // 不推薦
或者
int b = ++i; // 不推薦
或者
int a = 10;
int b = ++a + a++;  // 不推薦

• 請用如下代碼替代

int i = 10;
int b = i; // 推薦
i++;
或者;
i++;
int b = i; // 推薦
或者
int a = 10;
++a;
int b = a + a; // 推薦
a++;

• C語言標準沒有明確的規(guī)定煌妈，同一個表達式中同一個變量自增或自減后如何運算, 不同編譯器得到結果也不同, 在企業(yè)開發(fā)中千萬不要這樣寫

    int a = 1;
    // 下列代碼利用Qt運行時6, 利用Xcode運行是5
    // 但是無論如何, 最終a的值都是3
   //  在C語言中這種代碼沒有意義, 不用深究也不要這樣寫
   // 特點: 參與運算的是同一個變量, 參與運算時都做了自增自減操作, 并且在同一個表達式中
    int b = ++a + ++a;
    printf("b = %i\n", b); 

sizeof運算符

• sizeof可以用來計算一個變量或常量隘梨、數(shù)據(jù)類型所占的內存字節(jié)數(shù)

  • 標準格式: sizeof(常量 or 變量);

• sizeof的幾種形式

  • sizeof( 變量\常量 );
    • sizeof(10);
    • char c = 'a'; sizeof(c);
  • sizeof 變量\常量;
    • sizeof 10;
    • char c = 'a'; sizeof c;
  • sizeof( 數(shù)據(jù)類型);
    • sizeof(float);
    • 如果是數(shù)據(jù)類型不能省略括號

• sizeof面試題:

  • sizeof()和+=、*=一樣是一個復合運算符, 由sizeof和()兩個部分組成, 但是代表的是一個整體
  • 所以sizeof不是一個函數(shù), 是一個運算符, 該運算符的優(yōu)先級是2

#include <stdio.h>
int main(){
    int a = 10;
    double b = 3.14;
    // 由于sizeof的優(yōu)先級比+號高, 所以會先計算sizeof(a);
    // a是int類型, 所以占4個字節(jié)得到結果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;

#include <stdio.h>
int main(){
    int a = 10, b = 20, c;
    // ()優(yōu)先級高于逗號運算符和賦值運算符, 所以先計算()中的內容
    // c = (11, 21);
    // ()中是一個逗號表達式, 結果是最后一個表達式的值, 所以計算結果為21
    // 將逗號表達式的結果賦值給c, 所以c的結果是21
    c = (a + 1, b + 1);
    printf("c = %i\n", c); // 21
}

關系運算符

• 為什么要學習關系運算符
  • 默認情況下，我們在程序中寫的每一句正確代碼都會被執(zhí)行鸠窗。但很多時候，我們想在某個條件成立的情況下才執(zhí)行某一段代碼
  • 這種情況的話可以使用條件語句來完成驾讲，但是學習條件語句之前，我們先來看一些更基礎的知識：如何判斷一個條件是否成立

• C語言中的真假性
  • 在C語言中，條件成立稱為“真”蝎毡，條件不成立稱為“假”厚柳，因此，判斷條件是否成立沐兵，就是判斷條件的“真假”

  • 怎么判斷真假呢别垮？C語言規(guī)定，任何數(shù)值都有真假性扎谎，任何非0值都為“真”碳想，只有0才為“假”。也就是說毁靶，108胧奔、-18、4.5预吆、-10.5等都是“真”龙填，0則是“假”

    
    

• 關系運算符的運算結果只有2種：如果條件成立，結果就為1拐叉，也就是“真”岩遗；如果條件不成立，結果就為0凤瘦，也就是“假”

#include <stdio.h>
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
}

• 優(yōu)先級和結合性

#include <stdio.h>
int main(){
    // == 優(yōu)先級 小于 >, 所以先計算>
    // result = 10 == 1; result = 0;
    int result = 10 == 5 > 3;
    printf("result = %i\n", result); // 0
}

#include <stdio.h>
int main(){
    // == 和 != 優(yōu)先級一樣, 所以按照結合性
    // 關系運算符是左結合性, 所以從左至右計算
    // result = 0 != 3; result = 1;
    int result = 10 == 5 != 3;
    printf("result = %i\n", result); // 1
}

• 練習: 計算result的結果

int result1 = 3 > 4 + 7
int result2 = (3>4) + 7
int result3 = 5 != 4 + 2 * 7 > 3 == 10

• 注意點:
  • 無論是float還是double都有精度問題, 所以一定要避免利用==判斷浮點數(shù)是否相等

#include <stdio.h>
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
}

邏輯運算符

• 邏輯非
  • 格式: ! 條件A;
  • 運算結果: 真變假,假變真
  • 運算過程:
    • 先判斷條件A是否成立宿礁，如果添加A成立, 那么結果就為0，即“假”蔬芥；
    • 如果條件A不成立梆靖，結果就為1，即“真”
  • 使用注意:
    • 可以多次連續(xù)使用邏輯非運算符
    • !!!0;相當于(!(!(!0)));最終結果為1

#include <stdio.h>
int main(){
    // ()優(yōu)先級高, 先計算()里面的內容
    // 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"不會被執(zhí)行

#include <stdio.h>
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
}

#include <stdio.h>
int main(){
    int a = 10;
    int b = 20;
    // 邏輯與, 前面為假, 不會繼續(xù)執(zhí)行后面
    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"不會被執(zhí)行

#include <stdio.h>
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
}

#include <stdio.h>
int main(){
    int a = 10;
    int b = 20;
    // 邏輯或, 前面為真, 不會繼續(xù)執(zhí)行后面
    int result = (a == 10) || (++b);
    printf("result = %i\n", result); // 1
    printf("b = %i\n", b); // 20
}

• 練習: 計算result的結果

int result = 3>5 || 2<4 && 6<1;

三目運算符

• 三目運算符吊宋，它需要3個數(shù)據(jù)或表達式構成條件表達式

• 格式: 表達式1？表達式2(結果A)：表達式3(結果B)

  • 示例: 考試及格 ? 及格 : 不及格;
    

• 求值規(guī)則:

  • 如果"表達式1"為真颜武，三目運算符的運算結果為"表達式2"的值(結果A)璃搜，否則為"表達式3"的值(結果B)

示例:
    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);

• 注意點
  • 條件運算符的運算優(yōu)先級低于關系運算符和算術運算符,但高于賦值符
  • 條件運算符?和:是一個整體,不能分開使用

#include <stdio.h>
int main(){
    int a = 10;
    int b = 5;
    // 先計算 a > b
    // 然后再根據(jù)計算結果判定返回a還是b
    // 相當于int max= (a>b) ? a : b;
    int max= a>b ? a : b;
    printf("max = %i\n", max); // 10
}

#include <stdio.h>
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);
}

類型轉換

• 強制類型轉換(顯示轉換)

// 將double轉換為int
int a = (int)10.5;

• 算數(shù)轉換
  • 系統(tǒng)會自動對占用內存較少的類型做一個“自動類型提升”的操作, 先將其轉換為當前算數(shù)表達式中占用內存高的類型, 然后再參與運算

// 當前表達式用1.0占用8個字節(jié), 2占用4個字節(jié)
// 所以會先將整數(shù)類型2轉換為double類型之后再計算
double b = 1.0 / 2;

• 賦值轉換

// 賦值時左邊是什么類型,就會自動將右邊轉換為什么類型再保存
int a = 10.6;

• 注意點:
  • 參與計算的是什么類型, 結果就是什么類型

// 結果為0, 因為參與運算的都是整型
double a = (double)(1 / 2);
// 結果為0.5, 因為1被強制轉換為了double類型, 2也會被自動提升為double類型
double b = (double)1 / 2;

• • 類型轉換并不會影響到原有變量的值

#include <stdio.h>
int main(){
    double d = 3.14;
    int num = (int)d;
    printf("num = %i\n", num); // 3
    printf("d = %lf\n", d); // 3.140000
}

階段練習

• 從鍵盤輸入一個整數(shù), 判斷這個數(shù)是否是100到200之間的數(shù)
• 表達式 6＝＝6＝＝6 的值是多少拖吼？
• 用戶從鍵盤上輸入三個整數(shù),找出最大值,然后輸入最大值
• 用兩種方式交換兩個變量的保存的值

交換前
int a = 10; int b = 20;
交換后
int a = 20; int b = 10;

配套視頻地址：www.it666.com