目錄

• 一、數(shù)據(jù)類型和表達(dá)式
• • 1.基本類型
  • 2.構(gòu)造類型
  • • 1）數(shù)組類型
    • 2）[結(jié)構(gòu)體類型](#jiegou)
    • 3）[共用體類型](#lianhe)
  • 3.常量
  • 4.運(yùn)算表達(dá)式
  • • 1）算術(shù)運(yùn)算表達(dá)式：
    • 2）關(guān)系運(yùn)算表達(dá)式：
    • 3）邏輯運(yùn)算符：
    • 4）位運(yùn)算符：
• 二、C語言的語句
• • 1.表達(dá)式語句
  • 2.函數(shù)調(diào)用語句
  • 3.控制語句
  • • 1）條件判斷語句：
    • 2）循環(huán)執(zhí)行語句：
    • 3）轉(zhuǎn)向語句：
  • 4.復(fù)合語句
  • 5.空語句
  • 6.案例
  • • 1）海倫公式
    • 2）一元二次方程
• 三、函數(shù)
• • 1.函數(shù)的概念
  • 2.函數(shù)的定義方式
  • 3.函數(shù)的參數(shù)
  • 4.函數(shù)的返回值
  • 5.函數(shù)的調(diào)用
  • 6.全局變量與局部變量
  • • 1）全局變量
    • 2）局部變量
  • 7.靜態(tài)變量與寄存器變量
  • • 1）靜態(tài)變量
    • 2）寄存器變量
  • 8.預(yù)處理命令
  • • 1）宏定義
    • 2）文件包含
    • 3）條件編譯
• 四、指針
• • 1.變量的指針&指針變量
  • • 1）指針變量的定義
  • 2）指針的操作
  • 2.數(shù)組的指針&指針數(shù)組
  • • 1）數(shù)組的指針
    • 2）指針數(shù)組
  • 3.字符串的指針
  • 4.函數(shù)的指針&指針型函數(shù)
  • • 1）函數(shù)的指針
    • 2）指針型函數(shù)
  • 5.指向指針的指針
• 五、結(jié)構(gòu)體和共用體
• • 1.結(jié)構(gòu)體
  • • 1）結(jié)構(gòu)體的定義
    • 2）結(jié)構(gòu)體的用法
  • 2.共用體（聯(lián)合體）
  • • 1）共用體的定義
    • 2）共用體的用法
  • 3.枚舉
  • • 1）枚舉的定義
    • 2）枚舉的用法
  • 4.動(dòng)態(tài)內(nèi)存分配
  • • 1）malloc
    • 2）calloc
    • 3）realloc
    • 4）free
  • 5.位域
• 六、文件操作
• • 1.文件的概念
  • 2.文件指針
  • 3.操作文件的函數(shù)
  • • 1）打開與關(guān)閉
    • 2）文件讀寫
    • 3）文件定位
    • 4）文件檢測
    • 5）文件操作示例

一、數(shù)據(jù)類型和表達(dá)式

C語言中二進(jìn)制數(shù)、八進(jìn)制數(shù)和十六進(jìn)制數(shù)的表示:

• 二進(jìn)制：二進(jìn)制由 0 和 1 兩個(gè)數(shù)字組成，使用時(shí)必須以0b或0B（不區(qū)分大小寫）開頭。例如：0b101、0B001
  注意：標(biāo)準(zhǔn)的C語言并不支持二進(jìn)制寫法，有些編譯器自己進(jìn)行了擴(kuò)展，才會(huì)支持二進(jìn)制數(shù)字
• 八進(jìn)制：八進(jìn)制由 0~7 八個(gè)數(shù)字組成，使用時(shí)必須以0開頭（注意是數(shù)字 0，不是字母 o），例如：015（十進(jìn)制的13）、0177777（十進(jìn)制的65535）
• 十六進(jìn)制：十六進(jìn)制由數(shù)字 0~9、字母 A~F 或 a~f（不區(qū)分大小寫）組成，使用時(shí)必須以0x或0X（不區(qū)分大小寫）開頭，例如：0X2A（十進(jìn)制的43）、0xffff（十進(jìn)制的65535）

• 整型(int)
• 字符型(char)
• 實(shí)型（浮點(diǎn)型）
  • 單精度型(float)
  • 雙精度型(double)
• 枚舉類型
  下面是詳細(xì)的類型說明：

1）數(shù)組類型

數(shù)組：按序排列的同類數(shù)據(jù)元素的集合

• 一維數(shù)組：類型說明符 數(shù)組名[數(shù)組長度];
• 二維/多維數(shù)組：類型說明符 數(shù)組名[行數(shù)][列數(shù)]; 多維數(shù)組以此類推
• 字符數(shù)組：char 數(shù)組名[數(shù)組長度];C語言沒有字符串類型，字符串通常用字符數(shù)組表示

數(shù)組定義：類型說明符 數(shù)組名[長度];
數(shù)組引用：
一維數(shù)組數(shù)組名[索引]; 二維數(shù)組數(shù)組名[行索引][列索引];
注：索引都是從0開始
數(shù)組賦值：
1.在定義的時(shí)候賦初值：int a[10]={1,2,3,4,5,6,7,8,9,10};或int a[]={1,2,3,4,5,6,7,8,9,10};
2.先定義,再賦值：int a[10];a = {1,2,3,4,5,6,7,8,9,10};
字符數(shù)組賦值：
1.char Hello[] = {'H','e','l','l','o'};
2.char Hello[] = "Hello";
注：字符數(shù)組第二種賦值方式比第一種方式多占一個(gè)字符，因?yàn)榈诙�種方式會(huì)在字符數(shù)組中結(jié)尾添加一個(gè)\0作為字符串結(jié)束符

提示：數(shù)組賦值時(shí)，如果給定值數(shù)量小于數(shù)組長度，系統(tǒng)默認(rèn)填充0

示例：

#include <stdio.h>
int main() {
  
    //=====================一維數(shù)組===============
    int a[5] = {
  1, 2}; // a={1,2,0,0,0}
    int b[] = {
  1, 2, 3, 4, 5};// b={1,2,3,4,5}
    int c[10];// 沒有賦初始值系統(tǒng)會(huì)自動(dòng)賦值一個(gè)無意義的數(shù)字，可以自行printf輸出查看
    printf("a第二個(gè)元素：%d\nb第一個(gè)元素：%d\n", a[1], b[0]);
    //=====================二維數(shù)組===============
    int aa[2][3] = {
  1, 2, 3, 4, 5, 6};// C語言是按行編址，所以可以這樣賦值
    int bb[2][3] = {
  
            {
  1, 2, 3},
            {
  4, 5, 6}
    };
    //aa和bb這兩個(gè)數(shù)組是相同的
    printf("aa第1行第1列元素：%d\n", aa[0][0]);
    printf("bb第1行第2列元素：%d\n", bb[0][1]);
    //=====================字符串===============
    char name[8] = {
  'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g'};
    char name2[] = "xiaohong";
    printf("第一個(gè)名字：%s第二個(gè)名字：%s", name, name2);
    return 0;
}

2）結(jié)構(gòu)體類型

3）共用體類型

C語言中常量的定義有兩種方式，假如我們要定義一個(gè)int類型的常量TEMP，值為1：

• 預(yù)定義命令： #define TEMP = 1
• const關(guān)鍵字：const int TEMP = 1

1）算術(shù)運(yùn)算表達(dá)式：

• 加：+
• 減：-
• 乘：*
• 除：/
• 取余：%
• 自增：++
• 自減：--

注意：自增和自減跟賦值運(yùn)算結(jié)合的時(shí)候如果運(yùn)算符在左邊，會(huì)先進(jìn)行自增或自減運(yùn)算，請(qǐng)看下面例子：

void test1(){
  
int a = 1;
int b = ++a; //結(jié)果是b=2
}
void test2(){
  
int a = 1;
int b = a++; //結(jié)果是b=1
}

2）關(guān)系運(yùn)算表達(dá)式：

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

3）邏輯運(yùn)算符：

C語言中非0為真

• 與：&&
• 或：||
• 非：!

4）位運(yùn)算符：

• 位與：&
  對(duì)每一位進(jìn)行邏輯與運(yùn)算，0表示假，1表示真：0011 & 1111 = 0011
• 位或：|
  對(duì)每一位進(jìn)行邏輯或運(yùn)算，0表示假，1表示真：0011 | 1111 =1111
• 位非：~
  對(duì)每一位進(jìn)行邏輯非運(yùn)算，0表示假，1表示真：~1111 =0000
• 位異或：^
  對(duì)每一位進(jìn)行邏輯異或運(yùn)算，0表示假，1表示真：0011 ^ 1111 =1100
• 左移：<<
  高位溢出丟棄，低位不足補(bǔ)0：01100100 << 2 = 10010000
• 右移：>>
  • 正數(shù)：高位補(bǔ)0，低位溢出舍去：01111111 >> 4 = 00000111
  • 負(fù)數(shù)：高位補(bǔ)1，低位溢出舍去：11111111 >> 4 = 11111111

二、C語言的語句

定義：由表達(dá)式和分號(hào)組成的語句：x + y = z;

定義：函數(shù)名、實(shí)際參數(shù)和分號(hào)組成：函數(shù)名(參數(shù));

1）條件判斷語句：

• if語句：單條件判斷語句

// 用法
if (條件表達(dá)式){
  
 // 條件滿足
 要執(zhí)行的語句
}

• if…else…語句：條件分支語句

// 用法
if (條件表達(dá)式){
  
 // 條件滿足
 要執(zhí)行的語句
}else{
  
 // 條件不滿足
 要執(zhí)行的語句
}

• if…else if…else…語句：多條件分支語句

// 用法
if (條件表達(dá)式1){
  
 // 滿足條件表達(dá)式1
 要執(zhí)行的語句;
}else if (條件表達(dá)式2) {
  
 // 滿足條件表達(dá)式2
 要執(zhí)行的語句;
}else if (條件表達(dá)式3) {
  
 // 滿足條件表達(dá)式3
 要執(zhí)行的語句;
}
...
else if (條件表達(dá)式n) {
  
 // 滿足條件表達(dá)式n
 要執(zhí)行的語句;
}else{
  
 // 所有條件表達(dá)式都不滿足
 要執(zhí)行的語句;
}

• switch語句：開關(guān)語句，一般配合case關(guān)鍵字使用

switch(表達(dá)式)
{
  
 case 常量1： 
  // 如果表達(dá)式的值等于常量1，執(zhí)行下面的語句1
  語句1 ;
  break;
 case 常量2： 
  // 如果表達(dá)式的值等于常量2，執(zhí)行下面的語句2
  語句2;
  break;
  ...
 case 常量n:
  // 如果表達(dá)式的值等于常量n，執(zhí)行下面的語句n
  語句n;
  break;
 default:
  // 默認(rèn)執(zhí)行的語句，如果沒有通過上面的開關(guān)語句退出，就會(huì)執(zhí)行下面的語句n+1
  語句n+1;
  //break; // default可以省略break;因?yàn)樗�本身就是最后�?zhí)行，執(zhí)行完就會(huì)退出開關(guān)語句。
}

注：switch語句如果沒有break會(huì)一直向下執(zhí)行直到結(jié)束。

2）循環(huán)執(zhí)行語句：

• for語句

結(jié)構(gòu)：
for (表達(dá)式1;表達(dá)式2;表達(dá)式3){
語句;
}
循環(huán)邏輯：
step1：先執(zhí)行表達(dá)式1
step2：然后執(zhí)行表達(dá)式2，
step3：如果step2結(jié)果為真，執(zhí)行語句，否則退出循環(huán)
step4：如果step3沒有退出循環(huán)，則執(zhí)行表達(dá)式3
step5：重復(fù)執(zhí)行step2-step4直至循環(huán)退出

//用法
for (循環(huán)變量賦初值;循環(huán)條件;循環(huán)變量增量){
  
 執(zhí)行語句;
}

• while語句

條件循環(huán)語句，當(dāng)滿足循環(huán)條件的情況下循環(huán)執(zhí)行

//用法
while (循環(huán)條件){
  
 執(zhí)行語句;
}

• do while語句

與while循環(huán)的區(qū)別：do…while會(huì)先執(zhí)行一遍循環(huán)體里面的語句，再進(jìn)行條件判斷，也就是說，do…while至少會(huì)執(zhí)行一次循環(huán)體中的語句

//用法
do{
  
 執(zhí)行語句;
}while (循環(huán)條件);

3）轉(zhuǎn)向語句：

• continue：continue語句一般用于循環(huán)結(jié)構(gòu)中，作用是跳過當(dāng)次循環(huán)，當(dāng)循環(huán)語句執(zhí)行到continue時(shí)，不會(huì)繼續(xù)向下執(zhí)行，會(huì)跳過當(dāng)次循環(huán)，直接執(zhí)行下一次循環(huán)。
• break：中斷語句，一般用于循環(huán)結(jié)構(gòu)中，作用是終止循環(huán)，當(dāng)執(zhí)行到break語句時(shí)，會(huì)立即退出循環(huán)。
• return：跳出函數(shù)語句，用于跳出函數(shù)并返回一個(gè)值。
• goto：強(qiáng)制轉(zhuǎn)向語句（不推薦使用）

//用法
int main(){
  
 int a=1;
 int b=5;
 loop: if (a<b){
  
  printf("%d\n",a);
  a++;
  goto loop;
 }
 return 0;
}

輸出結(jié)果：
1
2
3
4
說明：goto語句一般用于跟if語句結(jié)合形成循環(huán)結(jié)構(gòu)，需要先定義一個(gè)標(biāo)志符（loop），表示goto轉(zhuǎn)向到哪個(gè)地方。

定義：將多個(gè)語句用大括號(hào)括起來組成一個(gè)復(fù)合語句

{
  
 int a = 1;
 a++;
 int b = a + 1;
}

定義：只有分號(hào)組成的語句稱為空語句

;

1）海倫公式

根據(jù)三角形的三條邊求出面積：S= p ( a − p ) ( b − p ) ( c − p ) \sqrt{p(a-p)(b-p)(c-p)} p(a−p)(b−p)(c−p) ​

S:面積 p:周長的1/2 a,b,c:三角形的三條邊長

#include "stdio.h"
#include "math.h"
int main(){
  
    float a;
    float b;
    float c;
    float area;
    float p;
    printf("請(qǐng)輸入構(gòu)成三角形的三條邊的長度：");
    scanf("%f,%f,%f", &a, &b, &c);
    p = (a+b+c)/2;
    area = sqrt(p*(a-p)*(b-p)*(c-p));
    printf("三角形面積是：%f",area);
    return 0;
}

2）一元二次方程

#include <stdio.h>
#include "math.h"
int main() {
  
    float a,b,c;
    float p,x1,x2;
    printf("請(qǐng)輸入一元二次方程的3個(gè)系數(shù)a,b,c：ax^2+bx+c=0(a≠0)\n");
    scanf("%f,%f,%f",&a,&b,&c);
    p = sqrt(b*b-4*a*c);
    x1 = (-b+p)/(2*a);
    x2 = (-b-p)/(2*a);
    printf("方程的解為：x1=%f,x2=%f",x1,x2);
    return 0;
}

三、函數(shù)

函數(shù)是實(shí)現(xiàn)了某種功能的代碼塊

• 庫函數(shù)：由Ｃ系統(tǒng)提供，用戶無須定義，也不必在程序中作類型說明，只需在程序前包含有該函數(shù)原型的頭文件即可在程序中直接調(diào)用。
• 用戶定義函數(shù)：由用戶按需要寫的函數(shù)。對(duì)于用戶自定義函數(shù)，不僅要在程序中定義函數(shù)本身，而且在主調(diào)函數(shù)模塊中還必須對(duì)該被調(diào)函數(shù)進(jìn)行類型說明，然后才能使用。

• 無參函數(shù)：

類型標(biāo)識(shí)符 函數(shù)名() {
 聲明部分;
 語句;
}

• 有參函數(shù)：

類型標(biāo)識(shí)符 函數(shù)名(形參1,形參2,形參3...形參n) {
 聲明部分;
 語句;
}

• 示例：下面定義了兩個(gè)函數(shù)，第一個(gè)HelloWorld是無參函數(shù)，功能是輸出一個(gè)"Hello World!"字符串，第二個(gè)FindMax是有參函數(shù)，接收兩個(gè)int類型的參數(shù)，返回兩個(gè)數(shù)中最大的那個(gè)數(shù)

//void HelloWorld();
//int FindMax(int a,int b);
//上面是對(duì)函數(shù)進(jìn)行聲明，函數(shù)的調(diào)用必須先定義，否則編譯不通過，如果定義在調(diào)用函數(shù)之后，需要先聲明
void HelloWorld() {
  
    printf("Hello World!");
}
int FindMax(int a, int b) {
  
    int max;
    max = a >= b ? a : b;
    return max;
}
int main(){
  
 HelloWorld();
    int a = 5;
    int b = 10;
    int c;
    c = FindMax(a, b);
    printf("\n最大數(shù)為：%d\n", c);
    return 0;
}

• 形參：形參出現(xiàn)在函數(shù)定義中，在整個(gè)函數(shù)體內(nèi)都可以使用，離開該函數(shù)則不能使用。
• 實(shí)參：實(shí)參在主調(diào)函數(shù)中，是調(diào)用函數(shù)時(shí)傳遞的參數(shù)。
• 參數(shù)傳遞：函數(shù)的參數(shù)由主調(diào)函數(shù)的實(shí)參傳遞給被調(diào)函數(shù)的形參，因此實(shí)參與形參的順序、類型必須保持一致。

函數(shù)返回值是一個(gè)類型與函數(shù)聲明中定義的返回類型相同的值，如果函數(shù)聲明中沒有定義返回類型，則默認(rèn)為 int 類型。
例如，下面是一個(gè)簡單的 C 函數(shù)，它返回一個(gè)整數(shù)值：

int max(int a, int b)
{
  
    if (a > b) {
  
        return a;
    } else {
  
        return b;
    }
}

在這個(gè)例子中，函數(shù) max() 定義了兩個(gè) int 類型的參數(shù) a 和 b，并在函數(shù)體內(nèi)部判斷它們的大小關(guān)系。如果 a 大于 b，則函數(shù)返回 a 的值；否則，函數(shù)返回 b 的值。

另外，如果函數(shù)聲明中定義了 void 類型的返回值，則表示函數(shù)不會(huì)返回任何值。在這種情況下，函數(shù)體內(nèi)部不能使用 return 語句返回值。例如：

void print_hello()
{
  
    printf("Hello, world!\n");
}

在這個(gè)例子中，函數(shù) print_hello() 不需要返回任何值，因此聲明中定義的返回類型為 void。

• 調(diào)用的一般形式為：函數(shù)名(實(shí)參);
• 被調(diào)用函數(shù)的聲明和函數(shù)原型：在主調(diào)函數(shù)中調(diào)用某函數(shù)之前應(yīng)對(duì)該被調(diào)函數(shù)進(jìn)行說明（聲明），這與使用變量之前要先進(jìn)行變量說明是一樣的。在主調(diào)函數(shù)中對(duì)被調(diào)函數(shù)作說明的目的是使編譯系統(tǒng)知道被調(diào)函數(shù)返回值的類型，以便在主調(diào)函數(shù)中按此種類型對(duì)返回值作相應(yīng)的處理。
  其一般形式為： 類型說明符 被調(diào)函數(shù)名(類型 形參，類型 形參...);或 類型說明符 被調(diào)函數(shù)名(類型，類型...);

作用域：表示一個(gè)變量起作用的范圍，例如：

{
  
 int a = 1; //a的作用域就是這個(gè)代碼塊，在代碼塊外部就無法訪問變量a
}

1）全局變量

• 定義：全局變量也稱為外部變量，它是在函數(shù)外部定義的變量。它不屬于哪一個(gè)函數(shù)，它屬于一個(gè)源程序文件。其作用域是整個(gè)源程序。
• 使用：在全局變量定義之前的函數(shù)中使用全局變量，需要使用關(guān)鍵字extern做全局變量說明,聲明某個(gè)變量是全局變量，然后才能使用；在全局變量定義之后的函數(shù)中使用全局變量，可以省略extern關(guān)鍵字，不做全局變量說明也可以使用。

int a = 5; // 此處a為全局變量
int main(void){
  
 int extern a; // 全局變量說明，聲明a是一個(gè)全局變量，此處在a定義之后，可以省略該說明
 printf("%d", a); //輸出結(jié)果為5
}

2）局部變量

• 定義：局部變量也稱為內(nèi)部變量。局部變量是函數(shù)內(nèi)部定義的變量，作用域僅限于函數(shù)內(nèi)部，局部變量只能在函數(shù)內(nèi)部使用，函數(shù)外部無法訪問。

int main(void){
  
 int a = 5; // 這是一個(gè)局部變量，a的作用域范圍是main函數(shù)內(nèi)，在函數(shù)外無法使用
 print("%d", a);
 a++;
}
print("%d", a);//全局作用域內(nèi)找不到變量a，編譯不通過

1）靜態(tài)變量

• 定義：靜態(tài)變量是在函數(shù)調(diào)用結(jié)束后不消失而保留原值的變量，如果在一個(gè)函數(shù)調(diào)用結(jié)束后，希望它保留某個(gè)變量的值，就把這個(gè)變量用static關(guān)鍵字聲明為靜態(tài)變量。

// 定義一個(gè)自增函數(shù)，初始化局部靜態(tài)變量a為0，每調(diào)用一次，a自增1
int Add() {
  
    static int a = 0;
    a++;
    return a;
}
int main(){
  
 print("%d", Add());// 輸出結(jié)果為1
 print("%d", Add());// 輸出結(jié)果為2
 return 0;
}

2）寄存器變量

• 定義：寄存器變量是放在CPU寄存器中的變量，CPU寄存器可以理解為CPU的內(nèi)存空間，就像是電腦的內(nèi)存一樣，在寄存器中運(yùn)算速度非常快。使用register關(guān)鍵字聲明。
• 注意：
  • 只有局部自動(dòng)變量（非靜態(tài)變量）和形參可以作為寄存器變量
  • 一個(gè)計(jì)算機(jī)系統(tǒng)中的寄存器數(shù)目有限，不能定義任意多個(gè)寄存器變量
  • 局部靜態(tài)變量不能定義為寄存器變量

#include "stdio.h"
// 這是一個(gè)計(jì)算n的階乘的函數(shù)，將局部變量i和f聲明為寄存器變量
int fac(int n) {
  
    register int i, f = 1;
    for (i = 1; i <= n; i++) {
  
        f = f * i;
    }
    return f;
}
int main() {
  
    int i;
    for (i = 0; i <= 5; i++) {
   
        printf("%d!=%d\n", i, fac(i)); 
    }
    return 0;
}

預(yù)處理是指在進(jìn)行編譯的第一遍掃描(詞法掃描和語法分析)之前所作的工作。預(yù)處理是Ｃ語言的一個(gè)重要功能，它由預(yù)處理程序負(fù)責(zé)完成。
Ｃ語言提供了多種預(yù)處理功能，如宏定義、文件包含、條件編譯等。

1）宏定義

C語言可以使用#define定義宏（類似常量），程序在編譯處理時(shí)會(huì)把源程序中所有的宏名替換成宏定義的結(jié)果。
宏定義是由源程序中的宏定義命令完成的。宏代換是由預(yù)處理程序自動(dòng)完成的。

• 無參宏定義：#define 標(biāo)識(shí)符 字符串 （“字符串”可以是常數(shù)、表達(dá)式、格式串等）

所有出現(xiàn)在源程序中的宏名都會(huì)替換成宏定義的字符串
例如：

#include <stdio.h>
#define PI 3.1415926
#define M (a+a)
int main(void) {
  
  double a = 1.0;
   double b;
   b = 2*M + PI; // 等同于2*(a+a) + 3.1415926
   printf("%f", b);
   return 0;
}

• 帶參宏定義：#define 宏名(形參1,形參2,形參3,...形參n) 字符串 （“字符串”可以是常數(shù)、表達(dá)式、格式串等）

類似于定義一個(gè)匿名函數(shù)

>#include <stdio.h>
#define S(x,y) x*y // S表示矩形面積，x，y分別表示長寬
int main(void) {
  
  double a = 3.0,b = 4.0;
   double s;
   s = S(a,b); // 等同于a*b
   printf("%f", s);
   return 0;
}

2）文件包含

文件包含命令的功能是把指定的文件插入該命令行位置取代該命令行，從而把指定的文件和當(dāng)前的源程序文件連成一個(gè)源文件。
文件包含的形式為：#include "文件名"或#include <文件名>
上面兩種形式的區(qū)別：使用尖括號(hào)表示在包含文件目錄中去查找(包含目錄是由用戶在設(shè)置環(huán)境時(shí)設(shè)置的)，而不在源文件目錄去查找；使用雙引號(hào)則表示首先在當(dāng)前的源文件目錄中查找，若未找到才到包含目錄中去查找。

3）條件編譯

預(yù)處理程序提供了條件編譯的功能。可以按不同的條件去編譯不同的程序部分，因而產(chǎn)生不同的目標(biāo)代碼文件。

條件編譯有以下三種形式：

• 第一種：如果標(biāo)識(shí)符已被 #define命令定義過則對(duì)程序段 1 進(jìn)行編譯；否則對(duì)程序段 2 進(jìn)行編譯。

#ifdef 標(biāo)識(shí)符
 程序段 1
#else
 程序段 2
#endif

• 第二種：如果標(biāo)識(shí)符未被#define命令定義過則對(duì)程序段 1 進(jìn)行編譯，否則對(duì)程序段 2 進(jìn)行編譯。

#ifndef 標(biāo)識(shí)符 
 程序段 1 
#else 
 程序段 2 
 #endif

• 第三種：常量表達(dá)式的值為真(非 0)，則對(duì)程序段 1 進(jìn)行編譯，否則對(duì)程序段 2 進(jìn)行編譯。

#if 常量表達(dá)式
 程序段 1
#else 
 程序段 2
#endif

四、指針

指針是指存儲(chǔ)單元的地址，例如定義一個(gè)變量int a = 1;指向變量a的指針就是a在內(nèi)存中的地址。

• 變量的指針：就是變量的內(nèi)存地址。
• 指針變量：存放變量地址的變量。
  解釋：比如有個(gè)變量a，變量a的地址是p，p就是變量a的指針。現(xiàn)在我們?cè)偌僭O(shè)一個(gè)變量b，然后把p賦值給變量b，那么變量b就是一個(gè)指針變量（字面意思，存放指針的變量）。

