c語言基礎學習

資料型別

1. 基本資料型別

• 整數型別：用於表示整數值，包括int、short、long 等。

  • int：通常為 4 個位元組，即 32 位。
  • short：通常為 2 個位元組，即 16 位。
  • long：通常為 4 個位元組，即 32 位（在 32 位系統上），為 8 個位元組，即 64 位（在 64 位系統上）。
  • long long：通常為 8 個位元組，即 64 位。

  int integerVar = 10;
  short shortVar = 20;
  long longVar = 3000000L;
  

• 浮點型別：用於表示浮點數值，包括float、double、long double 等。

  • float：通常為 4 個位元組，即 32 位。
  • double：通常為 8 個位元組，即 64 位。
  • long double：在某些平臺上可能為 12 位元組或 16 位元組。

  float floatVar = 3.14;
  double doubleVar = 6.28;
  long double longDoubleVar = 10.0L;
  

• 字元型別：用於表示單個字元，包括char。

  • char：通常為 1 個位元組（8 位）。

  char charVar = 'A';
  

• 布林型別：用於表示邏輯值，包括bool（C99 標準引入）需要引入 stdbool.h。

  • bool：通常為 1 個位元組（8 位）。

  bool boolVar = 1;  // true
  

2. 派生資料型別

• 陣列型別：用於表示同一型別的連續元素列表。

  int numbers[5] = {1, 2, 3, 4, 5};
  

• 結構體型別：用於自定義複合資料結構。

  struct Person {
      char name[20];
      int age;
  };
  

• 聯合體型別：用於節省記憶體，多個成員共享同一塊記憶體區域。

  union Data {
      int i;
      float f;
      char str[20];
  };
  

• 列舉型別：用於定義符號常量。

  enum Color { RED, GREEN, BLUE };
  

3. 空型別

• 空型別：用於表示空值，包括void。

  void func() { /* ... */ }
  

運算子

1. 算術運算子

用於執行基本的數學運算，例如加法、減法、乘法、除法和取模等。

• + ：加法
• - ：減法
• * ：乘法
• / ：除法
• % ：取模（取餘）

2. 邏輯運算子

用於執行邏輯運算，例如與、或、非等。

• && ：邏輯與（AND）
• || ：邏輯或（OR）
• ! ：邏輯非（NOT）

3. 關係運算子

用於比較兩個值的關係，例如相等、不相等、大於、小於、大於等於、小於等於等。

• == ：等於
• != ：不等於
• > ：大於
• < ：小於
• >= ：大於等於
• <= ：小於等於

4. 位運算子

用於執行位級別的操作，例如與、或、異或和取反等。

• & ：按位與
• | ：按位或
• ^ ：按位異或
• ~ ：按位取反
• << ：左移
• >> ：右移

5. 賦值運算子

用於給變數賦值。

• = ：賦值
• += ：加後賦值
• -= ：減後賦值
• *= ：乘後賦值
• /= ：除後賦值
• %= ：取模後賦值
• &= ：按位與後賦值
• |= ：按位或後賦值
• ^= ：按位異或後賦值
• <<= ：左移後賦值
• >>= ：右移後賦值

6. 其他運算子

• sizeof ：返回變數或型別的大小（以位元組為單位）
• & ：取地址
• * ：指標解引用
• ?: ：三元條件運算子
• ++ ：自增
• -- ：自減

7.原理

1. 按位與（AND）

按位與運算子 & 的原理是：兩個運算元的對應位都為 1 時，結果位為 1；否則結果位為 0。

   0101  (5)
&  0011  (3)
---------
   0001  (1)

2. 按位或（OR）

按位或運算子 | 的原理是：兩個運算元的對應位有一個為 1 時，結果位為 1；否則結果位為 0。

   0101  (5)
|  0011  (3)
---------
   0111  (7)

3. 按位異或（XOR）

按位異或運算子 ^ 的原理是：兩個運算元的對應位不相同時結果位為 1；相同時結果位為 0。

   0101  (5)
^  0011  (3)
---------
   0110  (6)

4. 按位取反（NOT）

