目錄

• 一、數(shù)據(jù)類型和表達式
• • 1.基本類型
  • 2.構造類型
  • • 1）數(shù)組類型
    • 2）[結構體類型](#jiegou)
    • 3）[共用體類型](#lianhe)
  • 3.常量
  • 4.運算表達式
  • • 1）算術運算表達式：
    • 2）關系運算表達式：
    • 3）邏輯運算符：
    • 4）位運算符：
• 二、C語言的語句
• • 1.表達式語句
  • 2.函數(shù)調(diào)用語句
  • 3.控制語句
  • • 1）條件判斷語句：
    • 2）循環(huán)執(zhí)行語句：
    • 3）轉向語句：
  • 4.復合語句
  • 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.預處理命令
  • • 1）宏定義
    • 2）文件包含
    • 3）條件編譯
• 四、指針
• • 1.變量的指針&指針變量
  • • 1）指針變量的定義
  • 2）指針的操作
  • 2.數(shù)組的指針&指針數(shù)組
  • • 1）數(shù)組的指針
    • 2）指針數(shù)組
  • 3.字符串的指針
  • 4.函數(shù)的指針&指針型函數(shù)
  • • 1）函數(shù)的指針
    • 2）指針型函數(shù)
  • 5.指向指針的指針
• 五、結構體和共用體
• • 1.結構體
  • • 1）結構體的定義
    • 2）結構體的用法
  • 2.共用體（聯(lián)合體）
  • • 1）共用體的定義
    • 2）共用體的用法
  • 3.枚舉
  • • 1）枚舉的定義
    • 2）枚舉的用法
  • 4.動態(tài)內(nèi)存分配
  • • 1）malloc
    • 2）calloc
    • 3）realloc
    • 4）free
  • 5.位域
• 六、文件操作
• • 1.文件的概念
  • 2.文件指針
  • 3.操作文件的函數(shù)
  • • 1）打開與關閉
    • 2）文件讀寫
    • 3）文件定位
    • 4）文件檢測
    • 5）文件操作示例

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

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

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

1.基本類型

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

類型	類型說明符	字節(jié)	數(shù)字范圍
字符型	char	1	C字符集
基本整型	int	4	-32768~32767
短整型	short int	2	-32768~32767
長整型	long int	4	-214783648~-214783647
無符號整型	unsigned int	4	0~65535
無符號長整型	unsigned long	4	0~4294967295
單精度實型	float	4	10-38~1038
雙精度實型	double	8	10-308~10-308

2.構造類型

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.在定義的時候賦初值：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ù)組第二種賦值方式比第一種方式多占一個字符，因為第二種方式會在字符數(shù)組中結尾添加一個\0作為字符串結束符

提示：數(shù)組賦值時，如果給定值數(shù)量小于數(shù)組長度，系統(tǒng)默認填充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)會自動賦值一個無意義的數(shù)字，可以自行printf輸出查看
    printf("a第二個元素：%d\nb第一個元素：%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這兩個數(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("第一個名字：%s第二個名字：%s", name, name2);
    return 0;
}

2）結構體類型

3）共用體類型

3.常量

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

• 預定義命令： #define TEMP = 1
• const關鍵字：const int TEMP = 1

4.運算表達式

1）算術運算表達式：

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

注意：自增和自減跟賦值運算結合的時候如果運算符在左邊，會先進行自增或自減運算，請看下面例子：

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

2）關系運算表達式：

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

3）邏輯運算符：

C語言中非0為真

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

4）位運算符：

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

二、C語言的語句

1.表達式語句

定義：由表達式和分號組成的語句：x + y = z;

2.函數(shù)調(diào)用語句

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

3.控制語句

1）條件判斷語句：

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

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

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

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

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

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

• switch語句：開關語句，一般配合case關鍵字使用

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

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

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

• for語句

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

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

• while語句

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

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

• do while語句

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

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

3）轉向語句：

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

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

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

4.復合語句

定義：將多個語句用大括號括起來組成一個復合語句

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

5.空語句

定義：只有分號組成的語句稱為空語句

;

6.案例

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("請輸入構成三角形的三條邊的長度：");
    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("請輸入一元二次方程的3個系數(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ù)

1.函數(shù)的概念

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

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

2.函數(shù)的定義方式

• 無參函數(shù)：

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

• 有參函數(shù)：

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

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

//void HelloWorld();
//int FindMax(int a,int b);
//上面是對函數(shù)進行聲明，函數(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;
}

3.函數(shù)的參數(shù)

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

4.函數(shù)的返回值

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

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

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

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

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

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

5.函數(shù)的調(diào)用

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

