2.1.1.2 計算機和程式語言：計算機的思維方式

程式的執行

• 解釋：藉助一個程式，那個程式能試圖理解你的程式，然後按照你的要求執行。
• 編譯：藉助一個程式，就像一個翻譯，把你的程式翻譯成計算機真正能懂的語言——機器語言——寫的程式，然後，這個機器語言寫的程式就能直接執行了。

11.2.1.3 變數：變數賦值與初始化

如果變數沒有初始化，就直接拿到右邊去用，會出現什麼呢？

得到了一個非常奇怪的結果，這是因為，在記憶體當中，我們有一個變數 i 我們沒有給它一個初始值，那麼，它正好在記憶體當中，在什麼地方，那個地方原本有一些什麼樣的值在裡頭，它就是那個值了。

12.2.1.4 變數：變數輸入

讀整數

• scanf("%d", &price);
• 要求scanf這個函式讀入下一個整數，讀到的結果賦值給變數price。

scanf和printf中，f表示format格式化的意思。

13.2.1.5 變數：常量VS變數

常量（C99）

• int change = 100 - price;
• 固定不變的數，是常數。直接寫在程式裡，我們稱作直接量（literal）。
• 更好的方式，是定義一個常量：const int AMOUNT = 100。

#include <stdio.h>

int main()
{
    const int AMOUNT = 100;
    int
 
 price = 0;

    printf("請輸入金額（元）：");
    scanf("%d", &price);

    int change = AMOUNT - price;
    printf("找您%d元。\n", change);

    return 0;
}

const（C99）

• const是一個修飾符，加在int的前面，用來給這個變數加上一個const（不變的）的屬性。這個const的屬性表示這個變數的值一旦初始化，就不能再修改了。
• int change = AMOUNT - price;
• 如果你試圖對常量做修改，把它放在賦值運算子的左邊，就會被編譯器發現，指出為一個錯誤。

14.2.1.6 變數：浮點數

%lf對應double。

16.2.2.2 表示式：運算子優先順序

注意這裡優先順序為1的單目運算子+、-

注意，a=6這個式子本身，是有結果的，也就是6。

17.2.2.3 表示式：交換變數

視訊中4分20秒開始出現Dev C++斷點除錯的使用方法。

20.3.0.1 程式設計練習解析：PAT再解釋

視訊中5分30秒開始，出現了對scanf的講解。

出現在scanf格式字串裡面的東西，是它一定要你輸入的東西，而不是它會給你看的東西。

28.3.2.1 分支：巢狀的if-else

(學習筆記：能用大括號就用大括號，避免歧義。)

29.3.2.2 分支：級聯的if-else if

30.3.2.3 分支：if-else的常見錯誤

31.3.2.4 分支：多路分支

(以下程式碼利用了switch-case的某個特性)

34.4.1.3 迴圈：do-while迴圈

(注意：while結尾要有分號)

35.4.2.1 迴圈應用：迴圈計算

(計算之前先儲存原始的值，後面可能有用。)

40.5.1.2 第三種迴圈：迴圈的計算和選擇

41.5.2.1 迴圈控制：迴圈控制

(判斷素數)

(上面的程式碼中，設定一個標誌位的寫法，我認為值得借鑑。)

(判斷素數的另一種寫法。)

43.5.2.3 迴圈控制：從巢狀的迴圈中跳出

#include <stdio.h>

int main()
{
    int x;
    int one, two, five;
    int exit = 0;

    scanf("%d", &x);
    for (one=1; one<x*10; one++)
    {
        for (two=1; two<x*10/2; two++)
        {
            for (five=1; five<x*10/5; five++)
            {
                if (one + tw0*2 + five*5 == x*10)
                    {
                        printf("可以用%d個1角加%d個5角得到%d元\n",
                            one, two, five, x);
                        exit = 1;
                        break;
                    }
            }
            if (exit == 1) break;
        }
        if (exit == 1) break;
    }
}

(
我主要對這裡的先設定一個標誌int exit = 0;，然後滿足某種條件後，改變標誌exit = 1，進而改變程式控制流程的寫法，感興趣。
)

45.5.3.2 迴圈應用：整數分解

