[C語言]進階|數據類型: 整數, 浮點, 邏輯, 類型轉換和條件運算

時間 2019-11-12

標籤 c語言進階數據類型整數浮點邏輯轉換條件運算简体版

原文原文鏈接

---------------------------------------------------------------------------------html

【C語言的類型】架構

1. 整型(都分爲有符號signed和無符號unsigned兩個版本)：性能

char, short, int, long, long long　編碼

　　# 注：long long 爲C99標準，是64位長整型，須要編譯器對C標準的支持。spa

引：C標準規定整型值相互間大小規則，長整型至少應該和整型同樣長，而整型至少應該和短整型同樣長。操作系統

short int 至少爲16位，long int 至少32位，至於缺省的 int 到底是16仍是32，一般選擇的缺省值是這種機器最爲高效的位數。指針

頭文件 limits.h 說明了各類不一樣的整數類型的特色。　　———《C和指針》code

2. 浮點型：htm

float，double，long doubleblog

3. 布爾類型：

bool：經過頭文件定義，只須要引入stdbool.h便可使用

　　# 注：C99以前沒有布爾型，C99標準引入新關鍵字_Bool表示布爾類型，引入stdbool.h能夠用 bool 代替_Bool，true代替1，false代替0

4. 指針

自定義類型

【類型有什麼不一樣】

類型名稱：int，long，double

輸入輸出時的格式化：%d，%ld，%lf

所表達的數的範圍：char < short < int < float < double # 注意，它們的大小與編譯器和操做系統

內存中所佔據的大小：1個字節到16個字節，使用sizeof()獲得大小，sizeof是靜態運算符，它的結果在編譯時刻就決定了，sizeof的運算不會計算。

內存中的表達形式：二進制數（補碼），編碼

【整數類型】

//  main.c
//  Created by weichen on 15/3/25.
//  Copyright (c) 2015年 weichen. All rights reserved.
#include <stdio.h>

int main(int argc, const char * argv[]) {
    printf("sizeof(char)=%ld\n", sizeof(char));         //1 字節（8bite）
    printf("sizeof(short)=%ld\n", sizeof(short));       //2 字節
    printf("sizeof(int)=%ld\n", sizeof(int));           //4 取決於編譯器（cpu），一般的意義是「1個字」
    printf("sizeof(long)=%ld\n", sizeof(long));         //8 取決於編譯器（cpu），一般的意義是「1個字」
    printf("sizeof(long long)=%ld\n", sizeof(long long));//8 8字節

    //gcc ./test.c -o -m32  #以32平臺架構編譯顯示
    
    
    char c = 255;
    int i = 255;
    printf("c=%d, i=%d\n", c, i); //c=-1, d=255
    
    unsigned char d = 255;        //用來表示整數不以補碼的形式表示，看作純二進制
    printf("d=%d\n", d);          //d=255
    
    char e = 127;
    e = e + 1;
    printf("e=%d\n", e);          //-128
    
    unsigned char f = 127;
    f = f + 1;
    printf("f=%d\n", f);          //128
    
    return 0;
}

//int 是用來表達寄存器的
/*
 計算機以二進制表達正整數，表達負數用補碼：
 
    0  ->  00000000
    1  ->  00000001
 
    11111111 + 00000001 -> 1000000000 \
                                      |
    00000000 - 00000001 -> （負1）     |
                                      |
 (1)00000000 - 00000001 -> 11111111   /

   ① 11111111被當作純二進制時，是255，被看成補碼時，是-1
   ② 一樣，對於-a，實際是(2^n - 1)，n是這種類型的位數；補碼是0-a
   ③ 補碼的意思是拿補碼和原碼能夠加出一個溢出的「零」
*/


//數的範圍
/*
 一個字節（8位），表達的是：
 00000000 - 11111111

 其中，00000000 -> 0
     11111111 ~ 10000000 -> -1 ~ -128   //用補碼錶示
00000001 ~ 01111111 -> 1 ~ 127          //純二進制表示
*/

//unsigned
/*
 若是一個字面量常數想要表達本身是unsigned，能夠在後面加u或U
    255U
 用l或L表示long（long）
 unsigned的初衷並不是擴展數能表達的範圍，而是爲了作純二進制運算，主要是爲了移位。
 */