6.全局變量與局部變量

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

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

1）全局變量

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

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

2）局部變量

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

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

7.靜態(tài)變量與寄存器變量

1）靜態(tài)變量

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

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

2）寄存器變量

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

#include "stdio.h"
// 這是一個計算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;
}

8.預處理命令

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

1）宏定義

C語言可以使用#define定義宏（類似常量），程序在編譯處理時會把源程序中所有的宏名替換成宏定義的結果。
宏定義是由源程序中的宏定義命令完成的。宏代換是由預處理程序自動完成的。

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

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

#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ù)、表達式、格式串等）

類似于定義一個匿名函數(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）文件包含

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

3）條件編譯

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

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

• 第一種：如果標識符已被 #define命令定義過則對程序段 1 進行編譯；否則對程序段 2 進行編譯。

#ifdef 標識符
 程序段 1
#else
 程序段 2
#endif

• 第二種：如果標識符未被#define命令定義過則對程序段 1 進行編譯，否則對程序段 2 進行編譯。

#ifndef 標識符 
 程序段 1 
#else 
 程序段 2 
 #endif

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

#if 常量表達式
 程序段 1
#else 
 程序段 2
#endif

四、指針

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

1.變量的指針&指針變量

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

1）指針變量的定義

類型說明符* 變量名；

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

例如：

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

2）指針的操作

• &：取地址運算符

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

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

• *：指針運算符（或稱“間接訪問” 運算符）

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

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

2.數(shù)組的指針&指針數(shù)組

1）數(shù)組的指針

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

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

指針pA和指針pB是相等的

2）指針數(shù)組

一個數(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}; // 這是一個整型指針數(shù)組
   // 字符串在C語言中是字符數(shù)組，所以一個字符串相當于一個字符數(shù)組，字符串本身就等于字符數(shù)組的指針（首地址）
   const char* String[] = {
  "Test1","Test2","Test3","Test4","Test5"}; // 這是一個字符型的指針數(shù)組
   for (int i = 0; i < 5; ++i) {
  
       printf("%p\n",String[i]); // 這里輸出的就是每個字符串的指針
   }
   return 0;

3.字符串的指針

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

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

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

4.函數(shù)的指針&指針型函數(shù)

1）函數(shù)的指針

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

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

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

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

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

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 對應類型的指針;
}

例：下面定義了指針型函數(shù)，作用是隨機生成一個數(shù)組，返回數(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]);
    }

5.指向指針的指針

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

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

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

五、結構體和共用體

1.結構體

結構體跟一些面向對象的語言（Python、C#、Java）中的類概念相似，就是一組數(shù)據(jù)由多個成員數(shù)據(jù)組成，成員數(shù)據(jù)可以是基本類型或者構造類型，在使用結構體之前必須先進行定義。

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

1）結構體的定義

• 定義結構體關鍵字：struct
• 定義形式：struct 結構名 {成員數(shù)據(jù)};

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

2）結構體的用法

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

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

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

#include <stdio.h>
#include <string.h>
// 下面定義了一個名為Person的結構體，Person包含有一個人的姓名、年齡、性別、身高、住址信息
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 = "小明"; // 結構體變量賦值
    man.sex = 'M';
    man.age = 18;
    man.height = 1.78f;
    strcpy(man.address,"四川省成都市");
    (*pW).name = "小紅"; // 結構體變量賦值
    (*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;
}

2.共用體（聯(lián)合體）

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

1）共用體的定義

• 定義結構體關鍵字：union
• 定義形式：union 共用體名 {成員數(shù)據(jù)};

#include <stdio.h>
#include <string.h>
union data {
  
    int i;
    float f;
    char str[20];
};
int main() {
  
    union data mydata; // 實例化一個共用體變量
    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;
}

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

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

2）共用體的用法

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

#include <stdio.h>
#include <string.h>
union data {
  
    int i;
    float f;
    char* s;
    char c;
};
int main() {
  
    union data temp; // 定義一個共用體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看做一個沒有定義類型的變量，那么他就是個可變類型的變量
    return 0;
}

3.枚舉

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

1）枚舉的定義

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

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

2）枚舉的用法

枚舉常用來定義一組常量選項

#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;
}

4.動態(tài)內(nèi)存分配

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

1）malloc

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

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

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

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