按位取反運算子 ~ 的原理是：對運算元的每一位取反，即 0 變為 1，1 變為 0。

~ 00011001 (25)
--------------
  11100110  (230)

5. 左移和右移

左移運算子 << 和右移運算子 >> 的原理是：將運算元的二進位制位按照指定方向移動指定的位數，溢位位被丟棄，空出的位用 0 填補。

   00000101 (5) 左移 2 位
----------------
   00010100 (20)

   00010100 (20) 右移 2 位
----------------
   00000101 (5)

流程控制

1. 條件語句

條件語句用於根據特定條件選擇性地執行程式碼塊。C 語言中最常見的條件語句是 if-else 語句。

int num = 10;
if (num > 0) {
    printf("The number is positive.\n");
} else if (num < 0) {
    printf("The number is negative.\n");
} else {
    printf("The number is zero.\n");
}

C 語言還提供了條件三元運算子(?:)，它也可以完成簡單的條件選擇。

2. 迴圈語句

迴圈語句用於重複執行某段程式碼，直到滿足特定條件為止。C 語言中有 for、while 和 do-while 三種型別的迴圈語句。

// for 迴圈
for (int i = 0; i < 5; i++) {
    printf("Count: %d\n", i);
}

// while 迴圈
int j = 0;
while (j < 5) {
    printf("Count: %d\n", j);
    j++;
}

// do-while 迴圈
int k = 0;
do {
    printf("Count: %d\n", k);
    k++;
} while (k < 5);

3. 跳轉語句

跳轉語句用於改變程式的正常執行順序。C 語言中的跳轉語句包括 break、continue 和 return 等。

// break 語句
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;  // 跳出迴圈
    }
}

// continue 語句
for (int i = 0; i < 5; i++) {
    if (i == 2) {
        continue;  // 跳過本次迴圈的剩餘程式碼，執行下一次迴圈
    }
    printf("Count: %d\n", i);
}

// return 語句
int myFunction() {
    // ...
    return 0;  // 結束函式執行並返回值
}

陣列

C 語言中的陣列是一種用於儲存相同型別資料的集合。陣列在 C 語言中被廣泛使用，可以使用下標來訪問陣列中的元素。

下面是一個簡單的 C 語言陣列的宣告和初始化示例：

#include <stdio.h>

int main() {
    // 宣告一個包含5個整數的陣列
    int numbers[5];

    // 初始化陣列
    numbers[0] = 10;
    numbers[1] = 20;
    numbers[2] = 30;
    numbers[3] = 40;
    numbers[4] = 50;

    // 訪問陣列元素並列印輸出
    printf("%d\n", numbers[0]);  // 輸出 10
    printf("%d\n", numbers[2]);  // 輸出 30

    return 0;
}

除了上述的靜態初始化方式，C 語言還支援動態初始化陣列。下面是一個動態初始化陣列的示例：

#include <stdio.h>

int main() {
    // 動態初始化一個包含5個整數的陣列
    int numbers[] = {10, 20, 30, 40, 50};

    // 訪問陣列元素並列印輸出
    printf("%d\n", numbers[1]);  // 輸出 20
    printf("%d\n", numbers[4]);  // 輸出 50

    return 0;
}

在 C 語言中，陣列的下標是從 0 開始的，所以第一個元素的下標為 0，第二個元素的下標為 1，依此類推。當訪問陣列元素時，需要確保下標在陣列的合法範圍內，否則可能導致訪問越界錯誤。

1. 宣告和初始化陣列

在 C 語言中，陣列可以透過指定陣列的型別和元素個數來宣告和初始化。例如：

int numbers[5];  // 宣告瞭一個包含5個整數的陣列
int numbers2[5] = {1, 2, 3, 4, 5};  // 宣告並初始化了一個包含5個整數的陣列

2. 陣列元素的訪問

在 C 語言中，可以透過下標（索引）來訪問陣列中的元素。陣列的下標從 0 開始。例如：

int value = numbers[2];  // 獲取陣列 numbers 的第三個元素的值

3. 多維陣列