//整數越界
/*
 整數是以純二進制方式進行計算的，因此：
 11111111 + 1 -> 100000000 -> 0
 01111111 + 1 -> 10000000  -> -128
 10000000 - 1 -> 01111111  -> 127
 */

//整數的輸入輸出
/*
 只有兩種形式：int或long long
 %d：int
 %u：unsigned
 %ld：long long
 %lu：unsigned long long
 */

//8進制和16進制
/*
 一個以0開始的數字字面量是8進制
 一個以0x開始的數字字面量是16進制
 %o用於8進制，%x用於16進制
 8進制和16進制只是如何把數字表達爲字符串，與內部如何表達數字無關
 
 16進制很適合表達二進制數據，由於4位二進制正好是一個16進制位
 8進制的一位數字正好表達3位二進制
    由於早期計算機的字長是12的倍數，而非8
 */

//選擇整數類型
/*
 爲何整數要有那麼多種？
    爲了準確表達內存，作底層程序的須要
 沒有特殊須要，就選擇int
    如今的CPU的字長廣泛是32位或64位，一次內存讀寫就是一個int，一次計算也是一個int，選擇更短的類型不會更快，甚至可能更慢
    現代的編譯器通常會涉及內存對齊，因此更短的類型實際在內存中有可能也佔據一個int的大小（雖然sizeof告訴你更小）
 unsigned與否只是輸出的不一樣，內部計算是同樣的，因此現代高級語言大多已不區分非負。
 */

【浮點類型】

//  main.c  
//  Created by weichen on 15/4/6.
//  Copyright (c) 2015年 weichen. All rights reserved.
#include <stdio.h>

int main(int argc, const char * argv[]) {
    // 浮點類型
    /*
     類型     字長      範圍                                                      有效數字
     float    32   ±(1.20*10^-38 ~ 3.40*10^38), 0, ±inf(無窮大), nan(非數字)       7(準確的位數)
     double   64   ±(2.2*10^-308 ~ 1.79*10^308),0, ±inf, nan                     15
     
     類型     scanf     printf
     float     %f       %f，%e(科學計數法)
     double    %lf      %f，%e
     */
    
    double ff = 12.345;
    printf("%e, %f\n", ff, ff);     //1.234500e+01, 12.34500
    printf("%E\n", ff);             //1.234500E+01
    
    //在%和f之間加上.n能夠指定輸出小數點後幾位，這樣的輸出是作四捨五入的
    printf("%.3f\n", -0.0049);      //-0,005    小數點後保留三位
    printf("%.30f\n", -0.0049);     //-0.004899999999999999841793218991
    printf("%.3f\n", -0.00049);     //0.000
    
    printf("%f\n", 1.0/0.0);        //inf
    printf("%f\n", -1.0/0.0);       //-inf
    printf("%f\n", 0.0/0/0);        //nan
    //printf("%d\n", 12/0);           //沒法編譯經過,無窮大沒法用整數表達，能夠用浮點數表達
    
    float a, b, c;
    a = 1.34f;
    b = 1.22f;
    c = a + b;
    if( c == 2.56) {
        printf("a = b\n");
    } else {
        printf("a != b, c=%.10f 或 %f\n", c, c); //a != b, c=2.5599999428 或 2.560000(七位有效數字四捨五入而來)
    }
    
    //浮點運算的精度
    /*
     帶小數點的字面量是double而非float
     float須要用f或F後綴來代表身份
     float1 == float2 可能失敗
     fabs(f1-f2) < 1e^-12   #計算絕對值與最小偏差比較，來判斷是否相等
     */
     
    //浮點數的內部表達
    /*
     浮點數在計算時是由專用的硬件部件實現的
     計算double和float所用的部件是同樣的
     */
    
    //選擇浮點類型
    /*
     若是沒有特殊須要，只使用double
     現代CPU能直接對double作硬件運算，性能不會比float差，在64位的機器上，數據存儲的速度也不比float慢 
     */
    
    return 0;
}

【邏輯類型】

//  main.c
//  Created by weichen on 15/4/8.
//  Copyright (c) 2015年 weichen. All rights reserved.
#include <stdio.h>
#include <stdbool.h>

