相關文章鏈接 :
1.【嵌入式開發】C語言 指針數組 多維數組
2.【嵌入式開發】C語言 命令行參數 函數指針 gdb調試
3.【嵌入式開發】C語言 結構體相關 的 函數 指針 數組
4.【嵌入式開發】gcc 學習筆記(一) - 編譯C程序 及 編譯過程
5.【C語言】 C 語言 關鍵字分析 ( 屬性關鍵字 | 常量關鍵字 | 結構體關鍵字 | 聯合體關鍵字 | 枚舉關鍵字 | 命名關鍵字 | 雜項關鍵字)

文章目錄

• 一. 屬性關鍵字 (auto | static | register)
• • 1. auto 關鍵字
  • • (1) auto 關鍵字說明 ( 默認屬性 | 聲明棧存儲 | 只能修飾局部變量 [ 全局變量在全局區存儲 , auto 在棧內存中 ] )
    • (2) auto 關鍵字 代碼示例 ( 不能修飾全局變量 | 錯誤示例 )
    • (3) auto 關鍵代碼示例 ( 正確用法 )
  • 2. static 關鍵字
  • • (1) static 關鍵字說明 ( ① 聲明靜態屬性 存儲于靜態區 [ 修飾局部變量 ] | ② 文件作用域限定符 [ 修飾全局變量 和 函數 ] )
    • (2) static 關鍵字 代碼示例 ( 修飾局部變量 )
    • (3) static 關鍵字 代碼示例 ( 限定變量和方法 作用域 )
  • 3. register 關鍵字
  • • (1) register關鍵字說明 ( 聲明寄存器存儲 ( 不確定 ) | 適用前提 ① 值符合CPU要求 ② 不能用 & 取地址 , & 只能取內存地址 不能取 CPU 地址 )
    • (2) register 關鍵字代碼示例 ( 不能修飾全局變量 | 錯誤示例 )
    • (3) register 關鍵字代碼示例 ( 不能獲取register變量地址 | 錯誤示例 )
  • 4. 屬性關鍵字綜合示例
• 二. 其它關鍵字 ( goto | void | extern | sizeof)
• • 1. goto 關鍵字 ( 不建議使用 )
  • 2. void 關鍵字
  • • (1) void 關鍵字說明 ( 修飾 返回值 和 參數 | 本質 代表 沒有 )
    • (2) void * 指針介紹 ( 被賦值 [ 左值 ] 時可以被賦值為任意指針類型變量 | 右值 賦值給其它類型變量時 需要將 void* 指針強轉為被賦值的類型 )
    • (3) void * 指針 代碼示例 ( 實現 memset 方法 )
  • 3. extern 關鍵字
  • • (1) extern 關鍵字說明 ( 聲明外部文件的 變量 和 函數 | 設置編譯方式 C++ 中 命令編譯器 以 標準 C 規范編譯 變量 和 函數 )
    • (2) extern 引用外部文件示例 ( 聲明外部變量 : extern 類型 變量名稱; | 聲明外部函數 : extern 返回值類型 函數名稱 ( 參數列表 ) ; )
    • (3) extern 關鍵字代碼示例 ( 編譯方式 )
  • 4. sizeof 關鍵字
  • • (1) sizeof 關鍵字說明 ( 本質 不是函數 是 編譯器 指示符 | 編譯過程中得到結果 | 計算變量 或 類型 占用內存大小 )
• 三. 常量 和 易變 關鍵字 ( const | volatile )
• • 1. const 關鍵字 簡介
  • • (1) const 關鍵字 簡介 ( 左數右指 | 修飾制度變量 | 生成常量符號表 )
    • (2) const 關鍵字 代碼示例 ( const 常量不能被賦值 | 錯誤示例)
    • (3) const 關鍵字 代碼示例 ( 通過指針修改const常量 : 獲取 const 變量的地址, 并改變該地址的值 )
    • (4) const 關鍵字 代碼示例 ( 修飾指針 | 錯誤示例 )
    • ( 5 ) const 關鍵字 代碼示例 ( 修飾返回值 )
  • 2. volatile 關鍵字 簡介
  • • (1) volatile 關鍵字 簡介 ( 告訴編譯器 每次去內存中取變量值 | )
    • (2) volatile 關鍵字 代碼示例
• 四. 結構體 聯合體 關鍵字 ( struct | union )
• • 1. struct 關鍵字
  • • (1) 結構體定義 使用 ( ① 結構體定義 : struct 結構體名稱 {}; | ② 結構體變量聲明 : struct 結構體名 變量名 ; | ③ 定義結構體同時聲明結構體變量 : struct 結構體名稱 {} 變量名 ; | ④ 結構體定義別名 : typedef struct 結構體名稱 {} 別名名稱; 聲明變量 : 別名名稱 變量名稱 ; [ 定義一個別名后, ] | ⑤ 結構體定義別名省略結構體名稱 : typedef struct {} 別名名稱; 聲明變量 : 別名名稱 變量名稱 ; )
    • (2) struct 結構體大小
    • (3) struct 結構體實現柔性數組
    • (4) 柔性數組 代碼示例 ( 處理斐波那契數列 )
  • 3. union 聯合體 關鍵字
  • • (1) struct 和 union 的區別 ( struct 為每個元素分配獨立空間 | union 只為最大的元素分配內存空間 所有元素共享該空間 )
    • (2) union 聯合體注意事項 ( 受大小端影響 )