除了一維陣列，C 語言還支援多維陣列，例如二維陣列、三維陣列等。多維陣列的宣告和訪問方式類似於一維陣列，只是增加了多個維度的下標。例如：

int matrix[3][3];  // 宣告瞭一個3x3的二維陣列
int element = matrix[1][2];  // 獲取二維陣列 matrix 中的某個元素的值

4. 陣列和指標

在 C 語言中，陣列名可以看作是陣列第一個元素的地址，因此可以使用指標來訪問陣列元素。例如：

int numbers[] = {1, 2, 3, 4, 5};
int *ptr = numbers;  // 將指標指向陣列的第一個元素

5. 陣列和函式

C 語言中可以將陣列作為函式的引數進行傳遞，也可以從函式中返回陣列。

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
}

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    printArray(numbers, 5);  // 傳遞陣列給函式
    return 0;
}

指標

在 C 語言中，指標是一種非常重要的概念，它提供了直接訪問記憶體地址的能力。指標在 C 語言中被廣泛用於動態記憶體分配、陣列訪問和函式傳遞等場景。

以下是一個簡單的 C 語言指標的宣告和使用示例：

#include <stdio.h>

int main() {
    int num = 10;  // 宣告一個整數變數
    int *ptr;      // 宣告一個整型指標

    ptr = &num;    // 將指標指向 num 變數的記憶體地址

    printf("num 的值：%d\n", num);     // 輸出 10
    printf("透過指標訪問 num 的值：%d\n", *ptr);  // 輸出 10

    *ptr = 20;     // 透過指標修改 num 的值

    printf("num 的新值：%d\n", num);    // 輸出 20

    return 0;
}

在上面的示例中，我們首先定義了一個整數變數 num，然後宣告瞭一個指向整數型別的指標 ptr。透過 & 運算子，我們將 ptr 指向了 num 變數的記憶體地址，然後透過 * 運算子可以訪問指標所指向的記憶體地址的值。

除了上述的基本用法，指標還可以用於動態記憶體分配，例如使用 malloc 函式在堆上分配記憶體，使用完後使用 free 函式釋放記憶體。

1. 指標的宣告和初始化

在C語言中，指標的宣告方式為在變數名前加上*符號，例如 int *ptr; 表示宣告瞭一個指向整數的指標變數 ptr。指標變數可以透過地址運算子 & 來獲取變數的地址，或者直接賦值為其他指標變數。

int num = 10;
int *ptr;      // 宣告一個整型指標
ptr = #    // 將指標指向num變數的記憶體地址
int *ptr2 = ptr;  // 指標變數的賦值

2. 透過指標訪問記憶體

透過解引用運算子 *，可以透過指標來訪問指標所指向記憶體地址的值。

printf("%d\n", *ptr);  // 訪問ptr所指向的記憶體地址的值

3. 指標和陣列

指標和陣列在C語言中有著密切的關係。在C語言中，陣列名可以看作是一個指向陣列第一個元素的指標，也可以透過指標來訪問陣列的元素。

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;  // 將指標指向陣列的第一個元素
printf("%d\n", *ptr);  // 輸出陣列第一個元素的值

4. 指標和函式

指標在C語言中還廣泛用於函式引數的傳遞，可以透過指標在函式內部修改函式外部變數的值。

void modifyValue(int *ptr) {
    *ptr = 100;
}

int main() {
    int num = 10;
    modifyValue(&num);  // 透過指標修改num的值
    printf("%d\n", num);  // 輸出修改後的值 100
    return 0;
}

5. 指標和動態記憶體分配

在C語言中，可以使用指標來進行動態記憶體分配，比如使用 malloc 函式在堆上分配記憶體，然後使用完後透過 free 函式釋放記憶體。

int *ptr = (int *)malloc(5 * sizeof(int));  // 動態分配5個整數的記憶體空間
free(ptr);  // 釋放記憶體

6. 指標的注意事項

在使用指標時，需要格外注意空指標、野指標以及指標的安全性。指標操作可能引入一些潛在的錯誤，比如記憶體洩漏、越界訪問等。

函式