int main(int argc, const char * argv[]) {
    // bool
    /*
     C語言本沒有邏輯類型，在內部計算中使用整數表達關係運算和邏輯運算的結果，0表示false，而非0的值表示true。
     在C99中，也沒有固定的邏輯類型，可是經過一個頭文件定義了能夠直接使用的true和false這兩個值，以及bool這個類型。
     邏輯運算則是C語言固有的成分。
     
     #include <stdbool.h>
     以後就可使用bool和true、false
    */     
    bool a = 6 < 5;
    bool b = true;
    
    printf("%d\n", a);  //0
    printf("%d\n", b);  //1
    
    //邏輯運算
    /*
     邏輯運算是對邏輯量進行的運算，結果只有0或1
     邏輯量是關係運算或邏輯運算的結果
     ！ 邏輯非
     && 邏輯與
     || 邏輯或
     
     若是要表達數學中的區間，如：x∈(4,6) 或 x∈[4,6] 應該如何寫C的表達式？
     像 4 < x < 6 這樣的式子，不是C能正確計算的式子，由於 4 < x 的結果是一個邏輯值(0或1),
     應該寫成 (x > 4 && x < 6) 或 (x >= 4 && x <= 6)
     判斷一個字符a是不是大寫字母？ a >= 'A' && a <= 'Z'
     
     優先級    運算符         結合性
     1        ()            從左到右
     2        ! + - ++ --   從右到左（單目+和-）
     3        * / %         從左到右
     4        + -           從左到右
     5        < <= > >=     從左到右
     6        == !=         從左到右
     7        &&            從左到右
     8        ||            從左到右
     9     = += -= *= /= %= 從右到左
     
     */
    
    return 0;
}

【類型轉換與條件運算】

//  main.c
//  Created by weichen on 15/4/8.
//  Copyright (c) 2015年 weichen. All rights reserved.
#include <stdio.h>

int main(int argc, const char * argv[]) {

    //自動類型轉換
    //當運算符的兩邊出現不一致的類型時，會自動轉換成較大的類型，能表達範圍更大的數
    
    //char -> short -> int -> long -> long long
    //int -> float -> double
    
    //對於printf,任何小於int的類型會被轉換成int；float會被轉換成double
    //可是scanf不會，要輸入short，須要%hd，即short int，要輸入long long，須要%ld。 （h：短整數或單精度浮點數，l：長整數或雙精度浮點數）
    
    
    // 強制類型轉換的優先級高於四則運算
    //1. (類型)值
    double a = 1.0;
    double b = 2.0;
    int i = (int)a/b;
    int j = (int)(a/b);
    
    int c = 5;
    int d = 6;
    double e = (double)(c/d);
    
    printf("%d\n", i);
    printf("%d\n", j);
    printf("%lf\n", e);
    
    //2. 小的變量不總能表達大的量
    printf("%d\n", (short)32768);   //-32768,short最多能表示32767
    printf("%d\n", (char)32768);    //0
    
    //3. 強制類型轉換隻是從那個變量計算出了一個新的類型的值，它並不改變那個變量，不管是值仍是類型都不改變
    int k = 32768;
    short kk = (short)k;
    printf("%d\n", k);  //32768
    
    //條件運算符
    //c = (count > 20) ? count - 10 : count + 10;
    //條件運算符的優先級高於賦值運算符，可是低於其餘運算符
    
    
    //逗號運算符
    //逗號用來鏈接兩個表達式，並以其右邊的表達式的值做爲它的結果。逗號的優先級是全部的運算符中最低的，因此它兩邊的表達式會先計算；逗號的組合關係是自左向右，因此左邊的表達式會先計算，而右邊的表達式的值就留下來做爲逗號運算的結果。
    //在for中使用， for(i=0,j=0;i<j;i++,j--){}，這裏逗號劃分兩個表達式。
    int n;
    int m;
    n = 1+2,3+4;        //n=1+2是一個表達式，3+4沒有用到，最終結果是3
    m = (1+2,3+4);      //組合關係，右邊表達式的值做爲結果
    printf("%d\n", n);  //3
    printf("%d\n", m);  //7
    
    return 0;
}