1）指針變量的定義

類型說明符* 變量名；

類型說明符表示這個(gè)指針指向的變量類型，換句話說這個(gè)指針變量的值必須是一個(gè)什么類型的變量的地址

例如：

int* p1; //定義一個(gè)int類型的指針變量，指向的變量類型也必須是int
char* p2; //定義一個(gè)char類型的指針變量，指向的變量類型也必須是char
double* p3; //定義一個(gè)double類型的指針變量，指向的變量類型也必須是double

• &：取地址運(yùn)算符

  &變量名表示取變量的地址，就是獲取變量的指針

  int a = 123;
  int* p = &a; //取變量a的地址賦值給指針變量p
  

• *：指針運(yùn)算符（或稱“間接訪問” 運(yùn)算符）

  *指針變量表示取指向的變量的值

  int a = 123;
  int* p = &a; //取變量a的地址賦值給指針變量p
  printf("%d",*p); //輸出123，*p表示取a的值
  

1）數(shù)組的指針

數(shù)組的指針是指數(shù)組的首地址。
名詞解釋：一個(gè)數(shù)組是由連續(xù)的一塊內(nèi)存單元組成的。數(shù)組名就是這塊連續(xù)內(nèi)存單元的首地址,也是數(shù)組中第一個(gè)元素的地址。