1. 函式的宣告和定義

函式的宣告指定函式名、引數列表和返回型別，函式的定義包括了函式的具體實現。

// 函式宣告
int add(int a, int b);

// 函式定義
int add(int a, int b) {
    return a + b;
}

2. 函式呼叫

透過函式名和引數列表，可以在程式的任何地方呼叫函式。

int result = add(3, 5);  // 呼叫 add 函式並將結果儲存到 result 變數中

3. 引數傳遞

函式可以接收一個或多個引數，這些引數的型別和數量在函式宣告中指定。

void greetUser(char *name) {
    printf("Hello, %s!\n", name);
}

// 呼叫函式
greetUser("Alice");
greetUser("Bob");

4. 返回值

函式可以返回一個值，這個值的型別在函式宣告中指定。如果函式沒有返回值，可以使用 void 型別指定。

int multiply(int x, int y) {
    return x * y;
}

int result = multiply(3, 4);  // 返回值為 12

5. 函式引數

函式引數可以是基本型別、指標、陣列、結構體等。

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
}

int numbers[] = {1, 2, 3, 4, 5};
printArray(numbers, 5);

6. 遞迴函式

C語言支援遞迴函式。

int factorial(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int result = factorial(5);  // 返回值為 120

7.回撥函式

回撥函式是一種在軟體開發中常見的設計模式，在C語言中也經常使用。回撥函式是指將一個函式作為引數傳遞給另一個函式，在特定條件滿足時由另一個函式來呼叫。下面是一個簡單的例子，演示瞭如何在C語言中使用回撥函式。

#include <stdio.h>

// 回撥函式接受一個整數引數並將其列印出來
void callbackFunction(int value) {
    printf("Callback function: %d\n", value);
}

// 執行某個操作，並在操作完成後呼叫回撥函式
void performOperation(void (*callback)(int)) {
    // 模擬操作
    int result = 42;

    // 呼叫回撥函式
    callback(result);
}

int main() {
    // 將回撥函式作為引數傳遞給 performOperation 函式
    performOperation(callbackFunction);

    return 0;
}

8.字串函式

在C語言中，字串函式用於操作和處理字串，這些函式包含在標準庫的<string.h>標頭檔案中。以下是一些常用的字串函式及其簡要介紹：

1. strlen

• 功能：返回字串的長度（不包括空字元\0）。

• 示例：

  #include <string.h>
  char str[] = "Hello";
  int length = strlen(str);  // length 等於 5
  

2. strcpy

• 功能：將一個字串複製到另一個字串。

• 示例：

  #include <string.h>
  char source[] = "source";
  char destination[20];
  strcpy(destination, source);  // 現在 destination 中包含 "source"
  

3. strcat

• 功能：將一個字串追加到另一個字串的末尾。

• 示例：

  #include <string.h>
  char str1[20] = "Hello";
  char str2[] = "world";
  strcat(str1, str2);  // 現在 str1 中包含 "Helloworld"
  

4. strcmp

• 功能：比較兩個字串，相等返回0，不等返回非0。

• 示例：

  #include <string.h>
  char str1[] = "apple";
  char str2[] = "banana";
  int result = strcmp(str1, str2);  // result 小於 0
  

5. strchr

• 功能：在字串中查詢特定字元的首次出現位置。

• 示例：

  #include <string.h>
  char str[] = "Hello";
  char *ptr = strchr(str, 'l');  // ptr 指向 "llo" 中的 'l'
  

6. strstr

• 功能：在字串中查詢特定子串的首次出現位置。

• 示例：

  #include <string.h>
  char str[] = "Hello, world!";
  char *ptr = strstr(str, "world");  // ptr 指向 "world!" 中的 'w'
  

記憶體管理

動態記憶體管理是在程式執行時分配和釋放記憶體空間的過程。在C語言中，可以使用malloc函式動態分配記憶體，並使用free函式釋放已分配的記憶體。

動態記憶體分配

使用malloc函式可以在堆記憶體中分配一塊指定大小的記憶體空間。語法如下：

ptr = (int*)malloc(size);

其中，ptr是一個指標，用於儲存分配的記憶體空間的起始地址，而size是以位元組為單位的分配記憶體大小。

示例：

int *ptr;
ptr = (int*)malloc(5 * sizeof(int));

上面的程式碼將分配5個整型變數所佔的記憶體空間，並將起始地址儲存在ptr指標中。

使用分配的記憶體空間

分配記憶體後，可以透過指標操作這塊記憶體空間，就像操作普通變數一樣。示例如下：

for (int i = 0; i < 5; i++) {
    ptr[i] = i;
}

這段程式碼將0到4依次賦值給ptr指向的記憶體空間。這樣就可以在程式執行過程中動態地為變數分配記憶體。

釋放記憶體

在動態分配記憶體後，要確保在不再需要這些記憶體空間時及時釋放，以免造成記憶體洩漏。使用free函式可以釋放已分配的記憶體空間。語法如下：

free(ptr);

示例：

free(ptr);

在釋放記憶體後，應該將指標設定為NULL以避免出現懸空指標的問題：

ptr = NULL;

這種動態記憶體管理的能力使得程式可以根據需要在執行時動態地申請和釋放記憶體，靈活性更高。但需要注意在使用動態記憶體管理時要小心記憶體洩漏和懸空指標的問題。

作用域；儲存期

在C語言中，作用域和儲存期是兩個相關但不同的概念。作用域定義了變數或函式的可見性，而儲存期定義了變數或物件在記憶體中存在的時間範圍。

作用域（Scope）

作用域定義了識別符號（變數名、函式名等）在程式中可見的範圍。在C語言中，作用域主要有以下幾種：

• 塊作用域（Block scope）：變數在特定的塊（由花括號{}定義）中可見。例如區域性變數的作用域就是塊作用域。

void function() {
    int x;  // x的作用域是在function函式內
}

• 函式作用域（Function scope）：變數在整個函式內可見。

int globalVar;  // 全域性變數，函式作用域為整個原始檔

void function() {
    // 這裡可以訪問globalVar
}

• 檔案作用域（File scope）：變數在整個原始檔中可見，透過使用static關鍵字定義的變數具有檔案作用域。

static int fileVar;  // 檔案作用域只限於當前原始檔

儲存期（Storage Duration）

儲存期定義了變數或物件在記憶體中存在的時間範圍。在C語言中，儲存期主要有以下幾種：

• 靜態儲存期（Static storage duration）：在程式執行期間始終存在，例如全域性變數和使用static關鍵字定義的區域性變數。
• 自動儲存期（Automatic storage duration）：在進入作用域時建立，在離開作用域時銷燬，例如普通的區域性變數。
• 動態分配儲存期（Allocated storage duration）：透過malloc等函式動態分配的記憶體，需要顯式釋放，否則會一直存在直到程式結束。

對於函式或塊作用域內的變數，儲存期一般是自動的，而全域性變數和static變數的儲存期是靜態的。動態分配的記憶體具有動態分配的儲存期。

型別組合

型別組合指的是將不同的資料型別組合在一起，形成新的資料結構，如結構體和聯合體。

結構體（Struct）

結構體是一種使用者自定義的複合資料型別，能夠將不同型別的資料組合成一個整體，具有一定的記憶體佈局和對應的成員。

struct Person {
    char name[50];
    int age;
    float height;
};

這裡定義了一個Person結構體，包括了姓名、年齡和身高三個成員。結構體提供了一種方式來組合不同型別的資料，便於程式中對相關資料進行封裝和操作。

結構體初始化

在C語言中，結構體的初始化可以透過幾種不同的方式來完成。下面是結構體初始化的方法示例：

1. 按順序初始化

struct Person {
    char name[50];
    int age;
    float height;
};

struct Person person1 = { "Alice", 25, 1.75 };

在這個例子中，結構體Person中的成員按照定義時的順序進行初始化，即先是name，然後是age，最後是height。

2. 指定成員初始化

struct Person person1 = { .name = "Bob", .age = 30, .height = 1.80 };

透過指定成員名的方式可以更清晰地對結構體進行初始化，不依賴於順序。

3. 部分成員初始化

struct Person person1 = { .name = "Charlie" };

如果只對結構體的部分成員進行初始化，則其餘成員將被初始化為0或空值，具體取決於成員的型別。

4. 動態初始化

struct Person person1;
person1.name = "David";
person1.age = 35;
person1.height = 1.85;

在這種方式下，可以先分配結構體記憶體，然後逐個成員賦值。

這些是常見的結構體初始化方法，選擇合適的方式取決於具體的需求和程式碼風格。

聯合體（Union）

當涉及資料結構時，C語言中的聯合體（Union）與列舉（Enum）都可以用來組織資料，但它們的工作方式和用途不同。

定義聯合體：

union Data {
    int int_val;
    float float_val;
    char str_val[20];
};

在這個例子中，Data聯合體可以儲存整型、浮點型或字串型別的值，但一次只能儲存其中的一種型別。這樣的設計可以節省記憶體空間，但在某些情況下可能會引發資料訪問的困難。

使用聯合體：

union Data data;
data.int_val = 10;
printf("Integer value: %d\n", data.int_val);

data.float_val = 3.14;
printf("Float value: %f\n", data.float_val);

列舉（Enum）

列舉是一種用來定義識別符號常量的使用者定義資料型別。列舉型別可以為一組數值賦予語義上的名稱，使得程式更易讀，更易理解。

定義列舉：

enum Month {
    JANUARY,
    FEBRUARY,
    MARCH,
    /* ... */
    DECEMBER
};

上面例子中，定義了一個Month列舉型別，包含了十二個月份的常量。

使用列舉：

enum Month currentMonth = MARCH;
if (currentMonth == MARCH) {
    printf("It's March!\n");
}

列舉型別的值可以直觀地使用它們的語義上的名稱，而不需要記住或瞭解其實際值。

總結

聯合體允許在相同的記憶體位置儲存不同型別的資料，而列舉允許為一組數值賦予語義上的名稱。這兩種資料型別各自具有特定的用途和優勢，程式設計師可以根據實際需求選擇合適的資料型別。

預處理

預處理是C語言編譯過程中的第一個階段，由前處理器完成。在此階段，前處理器會對原始碼進行處理，包括檔案包含、宏替換、條件編譯等操作，生成經過預處理的原始碼，然後再進入編譯階段。

以下是前處理器的一些主要功能：

檔案包含（File Inclusion）

透過#include指令，可以將其他檔案包含到當前檔案中，這樣在編譯時就可以將這些檔案的內容插入到當前檔案中。

#include <stdio.h>
#include "mylibrary.h"

在上面的例子中，#include <stdio.h>包含了標準庫標頭檔案，而#include "mylibrary.h"包含了自定義的標頭檔案。

宏定義

宏定義是C語言中的一種預處理指令，用於定義識別符號和值之間的對映關係。宏定義可以簡化程式碼編寫、提高程式碼的可讀性、降低維護成本，並且支援程式碼的靈活調整。

基本宏定義語法

使用#define關鍵字可以定義宏。其基本語法為：

#define MACRO_NAME replacement

• MACRO_NAME為識別符號，將被用作替換的名稱。
• replacement為識別符號在程式碼中出現時將被替換為的內容。

例如，定義一個表示圓周率π的宏：

#define PI 3.14159

使用宏

定義好宏之後，可以在程式碼中使用該宏，預處理階段會將宏名替換為對應的值。例如：

float radius = 5.0;
float area = PI * radius * radius;

在上述程式碼中，預處理階段會將PI替換為3.14159，然後再進行編譯。

引數化宏

宏可以帶有引數，以實現在不同情況下的替換。帶有引數的宏的基本語法為：

#define MACRO_NAME(parameter_list) replacement

例如，定義一個比較兩個數大小並返回較大值的宏：

#define MAX(a, b) ((a) > (b) ? (a) : (b))

之後可以在程式碼中使用這個宏：

int max_value = MAX(10, 20);

在這個例子中，MAX宏接受兩個引數，並返回較大的那個數。

條件編譯（Conditional Compilation）

條件編譯是C語言預處理階段的重要功能，它可以根據預定義的宏來選擇性地編譯程式碼，以在不同的編譯環境下實現定製化的編譯。

#if、#ifdef、#ifndef、#elif、#else 和 #endif

條件編譯主要使用以上預處理指令來實現，以便根據宏的定義情況選擇性地編譯特定的程式碼塊。

• #if：如果給定的條件為真，就編譯後面的程式碼。
• #ifdef：如果指定的宏已經定義，就編譯後面的程式碼。
• #ifndef：如果指定的宏尚未定義，就編譯後面的程式碼。
• #elif：前一個條件不成立時，測試另一個條件。
• #else：如果前面的條件不成立，則編譯後面的程式碼。
• #endif：條件編譯指令塊的結束標記。

示例

#define DEBUG 1

#ifdef DEBUG
    // 除錯模式下的程式碼
#else
    // 釋出版本的程式碼
#endif

在上述示例中，如果宏DEBUG被定義，前處理器會編譯除錯模式下的程式碼；否則，會編譯釋出版本的程式碼。

條件編譯的應用

條件編譯可以用於根據不同的編譯目標或環境，選擇性地編譯特定的程式碼。它可以用於開發環境和生產環境、不同的作業系統、不同的體系結構等方面的定製化需求。

// 示例：根據作業系統選擇性編譯
#ifdef _WIN32
    // Windows平臺下的程式碼
#else
    // 非Windows平臺下的程式碼
#endif

條件編譯還可以結合宏定義實現一些特定功能的開關，從而在不同情況下定製化編譯不同的程式碼。

條件編譯為程式提供了很大的靈活性，可以根據不同的編譯環境和需求選擇性地編譯程式碼，這在實際開發中非常有用。

其他功能

預處理的結果是生成經過處理的原始碼，在這之後才會進入編譯器的詞法分析和語法分析階段。因此，預處理是為了在編譯時對原始碼進行一些文字替換和條件判斷，使得程式在不同的環境和條件下能夠靈活地進行編譯和定製。

在C語言中，良好的檔案組織結構對於程式的可維護性、可擴充套件性和可複用性都非常重要。檔案組織主要涉及標頭檔案的使用、模組化程式設計和程式碼的結構化佈局。

檔案組織

標頭檔案（Header File）

標頭檔案通常包含型別定義、函式宣告和常數定義，可以被多個原始檔包含以便共享這些定義。標頭檔案採用.h作為副檔名。

示例標頭檔案 mylib.h：

#ifndef MYLIB_H
#define MYLIB_H

// 宣告函式
int add(int a, int b);

// 定義常量
#define PI 3.14159

#endif

原始檔（Source File）

原始檔包含實際的函式定義和全域性變數的宣告，並且通常以.c作為副檔名。

示例原始檔 mylib.c：

#include "mylib.h"

// 定義函式
int add(int a, int b) {
    return a + b;
}

模組化程式設計（Modular Programming）

模組化程式設計是一種將程式碼分割成小模組，以便於管理和維護的程式設計風格。每個模組都有自己的介面和實現，這些模組可以利用模組化的思想設計和開發。

示例分割模組：

// math.h - 標頭檔案
#ifndef MATH_H
#define MATH_H

int add(int a, int b);  // 函式宣告

#endif
// math.c - 原始檔
#include "math.h"

int add(int a, int b) {  // 函式定義
    return a + b;
}

結構化佈局（Structured Layout）

合理的檔案結構能夠讓程式碼更易於閱讀和理解。對於大型專案，推薦採用一定的目錄結構，將相關檔案組織到不同的子目錄中。

例如，可以將標頭檔案放在include目錄中，將原始檔放在src目錄中，將測試相關檔案放在test目錄中。

檔案組織的良好結構有助於更好地理解和維護程式碼，可以透過簡單的目錄結構就能找到所需要的檔案。

透過良好的檔案組織，可以更好地組織程式碼、提高程式碼的可維護性和可移植性，便於團隊協作和後期維護。