• 五. 枚舉 關鍵字 ( enum )
• • 1. enum 關鍵字
  • • (1) enum 枚舉關鍵介紹 ( 定義常量 | 只能定義 int 類型 )
    • (2) enum 枚舉代碼示例
    • (3) enum 和 define 區別 ( #define 編譯時進行替換 | enum 是常量值 )
  • 2. typedef 關鍵字
  • • ( 1 ) typedef 關鍵字介紹 ( 給已有類型重新命名 | 沒有新類型 | 無法擴展 )

一. 屬性關鍵字 (auto | static | register)

每個C語言變量都有自己的屬性.
定義變量時可以在變量前加上 “屬性關鍵字” 來為變量定義屬性.
auto 關鍵字 : auto 是C語言變量的默認屬性, 所有的局部變量都被編譯器默認為 auto 屬性. 存儲在棧中.
static 關鍵字 : 聲明靜態, 限定作用域. 存儲在靜態存儲區.
register關鍵字 : 聲明存儲在 CPU 寄存器中. 存儲在CPU寄存器中.

1. auto 關鍵字

(1) auto 關鍵字說明 ( 默認屬性 | 聲明棧存儲 | 只能修飾局部變量 [ 全局變量在全局區存儲 , auto 在棧內存中 ] )

auto 關鍵字 :

• 1.C語言默認屬性 : 如果一個變量前沒有寫明屬性, 那就是默認為 auto 的屬性;
• 2.聲明棧存儲 : 使用auto修飾的變量, 會默認存儲在程序的棧中.
• 3.只能修飾局部變量 : auto 關鍵字只能修飾局部變量, 修飾全局變量編譯時會報錯.

>**auto不能修飾全局變量** : auto 關鍵字不能修飾全局變量, 因為 ***auto 修飾的變量存儲在棧內存中, 全局變量存儲在全局區, 此時出現了沖突***. 如果使用auto修飾全局變量, 編譯時會報錯.

存儲類型說明 : C 語言中的變量存儲 由上到下順序 : 棧區(stack) -> 堆區(heap) -> 全局區 -> 字符常量區 -> 代碼區

---

(2) auto 關鍵字 代碼示例 ( 不能修飾全局變量 | 錯誤示例 )

auto 關鍵字只能修飾局部變量, 修飾全局變量會報錯 :

• 1.代碼 : test_1.c .

#include<stdio.h>//使用auto修飾全局變量,編譯時直接報錯,因為auto代表存儲在棧中, 全局變量存儲在全局區, 因此auto只能修飾局部變量, 這里出現錯誤, 直接注釋掉. auto int global_auto = 0;

• 2.編譯結果 : 提示全局變量不能使用 auto 關鍵字聲明.
  

---

(3) auto 關鍵代碼示例 ( 正確用法 )

正確使用 auto 關鍵字 :

• 1.代碼 :

#include<stdio.h>//使用auto修飾全局變量,編譯時直接報錯,因為auto代表存儲在棧中, 全局變量存儲在全局區, 因此auto只能修飾局部變量, 這里出現錯誤, 直接注釋掉. //auto int global_auto = 0; int global_auto = 0;//該聲明合法 int main() {//auto 關鍵字只能修飾局部變量, 不能修飾全局變量auto int auto_variable = 0;//獲取局部變量的地址,該地址是棧內存地址printf("%0X\n", &auto_variable);return 0; }

• 2.執行結果 : 打印出了棧內存中的地址.
  

---

2. static 關鍵字

(1) static 關鍵字說明 ( ① 聲明靜態屬性 存儲于靜態區 [ 修飾局部變量 ] | ② 文件作用域限定符 [ 修飾全局變量 和 函數 ] )

static 關鍵字兩大作用 :

• 1.靜態屬性 : static 修飾局部變量 指明變量是靜態的, 該變量存儲在程序靜態區.
• 2.作用域限定符 : static 作為 文件作用域限定符.

static 修飾局部變量(聲明靜態存儲區) :

• 1.作用 : 說明該局部變量存儲在靜態存儲區.
• 2.初始化次數 : 該值只會***初始化一次***, 之后會被不斷賦值, 調用該局部變量所在方法, 每次的值都是上次調用該方法計算完畢后的值. 如果是第一次調用, 那么就初始化這唯一的一次.
• 3.聲明周期 : 該局部變量的生命周期***從第一次初始化直到程序退出為止***.

static 修飾全局變量和函數(聲明作用域) :

• 1.修飾全局變量 : static 如果修飾全局變量, 那么就說明該全局變量只能在本文件中使用, 其它文件無法訪問.
• 2.修飾函數 : static 如果修飾函數, 那么該函數只能

存儲類型說明 : C 語言中的變量存儲 由上到下順序 : 棧區(stack) -> 堆區(heap) -> 全局區 -> 字符常量區 -> 代碼區

---

(2) static 關鍵字 代碼示例 ( 修飾局部變量 )

static 關鍵字修飾局部變量, 只初始化一次, 之后每次使用, 都不再進行初始化操作.

static 修飾局部變量示例 : 兩個方法中各有一個變量, 一個靜態, 一個auto, 分別調用5次方法,進行對比.

• 1.代碼 :

#include<stdio.h>//定義兩個函數, 區別是一個是 auto 變量, 一個是 static 變量, 本函數定義是 auto 變量 void method1() {//每次調用都調用該值int local_variable_auto = 0;local_variable_auto ++;printf("%d\n", local_variable_auto); }//定義兩個函數, 區別是一個是 auto 變量, 一個是 static 變量, 本函數定義是 static 變量 void method2() {//與method1對比就是局部變量使用 static 修飾//該變量只初始化一次, 之后調用, 獲取的值都是上次用完后的值, 即使被賦值很多次, 獲取到的值是最后一次賦值的值.static int local_variable_static = 0;local_variable_static ++;printf("%d\n", local_variable_static); } int main() {//C編譯器中可以不聲明, 默認局部變量時 auto 屬性的.auto int i = 0;//調用五次定義了auto局部變量的值,其中的局部變量每次都初始化for(i = 0; i < 5; i ++){method1();}//調用五次定義了static局部變量的值,其中的靜態變量只初始化一次,之后每次都用上一次賦值過的變量for(i = 0; i < 5; i ++){method2();}return 0; }

• 2.執行結果 :
  

分析 :
調用5次method1()方法, 每次local_variable_auto 變量都初始化.
調用5次method2()方法, local_variable_static 變量只初始化一次, 之后每次都沿用上一次的值.

---

(3) static 關鍵字 代碼示例 ( 限定變量和方法 作用域 )

static 關鍵字 限定變量 只能在本代碼中訪問被修飾的變量和函數 :

• 1.代碼1 : 主程序 test_1.c ;

#include<stdio.h>//引用test_2.c 文件中的普通全局變量,該聲明合法. extern int test_2_global;//引用test_2.c 中的靜態全局變量, 在使用時會報錯. //extern int test_2_global_static;//引用test_2.c 中的普通函數, 通過該普通函數可以獲取test_2.c 中的 test_2_global_static 靜態變量 extern int method_3();//引用test_2.c 中的靜態函數, 使用時會報錯. //extern int method_4();//引用test_2.c 中的普通函數, 通過該普通函數可以調用test_2.c 中的method_4() 靜態函數 extern int method_5(); int main() {//打印 test_2.c 中的全局變量,查看是否在本文件中引用成功.printf("%d\n", test_2_global);//打印 test_2.c 中的靜態全局變量, 此時編譯時會報錯,這里注釋掉.//printf("%d\n", test_2_global_static);//通過調用 method_3() 獲取 test_2.c 中的靜態全局變量, 打印出該靜態全局變量的值printf("%d\n", method_3());//無法調用 test_2.c 中的靜態方法, 編譯時會報錯.//printf("%d\n", method_4());//通過調用 method_5, 間接調用 test_2.c 中的 method_4() 靜態函數, 獲取該靜態函數的值并打印出來.printf("%d\n", method_5());return 0; }

• 2.代碼2 : 外部文件 test_2.c ;

//普通的全局變量, 其它文件可以引用該變量 int test_2_global = 666; //靜態全局變量, 同時限定其作用域是本文件, 不能被外部文件使用. static int test_2_global_static = 444; //通過調用該方法, 可以在外部文件訪問該方法, 獲取靜態全局變量的值. int method_3() {return test_2_global_static; }//使用static修飾該方法, 外部文件無法使用該方法. static int method_4() {return test_2_global_static; }//在普通方法中調用static修飾的方法, 此時可以在外部文件中訪問該普通方法, 即通過普通方法調用 static 方法. int method_5() {return method_4(); }

• 3.執行結果 : 需要同時編譯兩個文件 gcc test_1.c test_2.c ;
  

---

3. register 關鍵字

(1) register關鍵字說明 ( 聲明寄存器存儲 ( 不確定 ) | 適用前提 ① 值符合CPU要求 ② 不能用 & 取地址 , & 只能取內存地址 不能取 CPU 地址 )

register 關鍵字說明 :

• 1.作用 : 聲明變量存儲的位置是在 寄存器 中.
• 2.成功率 : 該關鍵字只是請求編譯器將該變量存儲在寄存器中, 編譯器不一定會批準.
• 3.不能修飾全局變量 : register 修飾全局變量會報錯, 因為全局變量聲明周期是整個程序的聲明周期,該周期內長時間占用 CPU 寄存器明顯不可能, 因此編譯器禁止register修飾全局變量.

register 使用前提 :

• 1.值符合要求 : 該變量的值必須能夠被 CPU 的寄存器接受.
• 2.無法獲取地址 : 取地址運算符 & 不能獲取 register 變量地址, & 只是能獲取內存地址, 不能獲取 CPU 地址.

使用情況 : 當需求是***實時性要求效率非常高***時, 就應該使用寄存器變量.

---

(2) register 關鍵字代碼示例 ( 不能修飾全局變量 | 錯誤示例 )

register 不能修飾全局變量 : CPU 寄存器內的變量其生命周期不能太長.

• 1.代碼 : test_1.c ;

#include<stdio.h>//使用register 修飾全局變量,此時編譯也會報錯,全局變量聲明周期是整個程序的生命周期,如果將其放入CPU寄存器, //會導致寄存器占用, 因此編譯器規定寄存器變量不能是全局變量. 這里將錯誤代碼注釋掉. register int global_register = 0;

• 2.執行結果 : register修飾全局變量報錯;
  

---

(3) register 關鍵字代碼示例 ( 不能獲取register變量地址 | 錯誤示例 )

register 變量無法獲取地址 :

• 1.代碼1 : test_1.c .

#include<stdio.h>int main() {//register 關鍵字只能修飾局部變量,不能修飾全局變量register int register_variable = 0;//嘗試獲取CPU寄存器的地址, 此時編譯時會報錯. 這里注釋掉.printf("%0x\n", &register_variable);return 0; }

• 2.執行結果 :
  

---

4. 屬性關鍵字綜合示例

屬性關鍵字綜合示例 :

• 1.代碼1 : test_1.c;

#include<stdio.h>//使用auto修飾全局變量,編譯時直接報錯,因為auto代表存儲在棧中, 全局變量存儲在全局區, 因此auto只能修飾局部變量, 這里出現錯誤, 直接注釋掉. //auto int global_auto = 0; int global_auto = 0;//該聲明合法 //使用register 修飾全局變量,此時編譯也會報錯,全局變量聲明周期是整個程序的生命周期,如果將其放入CPU寄存器, //會導致寄存器占用, 因此編譯器規定寄存器變量不能是全局變量. 這里將錯誤代碼注釋掉. //register int global_register = 0; int global_register = 0;//該聲明合法//定義兩個函數, 區別是一個是 auto 變量, 一個是 static 變量, 本函數定義是 auto 變量 void method1() {//每次調用都調用該值int local_variable_auto = 0;local_variable_auto ++;printf("%d\n", local_variable_auto); }//定義兩個函數, 區別是一個是 auto 變量, 一個是 static 變量, 本函數定義是 static 變量 void method2() {//與method1對比就是局部變量使用 static 修飾//該變量只初始化一次, 之后調用, 獲取的值都是上次用完后的值, 即使被賦值很多次, 獲取到的值是最后一次賦值的值.static int local_variable_static = 0;local_variable_static ++;printf("%d\n", local_variable_static); }//引用test_2.c 文件中的普通全局變量,該聲明合法. extern int test_2_global;//引用test_2.c 中的靜態全局變量, 在使用時會報錯. //extern int test_2_global_static;//引用test_2.c 中的普通函數, 通過該普通函數可以獲取test_2.c 中的 test_2_global_static 靜態變量 extern int method_3();//引用test_2.c 中的靜態函數, 使用時會報錯. //extern int method_4();//引用test_2.c 中的普通函數, 通過該普通函數可以調用test_2.c 中的method_4() 靜態函數 extern int method_5(); int main() {//auto 關鍵字只能修飾局部變量, 不能修飾全局變量auto int auto_variable = 0;//static 既可以修飾局部變量(聲明存儲于靜態存儲區), 又可以修飾全局變量(文件作用域限定)static int static_variable = 0;//register 關鍵字只能修飾局部變量,不能修飾全局變量register int register_variable = 0;//獲取局部變量的地址,該地址是棧內存地址printf("%0x\n", &auto_variable);//獲取靜態變量的地址, 該地址是靜態區地址printf("%0x\n", &static_variable);//嘗試獲取CPU寄存器的地址, 此時編譯時會報錯. 這里注釋掉.//printf("%0x\n", &register_variable);//C編譯器中可以不聲明, 默認局部變量時 auto 屬性的.auto int i = 0;//調用五次定義了auto局部變量的值,其中的局部變量每次都初始化for(i = 0; i < 5; i ++){method1();}//調用五次定義了static局部變量的值,其中的靜態變量只初始化一次,之后每次都用上一次賦值過的變量for(i = 0; i < 5; i ++){method2();}//打印 test_2.c 中的全局變量,查看是否在本文件中引用成功.printf("%d\n", test_2_global);//打印 test_2.c 中的靜態全局變量, 此時編譯時會報錯,這里注釋掉.//printf("%d\n", test_2_global_static);//通過調用 method_3() 獲取 test_2.c 中的靜態全局變量, 打印出該靜態全局變量的值printf("%d\n", method_3());//無法調用 test_2.c 中的靜態方法, 編譯時會報錯.//printf("%d\n", method_4());//通過調用 method_5, 間接調用 test_2.c 中的 method_4() 靜態函數, 獲取該靜態函數的值并打印出來.printf("%d\n", method_5());return 0; }

• 2.代碼2 : test_2.c ;

//普通的全局變量, 其它文件可以引用該變量 int test_2_global = 666; //靜態全局變量, 同時限定其作用域是本文件, 不能被外部文件使用. static int test_2_global_static = 444; //通過調用該方法, 可以在外部文件訪問該方法, 獲取靜態全局變量的值. int method_3() {return test_2_global_static; }//使用static修飾該方法, 外部文件無法使用該方法. static int method_4() {return test_2_global_static; }//在普通方法中調用static修飾的方法, 此時可以在外部文件中訪問該普通方法, 即通過普通方法調用 static 方法. int method_5() {return method_4(); }

• 3.執行結果 :
  

---

二. 其它關鍵字 ( goto | void | extern | sizeof)

1. goto 關鍵字 ( 不建議使用 )

goto 現狀 (建議禁用) : 一般不使用 goto;

• 1.對程序質量影響 : 程序中使用的 goto 越多, 代碼質量越垃圾;
• 2.禁用 goto : goto 對代碼質量產生惡劣影響, 高手寫代碼一般不使用 goto;
• 3.后續高級語言刪除了 goto : 后續的 Java 等高級語言中, 沒有 goto 關鍵字;
• 4.原因 : 破壞了 過程式 程序順序執行 的規則;

---

2. void 關鍵字

(1) void 關鍵字說明 ( 修飾 返回值 和 參數 | 本質 代表 沒有 )

void 關鍵字作用 : 修飾函數 返回值 和 參數;

• 1.修飾返回值 : 函數 沒有返回值, 其類型就應該寫成 void;
• 2.修飾參數 : 如果函數 沒有參數, 即不接收參數, 其參數類型就寫成 void;
• 3.本質 : 使用 void 修飾 返回值 和 參數, 其本質就代表沒有;

void 類型大小C語言規范沒有規定, C 語言中是沒有 void 變量的. 使用sizeof查看void大小, gcc 返回1 這是編譯器廠商給的一個值, 不是C語言中規定的.

void 不能修飾變量, 否則會報錯.

---

(2) void * 指針介紹 ( 被賦值 [ 左值 ] 時可以被賦值為任意指針類型變量 | 右值 賦值給其它類型變量時 需要將 void* 指針強轉為被賦值的類型 )

void * 指針說明 :

• 1.被賦值的情況(作為左值) : void * 指針作為被賦值對象, 即在 “=” 左側, 其可以 直接被賦值為任何指針類型變量;
• 2.賦值給其它指針(作為右值) : void * 賦值給其它類型的指針變量, 需要強制轉換為其它類型的指針變量.

---

(3) void * 指針 代碼示例 ( 實現 memset 方法 )

使用 void * 指針實現 memset 方法示例 :

• 1.代碼示例 : test_1.c ;

#include<stdio.h> //實現 memset 函數, 下面是memset函數的內容. //void *memset(void *s, int ch, size_t n); //函數解析：將s中當前位置后面的n個字節 （typedef unsigned int size_t ）用 ch 替換并返回 s //memset：作用是在一段內存塊中填充某個給定的值，它是對較大的結構體或數組進行清零操作的一種最快方法//實現方法 : //1.接收參數 : void *s 內存地址, int ch 每個字節賦值內容, int size 替換的字節個數. //2.算法實現 : for 循環實現設置 //3.返回值 : void * void * memset(void *p, char v, int size) {//接收一個任意的內存地址值(任意類型的指針變量)void * ret = p;//將 void * 強制轉換為 char *char * dest = (char*)p;int i = 0;for(i = 0; i < size; i ++){//使用 char 類型指針, 依次將之后的字節每個設置成 vdest[i] = v;}return ret; }int main() {//定義一個數組, 之后我們將使用自定義的memset方法重置數組中的內容int array[5] = {1, 2, 3, 4, 5};//循環控制變量int i = 0;//打印數組的原始值for(i = 0; i < 5; i ++){printf("%d\n", array[i]);}//調用自己定義的memset函數清空數組內容memset(array, 0, sizeof(array));//打印數組經過memset重置后的數值for(i = 0; i < 5; i ++){printf("%d\n", array[i]);}//定義long類型測試long l = 66666;printf("%ld\n", l); //打印值memset(&l, 0, sizeof(l)); //重置long變量printf("%ld\n", l); //再次打印重置后的值return 0; }

• 2.執行結果 :
  

---

3. extern 關鍵字

(1) extern 關鍵字說明 ( 聲明外部文件的 變量 和 函數 | 設置編譯方式 C++ 中 命令編譯器 以 標準 C 規范編譯 變量 和 函數 )

extern 關鍵字說明 :

• 1.主要作用 : 聲明外部文件中定義的 變量 和 函數;
• 2.設置編譯方式 : 有些 C ++ 編譯器 和 一些 變種 C 編譯器 編譯變量 和 函數時有時不遵守標準C 規范, 通過 extern 關鍵字可以***命令編譯器以 標準C 規范編譯 變量和函數***.

extern "C" {... }

---

(2) extern 引用外部文件示例 ( 聲明外部變量 : extern 類型 變量名稱; | 聲明外部函數 : extern 返回值類型 函數名稱 ( 參數列表 ) ; )

extern 引用外部文件 :

• 1.代碼示例1 : test_1.c ;

#include <stdio.h>//引用外部文件 test_2.c 中定義的全局變量 extern int test_2_a;//引用外部文件 test_2.c 中定義的方法 extern int test_2_get_min(int a, int b);int main() {//調用外部變量 test_2_a, 并打印出其值printf("%d\n", test_2_a);//調用外部函數 test_2_get_min , 并打印結果printf("%d\n", test_2_get_min(666, 888));return 0; }

• 2.代碼示例2 : test_2.c ;

//test_2.c 中定義的全局變量 int test_2_a = 666;//test_2.c 中定義的函數 int test_2_get_min(int a, int b) {//返回a和b中較小的值return (a < b) ? a : b; }

• 3.執行結果 :
  

---

(3) extern 關鍵字代碼示例 ( 編譯方式 )

extern 指定編譯方式代碼示例 :

• 1.代碼示例 : test_1.c ;

#include <stdio.h>//如果在 gcc 編譯器中, 該用法直接報錯 //在 g++ 編譯器中, 該用法有效 extern "C" {int c_get_min(int a, int b){//返回a和b中較小的值return (a < b) ? a : b;} }int main() {//g++ 編譯器中編譯通過即可執行printf("%d\n", c_get_min(666, 888));return 0; }

• 2.執行結果 :
  

---

4. sizeof 關鍵字

(1) sizeof 關鍵字說明 ( 本質 不是函數 是 編譯器 指示符 | 編譯過程中得到結果 | 計算變量 或 類型 占用內存大小 )

sizeof 關鍵字說明 :

• 1.sizeof 本質 : sizeof 不是函數, 其本質是一個編譯器的內置的指示符;
• 2.sizeof 確定值的時機 : sizeof 的實際值值, 在***編譯的過程中就已經知道了結果***.
• 3.sizeof 作用 : 計算變量或者類型 等實體 占用內存的大小.

---

###(2) sizeof 關鍵字 代碼示例 ( 使用方法 )

---

sizeof 關鍵字 代碼示例 :

• 1.代碼示例 :

#include <stdio.h>int main() {int a;//這種sizeof, 將變量放在括號里, 與函數調用類似printf("%ld\n", sizeof(a));//可以不寫括號, 也可以打印出 變量 a 的大小, 注意 類型 不能這么寫//只有變量可以這么寫printf("%ld\n", sizeof a);//可以傳入類型 int, 打印出 int 類型占用內存大小printf("%ld\n", sizeof(int));return 0; }

• 2.執行結果 :
  

---

三. 常量 和 易變 關鍵字 ( const | volatile )

1. const 關鍵字 簡介

(1) const 關鍵字 簡介 ( 左數右指 | 修飾制度變量 | 生成常量符號表 )

const 關鍵字 說明 :

• 1.const 常量本質 : const 不是真的常量, 也是一種變量.
• 2.修飾只讀變量 : const 修飾的變量智能讀取, 不能被賦值, 即不能當做左值;
• 3.占用內存 : const 變量也會占用內存中的空間 ;
• 4.修改const值 : 使用指針可以修改const變量地址中的值.

const 只是針對編譯器是有用的, 在運行的時候 就沒有這種約束了, 可以改變其值.

編譯器處理 const 常量過程 :

• 1.定義 const 常量 : const int const_variable = 666, 之后編譯器開始編譯;
• 2.生成符號表 : 編譯器生成一個符號表, const_variable 對應 int 類型, 值為 666;

常量標示符常量類型常量值

const_variable	int	666

• 3.編譯器左值判定 : 編譯器查找const常量是否有左值, 如果有報錯;
• 4.編譯器右值判定 : 編譯器查找 const 常量是否當做右值,如果出現 int a = const_variable, 那么直接將 const_variable 替換為 666; 如果出現 int p = (int) &const_variable, 那么不做任何操作;

const 修飾數組 :

• 1.只讀數組 : const 修飾數組時, 這個數組是只讀的, 數組中的每個元素都是只讀的, 不能作為左值;
• 2.const 數組所在空間不可改變 : 數組所在的空間是不可更改的, 但是通過指針是可以修改數組中每個元素的值的;

const 修飾指針 : 需要符合下面的規則 :

聲明特征

const int* p	p指針地址可變 p指針指向的內容不可變 (const 在 * 左邊, 數據不可變)
int const* p	p指針地址可變 p指針指向的內容不可變 (const 在 * 左邊, 數據不可變)
int* const p	p指針地址不可變 p指針指向的內容不可變 (const 在 * 右邊, 地址不可變)
const int* const p	p指針地址不可變 p指針指向的內容不可變 (const 在 * 左邊 和 右邊, 數據和地址都不可變)

>**const 修飾指針規則** : ***左數 右指 (左邊數據是常量, 右邊指針是常量)***; >**左數** : ***const 出現在 * 左邊時, 指針指向的數據為常量***, 指向的數據不可改變; >**右指** : ***const 出現在 * 右邊時, 指針地址本身是常量***, 指針地址不可改變;

const 修飾函數參數 和 返回值 :

• 1.const 修飾參數 : 在函數體內, 不希望改變參數的值;
• 2.const 修飾返回值 : 一般情況下 返回值 使用 const 修飾, 是返回指針, 用于限制 指針指向的內容不允許改變 ;

---

(2) const 關鍵字 代碼示例 ( const 常量不能被賦值 | 錯誤示例)

const 關鍵字 代碼示例 : const 常量不能被賦值.

• 1.代碼示例 :

#include <stdio.h>int main() {//定義一個 const 變量, 直接賦值編譯器報錯, 但是使用指針改變該地址的值是可以的.const int const_variable = 666;printf("%d\n", const_variable);//const 變量不能被直接賦值, 這樣在編譯的時候就會報錯const_variable = 444;printf("%d\n", const_variable);return 0; }

• 2.執行結果 :
  

const 常量一旦作為左值, 編譯時就會報錯

---

(3) const 關鍵字 代碼示例 ( 通過指針修改const常量 : 獲取 const 變量的地址, 并改變該地址的值 )

const 關鍵字 代碼示例 : const 常量可以通過指針修改

• 1.代碼示例 :

#include <stdio.h>int main() {//定義一個 const 變量, 直接賦值編譯器報錯, 但是使用指針改變該地址的值是可以的.const int const_variable = 666;printf("%d\n", const_variable);//const 變量不能被直接賦值, 這樣在編譯的時候就會報錯, 這里注釋掉//const_variable = 444;//獲取 const 變量的地址, 并改變該地址的值int* p = (int*) &const_variable;*p = 888;printf("%d\n", const_variable);return 0; }

• 2.執行結果 :
  

通過指針可以修改 const 常量

---

(4) const 關鍵字 代碼示例 ( 修飾指針 | 錯誤示例 )

const 修飾指針規則 : 左數右指;
左數 : const 出現在 * 左邊時, 指針指向的數據為常量, 指向的數據不可改變;
右指 : const 出現在 * 右邊時, 指針地址本身是常量, 指針地址不可改變;

const 關鍵字 代碼示例 : 修飾指針

• 1.代碼示例1 : const 出現在 * 左邊, const int* p = &i;

#include <stdio.h>int main() {//定義普通的變量, 用于取地址用int i = 666;//定義一個 const 在 * 左邊的例子, 意義是 指針指向的內容是常量//按照規則, 指針地址可改變, 指針指向的數據不可變const int* p = &i; //指針指向的數據不可改變, 這里會報錯*p = 444;return 0; }

• 2.代碼示例2 : const 出現在 * 左邊, int const* p = &i;

#include <stdio.h>int main() {//定義普通的變量, 用于取地址用int i = 666;//定義一個 const 在 * 左邊的例子, 意義是 指針指向的內容是常量//按照規則, 指針地址可改變, 指針指向的數據不可變int const* p = &i;//指針指向的數據不可改變, 這里會報錯*p = 444;return 0; }

• 3.代碼示例3 : const 出現在 * 右邊, int* const p = &i;

#include <stdio.h>int main() {//定義普通的變量, 用于取地址用int i = 666;//定義一個 const 在 * 右邊的例子, 意思是 地址是常量//按照規則, 指針地址不可改變, 指針指向的內容可變int* const p = &i;//指針指向的數據不可改變, 這里會報錯p = NULL;return 0; }

• 4.代碼示例4 : const 同時出現在 * 左邊 和 右邊, const int* const p = &i;

#include <stdio.h>int main() {//定義普通的變量, 用于取地址用int i = 666;//定義 const 同時出現在 * 左邊 和 右邊, 則指針的地址 和 指向的數據都不可改變const int* const p = &i;//下面的兩個操作, 一個是想修改指針地址, 一個是想修改指針值, 這兩個都報錯.p = NULL;*p = 444;return 0; }

---

( 5 ) const 關鍵字 代碼示例 ( 修飾返回值 )

const 關鍵字 代碼示例 : const 修飾返回值

• 1.代碼示例 :

#include <stdio.h>//返回的指針 使用 const 修飾, //const 在 指針* 的左邊, 即其指向的內容是常量, 不可更改 const int* function() {//聲明靜態局部變量,該變量只初始化一次, 之后重復使用static int count = 0;count ++;return &count; }int main() {//使用 const int* 類型才可以接收 返回值是 const int* 類型的返回值//如果沒有 const 修飾, 會報警告const int* p = function();printf("%d\n", *p);return 0; }

• 2.執行結果 :
  

---

2. volatile 關鍵字 簡介

(1) volatile 關鍵字 簡介 ( 告訴編譯器 每次去內存中取變量值 | )

volatile 關鍵字簡介 :

• 1.作用 : 編譯器 警告指示, 告訴編譯器 每次去內存中取變量值 , 防止編譯器自己做優化, 改變了程序的執行邏輯;
• 2.使用情況 : ① 一個變量可能被多個變量同時訪問的情況, ② 變量可能被未知因素更改的情況 ;

---

(2) volatile 關鍵字 代碼示例

編譯器優化案例 : 有時我們不需要編譯器的優化, 有時編譯器優化完了反而得不到我們想要的執行效果 ;

• 代碼示例說明 :

#include <stdio.h> #include <unistd.h>　int main() {//value 全程沒有做過左值, 值當做右值為 a 和 b 賦值用//編譯器會將 value 當做常量, 使用 666 替代 value//如果使用 valatile 修飾value, 在編譯的時候, 編譯器就不會進行這種替換.int value = 666;//a 和 b 初始值為0int a = 0;int b = 0;//編譯器在編譯時, 直接將 666 賦值給了 aa = value;sleep(1000);//如果在休眠的 1000 ms, //value內存值變成了 888, 我們想要的是888, 但是編譯器自作主張將 b 賦值為了 666//這樣就無法實現我們想要的意圖b = value;return 0; }

---

四. 結構體 聯合體 關鍵字 ( struct | union )

1. struct 關鍵字

(1) 結構體定義 使用 ( ① 結構體定義 : struct 結構體名稱 {}; | ② 結構體變量聲明 : struct 結構體名 變量名 ; | ③ 定義結構體同時聲明結構體變量 : struct 結構體名稱 {} 變量名 ; | ④ 結構體定義別名 : typedef struct 結構體名稱 {} 別名名稱; 聲明變量 : 別名名稱 變量名稱 ; [ 定義一個別名后, ] | ⑤ 結構體定義別名省略結構體名稱 : typedef struct {} 別名名稱; 聲明變量 : 別名名稱 變量名稱 ; )

結構體定義 :

• 1.結構體定義最標準方法 : 最基本的方法, 聲明一個結構體, 使用 struct 結構體名 變量名 來聲明結構體變量;

//定義結構體 struct Student {char* name;int age; };//聲明結構體變量 struct Student stu;

• 2.定義結構體同時聲明結構體變量 : 在定義結構體的大括號后 寫上變量名;

//定義結構體的同時 聲明結構體變量 struct Student {char* name;int age; }stu;

• 3.定義結構體同時聲明變量 但不定義結構體類型名稱 : 定義結構體時如果不給出結構體的名稱, 那么只能在定義結構體時 同時 聲明該變量, 該結構體只有一個變量;

//定義結構體的同時 聲明結構體變量, 如果不給出結構體類型名稱, 在別處不能聲明該類型的結構體變量 struct {char* name;int age; }stu;

• 4.結構體定義別名 : 定義了別名的結構體, 在聲明結構體變量時可以不適用 struct 關鍵字;

//定義結構體類型, 并給 _student 定義一個別名 student typedef struct _student {char* name;int age; }student;//聲明結構體變量 student stu;

-5.定義結構體別名 但是沒有給出結構體的類型名稱 : 如果使用 typedef 定義了一個結構體的別名, 那么該結構體可以不定義結構體類型名稱;

//定義結構體類型, 并定義一個別名 student, 可以不定義結構體的類型名稱 typedef struct {char* name;int age; }student;//聲明結構體變量 student stu;

---

(2) struct 結構體大小

空結構體占用內存大小 :

• 1.C規范定義 : C語言規范中沒有定義空結構體的大小,不同編譯器有不同的默認值0或者1字節;
• 2.代碼示例 :

#include <stdio.h>//定義一個空結構體,用來測試空結構體的大小 struct A { };int main() {//定義兩個空結構體變量,打印其大小和地址值struct A a1;struct A a2;//打印空結構體類型大小printf("%ld\n", sizeof(struct A));//打印兩個空結構體大小 和 空結構體變量地址printf("%ld, %0X\n", sizeof(a1), &a1);printf("%ld, %0X\n", sizeof(a2), &a2);return 0; }

• 3.執行結果 :
  

空結構體變量類型大小為0,其變量的大小為0,其地址錯位1.

---

(3) struct 結構體實現柔性數組

柔性數組 :

• 1.普通數組 : 在定義的時候定義數組的大小,并且在棧上分配內存;
• 2.柔性數組 : 數組的大小未知,定義完之后可設置數組大小;
• 3.實現方式 : 使用結構體實現柔性數組.
• 4.代碼示例 :

#include <stdio.h> #include<stdlib.h>//定義柔性數組 typedef struct soft_array {int len;int array[]; } soft_array;int main() {//打印 結構體 soft_array 的類型大小, 結果是4字節//分析 : int array[] 是一個未知大小的數組, 編譯器不知道該數組多大, 就將該數組大小當做0//sizeof 計算的 結構體的 4 個字節是 int 類型的大小, 后面的 int array[] 只是占位符, 可以分配任意大小的數組printf("%ld\n", sizeof(soft_array));//為柔性數組分配內存空間, 結構體的基本空間 + 數組大小soft_array* array = (soft_array*)malloc(sizeof(soft_array) + sizeof(int) * 10);//設置柔性數組大小array->len = 10;int i = 0;//以此遍歷為柔性數組賦值for(i = 0; i < array->len; i ++){array->array[i] = i;}//依次遍歷打印柔性數組的值for(i = 0; i < array->len; i ++){printf("%d\n", array->array[i]);}return 0; }

• 5.執行結果 :

---

(4) 柔性數組 代碼示例 ( 處理斐波那契數列 )

柔性數組使用 :

• 1.代碼示例 :

#include <stdio.h> #include<stdlib.h>/*柔性數組實現斐波那契數列1. 定義柔性數組結構, typedef struct soft_array 實現;2. 創建柔性數組, 編寫一個創建函數 create_array() 方法;3. 生成斐波那契數列, generate_array() 方法;4. 釋放柔性數組, delete_array() 方法. *///1.定義柔性數組結構體 typedef struct soft_array {int len;int array[]; } soft_array;//2.創建柔性數組的函數 soft_array* create_array(int array_size) {soft_array* array = NULL;//數組大小必須大于0if(array_size > 0){//從堆空間申請一個柔性數組內存空間array = (soft_array*)malloc(sizeof(*array) + sizeof(*(array->array)) * array_size);array->len = array_size;}return array; }//3.生成斐波那契數列并放入柔性數組 void generate_array(soft_array* array) {//傳入的彈性數組不能為空if(array != NULL){//第一二項為1,后面第三項開始就是前兩項之和if(array->len == 1){//數組大小就1個直接賦值1array->array[0] = 1;}else if (array->len == 2){//數組大小2個,這兩個都賦值1array->array[0] = 1;array->array[1] = 1;}else{//如果超過2個,前兩個賦值1,然后依次計算array->array[0] = 1;array->array[1] = 1;int i = 0;for(i = 2; i < array->len; i ++){array->array[i] = array->array[i - 1] + array->array[i - 2];}}} }//4.刪除柔性數組 void delete_array(soft_array* array) {//釋放內存空間free(array); }int main() {//創建柔性數組, 為柔性數組分配內存空間, 結構體的基本空間 + 數組大小soft_array* array = create_array(10);//生成斐波那契數列generate_array(array);int i = 0;//依次遍歷打印柔性數組的值for(i = 0; i < array->len; i ++){printf("%d\n", array->array[i]);}//釋放柔性數組delete_array(array);return 0; }

• 2.執行結果 :
  

---

3. union 聯合體 關鍵字

(1) struct 和 union 的區別 ( struct 為每個元素分配獨立空間 | union 只為最大的元素分配內存空間 所有元素共享該空間 )

struct 和 union 的區別 :

• 1.struct 分配空間 : struct 結構體 為每個結構體元素分配獨立的內存空間 ;
• 2.union 分配空間 : union 聯合體 只為最大的聯合體元素分配內存控件, 所有的元素共享該空間 ;
• 3.struct union 空間分配示例 :

#include <stdio.h>//結構體需要為所有的元素分配內存空間 //該結構體占 8 個字節內存空間 struct A {int a;int b; };//聯合體只分配最大元素所占的內存空間 //該 聯合體 占 4 字節 內存空間 union B {int a;int b; };int main() {printf("%ld\n", sizeof(struct A));printf("%ld\n", sizeof(union B));return 0; }

• 4.執行結果 :

---

(2) union 聯合體注意事項 ( 受大小端影響 )

union 聯合體 受大小端 影響 :

• 1.大端模式 : 低位數據放在 高位地址 中;
• 2.小端模式 : 低位數據放在 低位地址 中;

通過 union 判斷系統的大小端 :

• 1.代碼示例 :

#include <stdio.h>//利用union聯合體賦值受大小端影響的特性, //判斷當前的系統是大端模式還是小端模式 int big_or_small_check() {//定義聯合體,其中定義int和char類型元素,兩個元素共用一個內存空間union check_end{int i;char c;} a;//將大空間的int賦值為1a.i = 1;//四個字節賦值為1,如果是小端模式,那么高位地址都是0,最低位個字節是1//char是占用最低位字節, 如果char 為1,說明就是小端模式if(a.c == 1){printf("small end\n");}else{printf("big end\n");}}int main() {big_or_small_check();return 0; }

• 2.執行結果 :

---

五. 枚舉 關鍵字 ( enum )

1. enum 關鍵字

(1) enum 枚舉關鍵介紹 ( 定義常量 | 只能定義 int 類型 )

enum 簡介 :

• 1.作用 : enum 是自定義類型, 作用是用來定義常量的 ;
• 2.定義要求 : enum 只能定義成 int 類型. 不能定義成 浮點型 ;

---

(2) enum 枚舉代碼示例

enum 枚舉代碼示例 :

• 1.代碼示例 :

#include <stdio.h>//enum 如果沒有指明, 默認值是從 0 開始 //如果沒有指定值, 那么后面一個默認是在前一個基礎上加1 //如果顯示的賦值后, 后面的類型依次加 1, 顯示賦值之前的默認從 0 開始 //枚舉是常量, 不能獲取枚舉的地址 enum color {RED,YELLOW,BLUE = 666,GRAY };int main() {printf("%d\n", RED);printf("%d\n", YELLOW);printf("%d\n", BLUE);printf("%d\n", GRAY);return 0; }

• 2.執行結果 :
  

---

(3) enum 和 define 區別 ( #define 編譯時進行替換 | enum 是常量值 )

enum 與 define 區別 :

• 1.本質 : #define 是在編譯的時候進行簡單的替換, enum 枚舉是常量值.
• 2.能否被調試 : #define 宏 無法調試, enum 可以;
• 3.類型 : #define 沒有類型信息, enum 是 有特定的類型 的;
• 代碼示例 :

#include <stdio.h>#define LEN 888int main() {//在編譯的時候, #define 定義的 LEN 直接替換成 888 數字int i = LEN;int array[LEN];return 0; }

---

2. typedef 關鍵字

( 1 ) typedef 關鍵字介紹 ( 給已有類型重新命名 | 沒有新類型 | 無法擴展 )

typedef 介紹 :

• 1.作用 : typedef 用于給 存在的數據類型 重新命名;
• 2.沒有新類型 : typedef 關鍵字使用, 全程都沒有產生 新的數據類型 ;
• 3.類型無法擴展 : 不能使用 unsigned 和 signed 等擴展 typedef 重命名的類型;

typedef 與 define 區別 :

• 1.typedef 本質 : typedef 是給已有類別重新命名;
• 2.define 本質 : define是簡單的字符串替換, 沒有類別 類型 等其它含義 ;
• 3.代碼示例 :

#include <stdio.h>typedef char* PCHAR #define PINT int*int main() {//這里 p1 和 p2 都是 char* 類型PCHAR p1, p2;//這里注意, 編譯時PINT 會被替換成 int* p3, p4//注意 *p3 是指針, p4 是 int 類型數據, int *p3, p4PINT p3, p4;return 0; }

---

總結

以上是生活随笔為你收集整理的【C语言】 C 语言 关键字分析 ( 属性关键字 | 常量关键字 | 结构体关键字 | 联合体关键字 | 枚举关键字 | 命名关键字 | 杂项关键字)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。