int array[] = {
  1,2,3,4,5,6};
int* pA = array; // 數(shù)組名就是數(shù)組的指針
int* pB = &array[0]; // 數(shù)組的第一個(gè)元素的地址就是數(shù)組的指針

指針pA和指針pB是相等的

2）指針數(shù)組

一個(gè)數(shù)組的元素值為指針則是指針數(shù)組。
定義方式：類型說明符* 數(shù)組名[數(shù)組長度]（跟普通數(shù)組定義方式相同，唯一區(qū)別是*）

int main() {
  
   int a=1,b=2,c=3,d=4,e=5;
   int* Int[5] = {
  &a,&b,&c,&d,&e}; // 這是一個(gè)整型指針數(shù)組
   // 字符串在C語言中是字符數(shù)組，所以一個(gè)字符串相當(dāng)于一個(gè)字符數(shù)組，字符串本身就等于字符數(shù)組的指針（首地址）
   const char* String[] = {
  "Test1","Test2","Test3","Test4","Test5"}; // 這是一個(gè)字符型的指針數(shù)組
   for (int i = 0; i < 5; ++i) {
  
       printf("%p\n",String[i]); // 這里輸出的就是每個(gè)字符串的指針
   }
   return 0;

C語言中是沒有字符串類型的，C語言中的字符串都是用字符數(shù)組進(jìn)行存儲(chǔ)
字符串的指針就是字符數(shù)組的指針，也就是字符數(shù)組的首地址

C語言字符串的兩種定義形式：

• 數(shù)組形式：char string[] = {'H','e','l','l','o','\0'};或char string[] = "Hello";
• 指針形式：char* string = "Hello";（等價(jià)于{'H','e','l','l','o','\0'}）

1）函數(shù)的指針

在Ｃ語言中，一個(gè)函數(shù)總是占用一段連續(xù)的內(nèi)存區(qū)，而函數(shù)名就是該函數(shù)所占內(nèi)存區(qū)的首地址（函數(shù)指針）。

• 函數(shù)指針的定義：類型說明符 (*指針變量名)(實(shí)參類型);

int (*p)(); // 定義一個(gè)函數(shù)指針p
int Function(){
  
    printf("test");
}
p = Function; // 將Function函數(shù)的入口地址賦值給函數(shù)指針變量p

注意：函數(shù)指針的定義區(qū)別于變量指針

• 函數(shù)指針的調(diào)用：(*指針變量名) (實(shí)參表);

int FindMax(int a, int b){
  
    return a > b ? a : b;
}
int main() {
  
    int (*p)(int, int) = FindMax;
    int max = p(5,10);
    printf("%d",max);
    return 0;
} 

2）指針型函數(shù)

函數(shù)類型是指針的函數(shù)就是指針型函數(shù)（函數(shù)類型是指函數(shù)返回值的類型）
定義：

類型說明符* 函數(shù)名(參數(shù)){
   執(zhí)行語句;
   return 對(duì)應(yīng)類型的指針;
}

例：下面定義了指針型函數(shù)，作用是隨機(jī)生成一個(gè)數(shù)組，返回?cái)?shù)組的指針

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int* GetNumber(){
  
    static int array[10];
    srand((unsigned)time(NULL));
    for (int i = 0; i < 10; ++i) {
  
        array[i] = rand();
        printf("%d\n",array[i]);
    }
    return array;
}
int main() {
  
    int* p = GetNumber();
    printf("===================================\n");
    for (int i = 0; i < 10; ++i) {
  
        printf("%d\n",p[i]);
    }

指向指針的指針，就是字面意思，假如有個(gè)變量a,變量a的指針用p1表示，將p1賦值給一個(gè)變量b，變量b的指針用p2表示，現(xiàn)在將p2賦值給一個(gè)變量c，變量c就是指向指針的指針。

int a = 2333;
int* b = &a;
int** c = &b;

要訪問指向指針的指針的值，要使用**，如上面的指針c，訪問方式為**c

五、結(jié)構(gòu)體和共用體

結(jié)構(gòu)體跟一些面向?qū)ο蟮恼Z言（Python、C#、Java）中的類概念相似，就是一組數(shù)據(jù)由多個(gè)成員數(shù)據(jù)組成，成員數(shù)據(jù)可以是基本類型或者構(gòu)造類型，在使用結(jié)構(gòu)體之前必須先進(jìn)行定義。