(這一段的視訊值得重新一看，整數正序分解，因為C 語言中沒有趁手的工具，所以這裡實現起來略繁瑣。)

46.5.3.3 迴圈應用：求最大公約數

輾轉相除法求最大公約數

48.6.0.2 程式設計練習解析：程式設計練習解析4-1

(水仙花數程式設計實現，值得一看)

49.6.0.3 程式設計練習解析4-2：九九乘法表

50.6.0.4 程式設計練習解析4-3：統計素數求和

(關鍵詞：素數、質數)

52.6.0.6 程式設計練習解析5-0：n項求和

每一項的分子是前一項分子與分母的和，分母是前一項的分子。

(下面的程式碼值得一看)

54.6.1.1 資料型別：資料型別

sizeof

• 是一個運算子，給出某個型別或變數在記憶體中所佔據的位元組數
• sizeof(int)
• sizeof(i)

55.6.1.2 資料型別：整數型別

整數

• char：1位元組（8位元）
• short：2位元組
• int：取決於編譯器（CPU），通常的意義是“1個字”
• long：取決於編譯器（CPU），通常的意義是“1個字”
• long long：8位元組

當我們在說1臺計算機的字長的時候，我們指的是暫存器是多少寬的，也就是說，這個暫存器是幾個bit的。比如說，當我們說暫存器是32個bit的，每一個暫存器可以表達32個bit的資料，同時也是在說，CPU和RAM之間在總線上傳遞資料的時候，每一次的傳遞是32個bit，也就是說，當要從記憶體RAM取資料到CPU裡面去，每一次就會要取32個bit。

除了32，現在更常見的是64個bit。

字長在C語言中，反映為int。int表達的是1個暫存器的大小。所以，在不同的平臺、CPU上面，int會不一樣大。

56.6.1.3 資料型別：整數的內部表達

所以，為什麼我們要在計算機的內部使用補碼呢？

最大的好處就是，如果你有了一個補碼，你用補碼來表示這個-1，那麼，當你在做加法的時候，你不需要根據條件，去變換，把加+變成減-，你直接拿它去做普通的二進位制的加法，你就會得到你想要的那個結果。

57.6.1.4 資料型別：整數的範圍

整數越界

整數是以純二進位制方式進行計算的，所以：
- 11111111 + 1 –> 100000000 –> 0
- 01111111 + 1 –> 10000000 –> -128(這裡我存在疑問)
- 10000000 + 1 –> 01111111 –> 127

下面的程式碼似乎可以解答我的疑問：

-2^(32-1) —— 2^(32-1)-1

(關鍵詞：無符號數、unsigned
這整段視訊建議重新細看、加強理解。)

58.6.1.5 資料型別：整數的格式化

(如下的程式碼，建議看視訊的詳細解釋)

59.6.1.6 資料型別：選擇整數型別

60.6.1.7 資料型別：浮點型別

(inf：正負的無窮大
nan：表示不是一個有效的數字
這段視訊建議再去詳細看。)

科學計數法

#include <stdio.h>

int main()
{
    double ff = 1234.56789;
    printf("%e,%f\n", ff, ff);

    return 0;
}

輸出：

1234568e+03,1234.567890

#include <stdio.h>

int main()
{
    double ff = 1E-10;
    printf("%E,%f\n", ff,ff);

    return 0;
}

輸出：

1.000000E-10,0.000000

61.6.1.8 資料型別：浮點的範圍與精度

#include <stdio.h>

int main()
{
        printf("%f\n", 12.0/0.0);
        printf("%f\n", -12.0/0.0);
        printf("%f\n", 0.0/0.0);

        return 0;
}

$ gcc q.c
$ ./a.out
inf
-inf
-nan

62.6.1.9 資料型別：字元型別

63.6.1.10 資料型別：逃逸字元

(即轉義字元)

64.6.1.11 資料型別：型別轉換

65.6.2.1 其他運算：邏輯型別

bool

• #include <stdio.h>；
• 之後就可以使用bool和true、false。

67.6.2.3 其他運算：條件運算與逗號運算

條件運算子