#include <stdio.h>
#include <stdlib.h>
int main() {
  
    int* ptr; // 定義一個指針變量
    int n, sum = 0; // 初始化元素個數(shù)與元素總和
    printf("輸入要保存的元素個數(shù): ");
    scanf("%d", &n);
    ptr = (int*) malloc(n * sizeof(int)); // 分配一塊足夠存儲n個int類型數(shù)字的內(nèi)存空間，將指針強制轉換為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*，使用時需要轉換成對應類型

同樣使用上面的例子：

#include <stdio.h>
#include <stdlib.h>
int main() {
  
    int* ptr; // 定義一個指針變量
    int n, sum = 0; // 初始化元素個數(shù)與元素總和
    printf("輸入要保存的元素個數(shù): ");
    scanf("%d", &n);
    ptr = (int*) calloc(n, sizeof(int)); // 分配n塊足夠存儲1個int類型數(shù)字的內(nèi)存空間，將指針強制轉換為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*，使用時需要轉換成對應類型

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

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

#include <stdio.h>
#include <stdlib.h>
int main() {
  
    int* ptr; // 定義一個指針變量
    int n,m, sum = 0; // 初始化元素個數(shù)與元素總和
    printf("輸入要保存的元素個數(shù): ");
    scanf("%d", &n);
    ptr = (int*) calloc(n, sizeof(int)); // 分配n塊足夠存儲1個int類型數(shù)字的內(nèi)存空間，將指針強制轉換為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)); // 重新分配一塊足夠存儲m個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：需要釋放的空間地址

返回值：沒有返回值

5.位域

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

• 基本定義：

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

• 示例：下面定義了一個日期的結構體，包含成員變量年、月、日，年我們用四位數(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;
}

輸出結果：

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

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

六、文件操作

1.文件的概念

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

2.文件指針

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

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

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

3.操作文件的函數(shù)

1）打開與關閉

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

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

• fclose：關閉一個文件，成功返回0，失敗返回非0
  通常對文件操作如下：

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

2）文件讀寫

文件結束符：EOF
文件寫入的函數(shù)需要以寫或者讀寫模式打開文件，文件讀取的函數(shù)需要以讀或者讀取的模式打開文件，讀取或寫入操作之后，位置指針都會向后移動到讀取或寫入位置的末尾

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

3）文件定位

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

      起始點	標識符	數(shù)字表示
      文件頭部	SEEK_SET	0
      當前位置	SEEK_CUR	1
      文件尾部	SEEK_END	2

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

4）文件檢測

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

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

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

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

• clearerr：清除出錯標志和文件結束標志，使它們?yōu)?值

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

5）文件操作示例

#include "stdio.h"
#include "stdlib.h"
struct Student {
  
    char name[20];
    int age;
    float score;
};
int main() {
  
    FILE *fp = fopen("test.txt", "w+"); // 以讀寫模式打開一個文件
    if (fp == NULL) {
  
        printf("文件打開失敗！");
        exit(1);
    }
    fputc('a', fp); // 向文件寫入一個字符'a'
    rewind(fp); // 將文件位置指針放到文件頭部，因為我們剛剛向文件寫入了一個字符'a'，所以現(xiàn)在文件位置指針指向的文件尾部
    char ch = (char)fgetc(fp); // 從文件讀取一個字符，現(xiàn)在文件中只有一個'a'，讀取的字符就是'a'
    printf("%c\n",ch);
    printf("結束位置：%d\n", feof(fp)); // 看看位置指針是不是在結束位置
    fseek(fp,1L,0); // 將文件位置指針手動置于字符'a'后面，讀取時也會把指針后移，但是寫入的時候失敗了，原因暫時未找到！
    fputs("this is fputs test", fp); // 向文件中寫入字符串，現(xiàn)在文件中的內(nèi)容應該是"athis is fputs test"
    printf("寫入出錯：%d\n",ferror(fp)); // 查看寫入是否出錯
    rewind(fp); // 位置指針放回文件頭部
    char string[255]; // 定義一個字符數(shù)組用來存放字符串
    fgets(string, 255, fp); // 讀取文件中的字符串到字符數(shù)組string中，遇到換行或文件末尾就結束
    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"，因為現(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]; // 定義一個結構體數(shù)組
    struct Student boy2[2];
    struct Student *pb; // 定義一個結構體指針
    pb = boys; // 指向結構體中第一個成員（數(shù)組首地址）
    FILE *fp1 = fopen("test1.txt", "wb+"); // 以二進制讀寫模式打開一個文件
    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)輸入學生的信息
        pb++; // 指針向后移動，指向下一個boys數(shù)組的成員
    }
    long size = sizeof(struct Student); // 獲取結構的大小
    fwrite(boys, size,3,fp1); // 向文件中寫入3個Student結構
    rewind(fp1);
    fseek(fp1,size,SEEK_SET); // 位置指針移動到第二個學生的地址
    fread(boy2,size,2,fp1);  // 讀取2個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); // 關閉文件
    return 0;
}