結(jié)構(gòu)體是由多個(gè)不同數(shù)據(jù)類型的成員組成的數(shù)據(jù)類型。結(jié)構(gòu)體中的每個(gè)成員可以有不同的數(shù)據(jù)類型和命名。使用結(jié)構(gòu)體可以將多個(gè)不同數(shù)據(jù)類型的信息組合成一個(gè)單一的邏輯單元，從而方便地進(jìn)行操作。

1）結(jié)構(gòu)體的定義

• 定義結(jié)構(gòu)體關(guān)鍵字：struct
• 定義形式：struct 結(jié)構(gòu)名 {成員數(shù)據(jù)};

// 下面定義了一個(gè)名為Person的結(jié)構(gòu)體，Person包含有一個(gè)人的姓名、年齡、性別、身高、住址信息
struct Person{
  
    char* name;
    int age;
    char sex;
    double height;
    char address[200];
};

2）結(jié)構(gòu)體的用法

• 結(jié)構(gòu)體成員變量的表示方法：結(jié)構(gòu)名.變量名或(*結(jié)構(gòu)指針).變量名/(*結(jié)構(gòu)指針)->變量名

struct Person{
  
    char* name;
    int age;
    char sex;
    double height;
    char address[200];
};
int main() {
  
    struct Person man; // 結(jié)構(gòu)體變量實(shí)例化
    struct Person woman; // 結(jié)構(gòu)體變量實(shí)例化
    struct Person* pW = &woman; // 實(shí)例化一個(gè)結(jié)構(gòu)體指針變量
    man.name; // 結(jié)構(gòu)體變量直接表示
    man.sex;
    (*pW).name; // 結(jié)構(gòu)體指針變量表示
    pW->sex; // 結(jié)構(gòu)體指針變量表示
    return 0;
}