• count = (count > 20) ? count - 10 : count + 10；
• 條件、條件滿足時的值和條件不滿足時的值。

69.7.1.2 函式的定義和使用：函式的定義和呼叫

(8分01秒開始出現了“單步進入”，講解了呼叫函式時，進入函式內部、單步除錯)

71.7.2.1 函式的引數和變數：函式原型

函式的先後關係

void sum(int begin, int end)
{
    int i;
    int sum = 0;
    for (i=begin; i<=end; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%的\n", begin, end, sum)
}

int main()
{
    sum(1,10);
    sum(20,30);
    sum(35,45);

    return 0;
}

像這樣把sum()寫在上面，是因為：

• C的編譯器自上而下順序分析你的程式碼；
• 在看到sum(1,10)的時候，它需要知道sum()的樣子；
• 也就是sum()要幾個引數，每個引數的型別如何，返回什麼型別。

void sum(int begin, int end);   // 宣告。這裡是函式原型

int main()
{
    sum(1,10);
    sum(20,30);
    sum(35,45);

    return 0;
}

void sum(int begin, int end)    // 定義。
{
    int i;
    int sum = 0;
    for (i=begin; i<=end; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%的\n", begin, end, sum)
}

72.7.2.2 函式的引數和變數：引數傳遞

C語言在呼叫函式時，只能傳值給函式。

當我們在main()函式中，做swap(a,b)的時候，是把a的值5交給了swap裡的a、把b的值6交給了swap裡的b。swap裡的a、b，與main裡的a、b完全沒有任何關係的。

我們在swap裡面，對a、b做的任何事情，是swap裡的引數a、b的事情，和main的a、b沒有任何關係。如上的程式碼，不能交換a、b的值。

73.7.2.3 函式的引數和變數：本地變數（區域性變數）

(關鍵詞：本地變數，也叫做區域性變數，因為英文是local，可翻譯為本地或區域性。
)

也有的地方把它叫做自動變數，把它叫做自動變數是和我們後面講的一件事情有關係，它的生存期和作用域的關係，把它叫做自動變數是因為，它的生存期是自動的。

(這一段，建議藉助視訊講解和在Dev C++編譯器中斷點除錯，可以輔助加強理解context等概念的含義。

關鍵詞：生存期、作用域
從1分59秒開始看。
從4分09秒開始看。)

本地變數的規則

(整段視訊都值得重新仔細看，介紹了作用域、生存期，可以結合Python的LEGB同時理解。

特別是8分39秒開始的地方，依次介紹了類似巢狀作用域、變數掩蓋之類的概念。)

76.8.1.2 陣列：陣列的使用

在記憶體中，陣列的單元是依次排列的，而且是緊密依次排列的。

77.8.1.3 陣列：陣列的例子

通常來說，用到陣列的程式，都需要這麼一些環節。

78.8.2.1 陣列運算：陣列運算

(以下值得一看)

79.8.2.2 陣列運算：陣列例子

(判斷素數、質數)

(求解素數的另外一種思路的演算法。)

(虛擬碼)

80.8.2.3 陣列運算：二維陣列

81.9.1.1 指標：取地址運算

為什麼變數會有地址？

因為 C 語言的變數，是放在記憶體裡的。每 1 個變數，比如說 int ，可能是 4 個位元組，在記憶體中要佔一定的地方，放在某個地方，就有 1 個地址。 & 運算子就是把地址拿出來。

(整段視訊都值得重新看，
特別是6分38秒開始的，
關鍵詞：C語言的記憶體模型、變數的地址、記憶體中的堆疊stack、自頂向下、分配變數。
)

#include <stdio.h>

int main(void)
{
        int a[10];

        printf("%p\n", &a);
        printf("%p\n", a);
        printf("%p\n", &a[0]);
        printf("%p\n", &a[1]);

        return 0;
}

輸出：

$ gcc q.c
$ ./a.out
0x7ffe025df0d0
0x7ffe025df0d0
0x7ffe025df0d0
0x7ffe025df0d4

82.9.1.2 指標：指標

(最後2行，p為int型指標，q為int型、不是指標。)

當我們說， p 指向了 i，實際的意思是，p 的值是變數 i 的地址。

#include <stdio.h>

void f(int *p);
void g(int k);

int main(void)
{
        int i = 6;
        printf("&i=%p\n", &i);
        f(&i);
        g(i);
        return 0;
}

void f(int *p)
{
        printf(" p=%p\n", p);
        printf("*p=%d\n", *p);
}

void g(int k)
{
        printf("k=%d\n", k);
}

輸出：

$ gcc w.c
$ ./a.out
&i=0x7ffd4447a5d4
 p=0x7ffd4447a5d4
*p=6
k=6

這就意味著，通過 *p 這個指標，我們訪問到了 p 所指的 int i 裡面的值。

增加一行程式碼 *p = 26; ：

#include <stdio.h>

void f(int *p);
void g(int k);

int main(void)
{
        int i = 6;
        printf("&i=%p\n", &i);
        f(&i);
        g(i);
        return 0;
}

void f(int *p)
{
        printf(" p=%p\n", p);
        printf("*p=%d\n", *p);
        *p = 26;
}

void g(int k)
{
        printf("k=%d\n", k);
}

輸出：

$ gcc w.c
$ ./a.out
&i=0x7ffd8ecfb624
 p=0x7ffd8ecfb624
*p=6
k=26

k=26 意味著，在經歷了 f 函式的呼叫了之後， i 的值被改了。

地址值 &i 被傳進了函式 f(int *p)，這裡，仍然是值的傳遞，因為傳進來的是地址，所以，通過這個地址，在函式內部，可以以這種方式，訪問到外面的 i 變數。

因為 p 的值，就是 i 的地址。 *p 就代表了 i 。

當我們做 *p = 26 這個運算的時候，我們實際做的事情，是對 i 做的。

83.9.1.3 指標：指標的使用

84.9.1.4 指標：指標與陣列

(函式引數裡的陣列是指標。
從視訊0分59秒開始看起)

(“*ar、ar[]在函式引數表中出現，是等價的”)

(const 常量)

85.9.1.5 指標：指標與const

上圖。如果指標是const，比如int * const q = &i;，在這種情況下，q這個指標是const，它的意思是說，q的值不能被改變，什麼是q的值？就是i的地址，就是q指向了i這個事實不能被改變，也就是q不能再指向別人了，它們之間的關係是永久的。

(對上圖和上上圖的一點說明：)
p可以指向別人，i可以被賦以別的值，但是通過p去修改i就不可以。

如果const在*前面，那麼，表示它所指的東西不能被修改；
如果const在*後面，那麼，表示指標不能被修改；

86.9.2.1 指標運算：指標運算

當我們給一個指標加1的時候，它不是在地址值上加1，它在地址值上加一個sizeof(那個指標所指的型別)。

所以對指標做一個加1的動作，意味著，我們要把它移到下一個單元去。

(當做兩個指標相減的時候，它給你的是兩個地址的差除以sizeof(它的型別)，也就是，在這兩個地址之間，有幾個這樣型別的東西在，或者說，能放幾個這樣型別的東西。)

87.9.2.2 指標運算：動態記憶體分配

(0分52秒開始，略為完整地介紹了動態記憶體分配malloc、記憶體釋放free()。

第12行：
malloc返回的結果是是void *，而a是int*，所以我們還要型別轉換一下。(在前面加上(int*))。
)

(第8行：每次申請100兆的空間，然後把申請到的空間，交給p，(p=malloc(100*1024*1024))中，對p做了一個賦值。賦值也是個表示式，有個結果，結果就是p得到的malloc的那個結果。

while ( (p=malloc(100*1024*1024)) ){
    cnt++;
}

這樣的程式碼同時做了2件事情：
1.把malloc的結果賦給了p這個變數；
2.要讓p得到的這個值，拿來做while的條件。

如果p得到的地址不是0，那就意味著它得到了一個有效的地址，那麼，我們迴圈要繼續，要讓cnt去加加。
如果它得到的地址是0，那麼while就要退出來。
)

(著重：首地址)

88.10.1.1 字串：字串

(在字元陣列的最後一個元素，使用'\0')

89.10.1.2 字串：字串變數

相關推薦