• 結(jié)構(gòu)體變量的賦值：直接給成員變量賦值，注意數(shù)組類型不能直接賦值。

#include <stdio.h>
#include <string.h>
// 下面定義了一個(gè)名為Person的結(jié)構(gòu)體，Person包含有一個(gè)人的姓名、年齡、性別、身高、住址信息
struct Person{
  
    char* name;
    int age;
    char sex;
    float height;
    char address[200];
};
int main() {
  
    struct Person man;
    struct Person woman;
    struct Person* pW = &woman;
    man.name = "小明"; // 結(jié)構(gòu)體變量賦值
    man.sex = 'M';
    man.age = 18;
    man.height = 1.78f;
    strcpy(man.address,"四川省成都市");
    (*pW).name = "小紅"; // 結(jié)構(gòu)體變量賦值
    (*pW).sex = 'W';
    pW->age = 19;
    pW->height = 1.68f;
    strcpy(pW->address,"四川省綿陽市"); // 數(shù)組類型不能直接賦值
    printf("姓名：%s\n年齡：%d\n性別：%c\n身高：%.2fm\n地址：%s\n",man.name,man.age,man.sex,man.height,man.address);
    printf("==============================================================================================\n");
    printf("姓名：%s\n年齡：%d\n性別：%c\n身高：%.2fm\n地址：%s\n",woman.name,woman.age,woman.sex,(*pW).height,pW->address);
    return 0;
}

共用體是一種特殊的結(jié)構(gòu)體，其所有成員共享相同的內(nèi)存空間。共用體中的每個(gè)成員可以有不同的數(shù)據(jù)類型，但是它們共享相同的內(nèi)存空間，因此只能同時(shí)存在一個(gè)成員的值。共用體的主要用途是在不同的數(shù)據(jù)類型之間進(jìn)行類型轉(zhuǎn)換或節(jié)省內(nèi)存空間。

1）共用體的定義

• 定義結(jié)構(gòu)體關(guān)鍵字：union
• 定義形式：union 共用體名 {成員數(shù)據(jù)};

#include <stdio.h>
#include <string.h>
union data {
  
    int i;
    float f;
    char str[20];
};
int main() {
  
    union data mydata; // 實(shí)例化一個(gè)共用體變量
    mydata.i = 10;
    printf("mydata.i = %d\n", mydata.i);
    mydata.f = 3.14f;
    printf("mydata.f = %f\n", mydata.f);
    strcpy(mydata.str, "Hello");
    printf("mydata.str = %s\n", mydata.str);
    return 0;
}

在這個(gè)例子中，我們定義了一個(gè)名為data的共用體，包含一個(gè)整型變量i、一個(gè)浮點(diǎn)型變量f和一個(gè)字符數(shù)組str。在main函數(shù)中，我們定義了一個(gè)mydata的共用體變量，可以用來存儲(chǔ)int、float或char類型的數(shù)據(jù)。

由于所有成員變量共享同一塊內(nèi)存空間，因此在設(shè)置mydata.f和mydata.str時(shí)，mydata.i的值被覆蓋了。這也是共用體的一個(gè)特點(diǎn)：在任意時(shí)刻，只能有一個(gè)成員變量是有效的。

2）共用體的用法

主要用途：在不同的數(shù)據(jù)類型之間進(jìn)行類型轉(zhuǎn)換或節(jié)省內(nèi)存空間。

#include <stdio.h>
#include <string.h>
union data {
  
    int i;
    float f;
    char* s;
    char c;
};
int main() {
  
    union data temp; // 定義一個(gè)共用體temp
    temp.i = 10;
    printf("temp = %d\n",temp.i);
    printf("data中i的內(nèi)存地址：%p\n",&temp.i);
    printf("data中f的內(nèi)存地址：%p\n",&temp.f);
    printf("data中s的內(nèi)存地址：%p\n",&temp.s);
    printf("data中c的內(nèi)存地址：%p\n",&temp.c);
    // 可以看出共用體的所有成員指向的是同一塊內(nèi)存空間
    printf("=========================================================\n");
    temp.s = "測試";
    printf("temp = %s\n",temp.s);
    printf("data中i的內(nèi)存地址：%p\n",&temp.i);
    printf("data中f的內(nèi)存地址：%p\n",&temp.f);
    printf("data中s的內(nèi)存地址：%p\n",&temp.s);
    printf("data中c的內(nèi)存地址：%p\n",&temp.c);
    printf("=========================================================\n");
    temp.f = 3.14159f;
    printf("temp = %f\n",temp.f);
    printf("data中i的內(nèi)存地址：%p\n",&temp.i);
    printf("data中f的內(nèi)存地址：%p\n",&temp.f);
    printf("data中s的內(nèi)存地址：%p\n",&temp.s);
    printf("data中c的內(nèi)存地址：%p\n",&temp.c);
    printf("=========================================================\n");
    //通過上面的例子，如果把temp看做一個(gè)沒有定義類型的變量，那么他就是個(gè)可變類型的變量
    return 0;
}

枚舉（Enumeration）是一種自定義的數(shù)據(jù)類型，它允許定義一組命名的常量。枚舉類型的變量只能賦值為枚舉列表中的一個(gè)值，這些值被稱為枚舉常量。枚舉類型是一種非常方便的方式來組織和描述常量。

1）枚舉的定義

• 定義枚舉關(guān)鍵字：enum
• 定義枚舉的形式：enum 枚舉名稱 {枚舉常量列表};（枚舉常量的值被認(rèn)為是int類型或者unsigned int類型，默認(rèn)枚舉變量值從0開始遞增）

enum color {
  
    RED,
    GREEN,
    BLUE
};
/*上面定義了一個(gè)三種顏色的枚舉，三種枚舉默認(rèn)值為RED=0，GREEN=1，BLUE=2*/
// 下面定義一個(gè)性別的枚舉，并給枚舉值進(jìn)行自定義
enum sex {
  
    MAN = 1,
    WOMAN = 2
}

2）枚舉的用法

枚舉常用來定義一組常量選項(xiàng)

#include <stdio.h>
#include <string.h>
enum week {
  
    Mon,
    Tue,
    Wed,
    Thu,
    Fri,
    Sat,
    Sun
};
int main() {
  
    enum week today;
    today = Mon;
    switch (today) {
  
        case Mon:
            printf("今天是周一");
            break;
        case Tue:
            printf("今天是周二");
            break;
        case Wed:
            printf("今天是周三");
            break;
        case Thu:
            printf("今天是周四");
            break;
        case Fri:
            printf("今天是周五");
            break;
        case Sat:
            printf("今天是周六");
            break;
        case Sun:
            printf("今天是周日");
            break;
    }
    return 0;
}

C語言常用的內(nèi)存管理函數(shù)有四個(gè)：malloc、calloc、realloc、free
其中申請(qǐng)空間的函數(shù)是malloc、calloc；重新調(diào)整空間大小的函數(shù)是realloc；釋放空間的函數(shù)是free

1）malloc

作用：用于在堆上分配指定大小的內(nèi)存空間，內(nèi)容隨機(jī)，函數(shù)原型：void* malloc(size_t size);
參數(shù)：

• size：分配空間的大小（字節(jié)）

返回值：分配的內(nèi)存空間的首地址，分配失敗返回NULL空指針
注意：返回值類型為void*，使用時(shí)需要轉(zhuǎn)換成對(duì)應(yīng)類型

下面是一個(gè)例子：分配一塊空間存儲(chǔ)指定個(gè)數(shù)的數(shù)字，并對(duì)數(shù)字求和

#include <stdio.h>
#include <stdlib.h>
int main() {
  
    int* ptr; // 定義一個(gè)指針變量
    int n, sum = 0; // 初始化元素個(gè)數(shù)與元素總和
    printf("輸入要保存的元素個(gè)數(shù): ");
    scanf("%d", &n);
    ptr = (int*) malloc(n * sizeof(int)); // 分配一塊足夠存儲(chǔ)n個(gè)int類型數(shù)字的內(nèi)存空間，將指針強(qiáng)制轉(zhuǎn)換為int類型
    if(ptr == NULL) {
  
        printf("內(nèi)存空間分配失敗！\n");
        exit(1);
    }
    printf("輸入保存的元素:\n");
    for(int i = 0; i < n; i++) {
  
        scanf("%d", &ptr[i]);
        sum += ptr[i];
    }
    printf("所有元素累加總和為：%d\n", sum);
    free(ptr);// 釋放內(nèi)存空間ptr
    return 0;
}

2）calloc

作用：用于在堆上分配指定數(shù)量和大小的內(nèi)存空間，內(nèi)容初始化為0。
其函數(shù)原型為：void* calloc(size_t num, size_t size);
參數(shù)：

• num：分配空間塊數(shù)（需要分配多少塊空間）
• size：每塊空間的大小（字節(jié)）

返回值：分配的內(nèi)存空間的首地址，分配失敗返回NULL空指針
注意：返回值類型為void*，使用時(shí)需要轉(zhuǎn)換成對(duì)應(yīng)類型

同樣使用上面的例子：

#include <stdio.h>
#include <stdlib.h>
int main() {
  
    int* ptr; // 定義一個(gè)指針變量
    int n, sum = 0; // 初始化元素個(gè)數(shù)與元素總和
    printf("輸入要保存的元素個(gè)數(shù): ");
    scanf("%d", &n);
    ptr = (int*) calloc(n, sizeof(int)); // 分配n塊足夠存儲(chǔ)1個(gè)int類型數(shù)字的內(nèi)存空間，將指針強(qiáng)制轉(zhuǎn)換為int類型
    if(ptr == NULL) {
  
        printf("內(nèi)存空間分配失敗！\n");
        exit(1);
    }
    printf("輸入保存的元素:\n");
    for(int i = 0; i < n; i++) {
  
        scanf("%d", &ptr[i]);
        sum += ptr[i];
    }
    printf("所有元素累加總和為：%d\n", sum);
    free(ptr);// 釋放內(nèi)存空間ptr
    return 0;
}

3）realloc

作用：用于重新分配已分配內(nèi)存的大小。其函數(shù)原型為：void* realloc(void* ptr, size_t size);
參數(shù)：

• ptr：原內(nèi)存空間地址
• size：重新分配內(nèi)存空間大小

返回值：分配的內(nèi)存空間的首地址，分配失敗返回NULL空指針
注意：返回值類型為void*，使用時(shí)需要轉(zhuǎn)換成對(duì)應(yīng)類型

說明：realloc重新分配是在原地址的基礎(chǔ)上進(jìn)行調(diào)整，如果是擴(kuò)大空間大小，當(dāng)新的空間大小超過了原空間所能擴(kuò)展的范圍（比如a空間占了4個(gè)字節(jié)，現(xiàn)在要把a(bǔ)空間擴(kuò)展到8個(gè)字節(jié)，而在這一塊連續(xù)的內(nèi)存中，第7個(gè)字節(jié)已經(jīng)被分配出去了，那么這塊空間最大只能是6個(gè)字節(jié)了），系統(tǒng)會(huì)重新找一塊足夠大的空間來作為新空間，然后將原本空間中的數(shù)據(jù)拷貝過來，釋放原本的空間，也就是指針會(huì)進(jìn)行改變，值不會(huì)發(fā)生變化；如果是縮小空間大小，就會(huì)釋放原空間調(diào)整之后的內(nèi)存空間。

同樣使用上面例子做修改：

#include <stdio.h>
#include <stdlib.h>
int main() {
  
    int* ptr; // 定義一個(gè)指針變量
    int n,m, sum = 0; // 初始化元素個(gè)數(shù)與元素總和
    printf("輸入要保存的元素個(gè)數(shù): ");
    scanf("%d", &n);
    ptr = (int*) calloc(n, sizeof(int)); // 分配n塊足夠存儲(chǔ)1個(gè)int類型數(shù)字的內(nèi)存空間，將指針強(qiáng)制轉(zhuǎn)換為int類型
    if(ptr == NULL) {
  
        printf("內(nèi)存空間分配失敗！\n");
        exit(1);
    }
    printf("輸入保存的元素:\n");
    for(int i = 0; i < n; i++) {
  
        scanf("%d", &ptr[i]);
        sum += ptr[i];
    }
    m = n+2;
    ptr = (int*)realloc(ptr,m*sizeof(int)); // 重新分配一塊足夠存儲(chǔ)m個(gè)int類型數(shù)字的內(nèi)存空間
    printf("輸入新增的元素:\n");
    for(int i = n; i < m; i++) {
  
        scanf("%d", &ptr[i]);
        sum += ptr[i];
    }
    printf("所有元素累加總和為：%d\n", sum);
    free(ptr);// 釋放內(nèi)存空間ptr
    return 0;
}

4）free

作用：用于釋放已分配的內(nèi)存空間。其函數(shù)原型為：void free(void* ptr);
參數(shù)：

• ptr：需要釋放的空間地址

返回值：沒有返回值

C語言允許在一個(gè)結(jié)構(gòu)體中以位(Bit)為單位來指定其成員長度，這種以位為單位的結(jié)構(gòu)體成員稱為“位段”或者“位域”。位域只能是int、unsigned int、signed int類型。int默認(rèn)是有符號(hào)整型（signed）。
位域的主要目的：節(jié)省內(nèi)存空間，比如開關(guān)控制只需要0和1，那么只需要1位就能表示二進(jìn)制0和1，一個(gè)字節(jié)有8位，使用位域就可以只是用一個(gè)字節(jié)中的其中1位。

• 基本定義：

struct 位域名稱 {
  
    位域列表;
}

• 示例：下面定義了一個(gè)日期的結(jié)構(gòu)體，包含成員變量年、月、日，年我們用四位數(shù)字表示，最多只需要14位，月我們只需要四位就能表示1-12月，我們只需要用6位便能完全表示1-31日。

#include <stdio.h>
struct Date{
  
    unsigned int year;
    unsigned int month;
    unsigned int day;
};
struct Date2{
  
    unsigned int year : 14;
    unsigned int month : 4;
    unsigned int day : 6;
};
int main() {
  
    printf("Date占用字節(jié)數(shù)：%llu\n", sizeof(struct Date));
    printf("Date2占用字節(jié)數(shù)：%llu\n", sizeof(struct Date2));
    return 0;
}

輸出結(jié)果：

Date占用字節(jié)數(shù)：12
Date2占用字節(jié)數(shù)：4

從以上結(jié)果便能看出，使用位域可以節(jié)省內(nèi)存空間。
注意：位域的位數(shù)不能超過其依附的基本類型的最大位數(shù)，例如一個(gè)unsigned int類型的成員，他有4個(gè)字節(jié)，一個(gè)字節(jié)是8位，它最大只能存儲(chǔ)32位，位域的位數(shù)就不能超過32（不同的編譯器基本類型占用空間大小不一致）

六、文件操作

文件是一個(gè)有序數(shù)據(jù)集，數(shù)據(jù)集的名稱叫文件名。文件分為兩種，一種是普通文件，比如txt文件、C語言的源程序文件、頭文件等等存在于磁盤上的；另一種是設(shè)備文件，比如鼠標(biāo)、鍵盤、顯示器等等外部設(shè)備，都認(rèn)為是一個(gè)文件。

C語言使用一個(gè)指針變量指向一個(gè)文件，通過操作指針來操作文件。
文件指針的定義:FILE *變量名;

FILE實(shí)際上是系統(tǒng)定義的一個(gè)結(jié)構(gòu)體，該結(jié)構(gòu)體中含有文件名、文件狀態(tài)、文件當(dāng)前位置等信息（編寫程序時(shí)不用關(guān)心FILE結(jié)構(gòu)體細(xì)節(jié)）

文件位置指針： 文件位置指針表示的是文件中所處位置的指針（頭部、當(dāng)前位置、末尾等），注意跟文件指針區(qū)別開，文件指針指向的是整個(gè)文件

1）打開與關(guān)閉

• fopen：打開一個(gè)文件，成功返回文件的指針，失敗返回空指針NULL
  • 函數(shù)原型：FILE* fopen(const char *path,const char *mode)
    • path：文件路徑
    • mode：打開的模式
      mode主要由以下6個(gè)字符組合而成：
      • r：可讀（文件位置指針在文件頭部，文件必須存在）
      • w：可寫（文件位置指針在文件頭部，文件存在則清空內(nèi)容，不存在就創(chuàng)建）
      • a：追加寫入（文件位置指針在文件尾部，文件必須存在）
      • b：二進(jìn)制方式打開
      • +：可讀寫
      • t：文本模式（默認(rèn)，可省略）
    • 下面列出常用模式：

      選項(xiàng)	說明
      r	只讀打開一個(gè)文本文件，只允許讀數(shù)據(jù)
      w	只寫打開一個(gè)文本文件，只允許寫數(shù)據(jù)
      a	追加寫入打開一個(gè)文本文件，在文件末尾寫數(shù)據(jù)
      rb	以二進(jìn)制方式打開一個(gè)文件，只允許讀數(shù)據(jù)
      wb	以二進(jìn)制方式打開一個(gè)文件，只允許寫數(shù)據(jù)

• fclose：關(guān)閉一個(gè)文件，成功返回0，失敗返回非0
  通常對(duì)文件操作如下：

#include "stdio.h"
#include "stdlib.h"
FILE *fp = fopen("文件名", "打開模式");
if (fp == NULL) {
  
        printf("文件打開失敗！");
        exit(1);
    }
/* 要執(zhí)行的文件操作 */
fclose(fp);

2）文件讀寫

文件結(jié)束符：EOF
文件寫入的函數(shù)需要以寫或者讀寫模式打開文件，文件讀取的函數(shù)需要以讀或者讀取的模式打開文件，讀取或?qū)懭氩僮髦�后，位置指針都�?huì)向后移動(dòng)到讀取或?qū)懭胛恢玫哪┪?/MARK>

• fgetc：從文件讀取一個(gè)字符
  • 函數(shù)原型：int fgetc(FILE *file);
    • file：目標(biāo)文件的指針
  • 返回值：返回int類型的ASCII碼，位置指針向后移動(dòng)一個(gè)字節(jié)
  • 使用方法：fgetc(文件指針);
• fputc：向文件中寫入一個(gè)字符
  • 函數(shù)原型：int fputc(int c, FILE *file);
    • c：要寫入的字符（char或者int類型ASCII碼）
    • file：目標(biāo)文件的指針
  • 返回值：成功返回寫入的字符，位置指針向后移動(dòng)一個(gè)字節(jié)；失敗返回EOF
  • 使用方法：fputc('a', 文件指針);
• fgets：從文件讀取一個(gè)字符串到字符數(shù)組中
  • 函數(shù)原型：char* fgets(char *Buffer, int MaxCount, FILE *file );
    • Buffer：字符數(shù)組的指針
    • MaxCount：最大讀取字符數(shù)
    • file：目標(biāo)文件的指針
  • 說明：
    • MaxCount是一個(gè)正整數(shù)，表示從文件中讀出的字符串不超過 MaxCount-1個(gè)字符。在讀入的最后一個(gè)字符后加上串結(jié)束標(biāo)志\0。
    • 在讀出MaxCount-1個(gè)字符之前，如遇到了換行符或EOF，則讀出結(jié)束。
  • 返回值：字符數(shù)組的首地址
  • 使用方法：fgets(數(shù)組首地址, 字符串最大長度, 文件指針);
• fputs：將一個(gè)字符串寫入到文件中，不包含’\0’
  • 函數(shù)原型：int fputs(const char *str, FILE *file);
    • str：要寫入的字符數(shù)組（字符串）的指針
    • file：目標(biāo)文件的指針
  • 返回值：成功返回非負(fù)整數(shù)；失敗返回EOF(符號(hào)常量，其值為-1)
  • 使用方法：fputs(字符串, 文件指針);
• fread：從文件中讀取一組固定大小的數(shù)據(jù)到內(nèi)存空間
  • 函數(shù)原型：size_t fread(void *Buffer, size_t size, size_t count, FILE *file);
    • Buffer：內(nèi)存空間首地址（用來存放數(shù)據(jù)的內(nèi)存空間指針）
    • size：數(shù)據(jù)塊的大小
    • count：數(shù)據(jù)塊的數(shù)量
    • file：目標(biāo)文件的指針
  • 返回值：返回成功讀取的對(duì)象個(gè)數(shù)（若出現(xiàn)錯(cuò)誤或到達(dá)文件末尾，則可能小于count）
  • 使用方法：fread(內(nèi)存空間地址, 數(shù)據(jù)塊大小, 數(shù)據(jù)塊數(shù)量, 文件指針);
• fwrite：寫入一組固定大小的數(shù)據(jù)到文件中
  • 函數(shù)原型：size_t fwrite(const void *Buffer, size_t size, size_t count, FILE *file);
    • Buffer：要存入的數(shù)據(jù)的首地址
    • size：數(shù)據(jù)塊的大小
    • count：數(shù)據(jù)塊的數(shù)量
    • file：目標(biāo)文件的指針
  • 返回值：返回成功寫入的對(duì)象個(gè)數(shù)（若出現(xiàn)錯(cuò)誤或到達(dá)文件末尾，則可能小于count）
  • 使用方法：fwrite(數(shù)據(jù)地址, 數(shù)據(jù)塊大小, 數(shù)據(jù)塊數(shù)量, 文件指針);
• fscanf：從文件中獲取指定格式的數(shù)據(jù)，跟scanf類似，輸入對(duì)象換成了普通文件
  • 函數(shù)原型：int fscanf(FILE *file, const char *str, [arg...]);
    • file：目標(biāo)文件的指針
    • str：格式化字符串
    • [arg…]：一個(gè)或多個(gè)接收數(shù)據(jù)的地址
  • 說明：fscanf遇到空格和換行時(shí)結(jié)束
  • 返回值：成功返回讀入的參數(shù)的個(gè)數(shù)，失敗返回EOF
  • 使用方法：fscanf(文件指針, 格式化字符串, 目標(biāo)地址);
• fprintf：格式化輸出數(shù)據(jù)到文件，跟printf類似，輸出對(duì)象換成了普通文件
  • 函數(shù)原型：int fprint(FILE *file, const char *str, [arg...]);
    • file：目標(biāo)文件的指針
    • str：格式化字符串
    • [arg…]：一個(gè)或多個(gè)數(shù)據(jù)
  • 說明：fprintf會(huì)根據(jù)參數(shù)str字符串來轉(zhuǎn)換并格式化數(shù)據(jù)，然后將結(jié)果輸出到參數(shù)file指定的文件中，直到出現(xiàn)字符串結(jié)束(\0)為止。
  • 返回值：成功返回輸出的數(shù)據(jù)的個(gè)數(shù)，失敗返回EOF
  • 使用方法：fprintf(文件指針, 格式化字符串, 目標(biāo)數(shù)據(jù));

3）文件定位

• rewind：將文件的位置指針移動(dòng)到文件頭部
  • 函數(shù)原型：void rewind(FILE *file);
    • file：目標(biāo)文件的指針
  • 使用方法：rewind(文件指針);
• fseek：將文件的位置指針從規(guī)定的起始點(diǎn)移動(dòng)到某個(gè)位置
  • 函數(shù)原型：int fseek(FILE *file, long offset, int start);
    • file：目標(biāo)文件的指針
    • offset：偏移量，從起始點(diǎn)移動(dòng)多少字節(jié)，必須是long型數(shù)據(jù)
    • start：起始點(diǎn)，規(guī)定三個(gè)起始點(diǎn)：文件首、當(dāng)前位置、文件尾

      起始點(diǎn)	標(biāo)識(shí)符	數(shù)字表示
      文件頭部	SEEK_SET	0
      當(dāng)前位置	SEEK_CUR	1
      文件尾部	SEEK_END	2

  • 使用方法：fseek(文件指針, 偏移量, 起始點(diǎn));

4）文件檢測

• feof：判斷文件位置指針是否處于文件結(jié)束位置

  • 函數(shù)原型：int feof(FILE *file);
    • file：目標(biāo)文件的指針
  • 返回值：文件指針處于結(jié)束位置返回非0，否則返回0

• ferror：檢查文件在用各種輸入輸出函數(shù)進(jìn)行讀寫時(shí)是否出錯(cuò)

  • 函數(shù)原型：int ferror(FILE *file);
    • file：目標(biāo)文件的指針
  • 返回值：未出錯(cuò)返回0，出錯(cuò)返回非0

• clearerr：清除出錯(cuò)標(biāo)志和文件結(jié)束標(biāo)志，使它們?yōu)?值

  • 函數(shù)原型：void clearerr(FILE *file);
    • file：目標(biāo)文件的指針

5）文件操作示例

#include "stdio.h"
#include "stdlib.h"
struct Student {
  
    char name[20];
    int age;
    float score;
};
int main() {
  
    FILE *fp = fopen("test.txt", "w+"); // 以讀寫模式打開一個(gè)文件
    if (fp == NULL) {
  
        printf("文件打開失敗！");
        exit(1);
    }
    fputc('a', fp); // 向文件寫入一個(gè)字符'a'
    rewind(fp); // 將文件位置指針放到文件頭部，因?yàn)槲覀儎倓傁蛭募�寫入了一個(gè)字符'a'，所以現(xiàn)在文件位置指針指向的文件尾部
    char ch = (char)fgetc(fp); // 從文件讀取一個(gè)字符，現(xiàn)在文件中只有一個(gè)'a'，讀取的字符就是'a'
    printf("%c\n",ch);
    printf("結(jié)束位置：%d\n", feof(fp)); // 看看位置指針是不是在結(jié)束位置
    fseek(fp,1L,0); // 將文件位置指針手動(dòng)置于字符'a'后面，讀取時(shí)也會(huì)把指針后移，但是寫入的時(shí)候失敗了，原因暫時(shí)未找到！
    fputs("this is fputs test", fp); // 向文件中寫入字符串，現(xiàn)在文件中的內(nèi)容應(yīng)該是"athis is fputs test"
    printf("寫入出錯(cuò)：%d\n",ferror(fp)); // 查看寫入是否出錯(cuò)
    rewind(fp); // 位置指針放回文件頭部
    char string[255]; // 定義一個(gè)字符數(shù)組用來存放字符串
    fgets(string, 255, fp); // 讀取文件中的字符串到字符數(shù)組string中，遇到換行或文件末尾就結(jié)束
    printf("%s\n",string); // 輸出：athis is fputs test
    rewind(fp); // 位置指針放回文件頭部
    fprintf(fp,"%s %d %f","test", 1, 0.6f); // 現(xiàn)在文件內(nèi)容是"test 1 0.600000test"，因?yàn)楝F(xiàn)在寫入的把前面的"athis is fputs "覆蓋了
    rewind(fp);
    char str[255];
    int a;
    float b;
    fscanf(fp,"%s %d %f",str,&a,&b);
    printf("str的值:%s\na的值：%d\nb的值：%f",str,a,b);
    /*
    str的值:test
    a的值：1
    b的值：0.600000
     */
    fclose(fp);
    struct Student boys[3]; // 定義一個(gè)結(jié)構(gòu)體數(shù)組
    struct Student boy2[2];
    struct Student *pb; // 定義一個(gè)結(jié)構(gòu)體指針
    pb = boys; // 指向結(jié)構(gòu)體中第一個(gè)成員（數(shù)組首地址）
    FILE *fp1 = fopen("test1.txt", "wb+"); // 以二進(jìn)制讀寫模式打開一個(gè)文件
    if (fp1 == NULL) {
  
        printf("文件打開失敗！");
        exit(1);
    }
    for (int i=0;i<3;i++){
  
        scanf("%s %d %f",pb->name,&pb->age,&pb->score); // 這里循環(huán)輸入學(xué)生的信息
        pb++; // 指針向后移動(dòng)，指向下一個(gè)boys數(shù)組的成員
    }
    long size = sizeof(struct Student); // 獲取結(jié)構(gòu)的大小
    fwrite(boys, size,3,fp1); // 向文件中寫入3個(gè)Student結(jié)構(gòu)
    rewind(fp1);
    fseek(fp1,size,SEEK_SET); // 位置指針移動(dòng)到第二個(gè)學(xué)生的地址
    fread(boy2,size,2,fp1);  // 讀取2個(gè)Student大小的數(shù)據(jù)
    for (int i=0; i < 2;i++) {
  
        printf("%s %d %f\n",boy2[i].name,boy2[i].age,boy2[i].score);
    }
    fclose(fp1); // 關(guān)閉文件
    return 0;
}