c语言提高学习笔记—

c语言提高学习笔记——02-c提高05day

在学习c语言提高总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

02-c提高05day

目录：
一、结构体
1、以前课程问题复习
2、结构体嵌套二级指针
3、结构体偏移量
4、结构体字节对齐
（1）内存对齐
1）内存对齐原因
2）如何内存对齐
（2）练习
二、文件操作
1、文件相关概念
（1）文件的概念
（2）流的概念
1）文本流
2）二进制流
2、文件的操作
（1）文件流总览
（2）文件指针
（3）文件缓冲区
（4）文件打开关闭
1）文件打开（fopen)
2）文件关闭（fclose)
（5）文件读写函数回顾
1）字符读写函数回顾
2）行读写函数回顾
3）块读写函数回顾
4）格式化读写函数回顾
5）随机读写函数回顾
练习：配置文件读写（重点）

一、结构体

1、以前课程问题复习

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 void test01()
 7 {
 8     char* arr[] = {"aaa", "bbb", "ccc", "ddd"};//等价于下边
 9 #if 0
10     char* p1 = "aaa";
11     char* p2 = "bbb";
12     char* p3 = "ccc";
13     char* p4 = "ddd";
14     char* arr[] = {p1, p2, p3, p4};
15 #endif
16     //返回的是首元素的地址
17     char** arr = malloc(sizeof(char*) * 4);
18     
19     //错误写法，原因放不下
20     //char** arr = {"aaa","bbb","ccc","ddd"};
21 }
22 
23 void printArray1(int* arr, int len){}
24 void printArray2(int(*arr)[3], int len){}
25 void printArray2(char** arr, int len){}
26 void test02()
27 {
28     //除了sizeof对数组名取地址这两种情况下，其他任何情况下数组名都是指向首元素的指针
29     int arr1[10]={0};//arr1是什么类型？int*类型
30     printArray1(arr1,10);
31     
32     int arr2[3][3] = {
33         {1,2,3},
34         {4,5,6},
35         {7,8,9}
36     };//arr2是什么类型？int(*)[3]
37     printArray2(arr2,3);
38     
39     char* arr3[] = {"aaa","bbb","ccc"};//arr3是什么类型？char**类型
40     printArray3(arr3,3);
41     
42     char** arr4[3];//arr4是什么类型？char***
43 }
44 
45 //数组指针
46 void test03()
47 {
48     int arr[10];
49     //第一种方法
50     typedef int (ARRAY_TYPE)[10];
51     ARRAY_TYPE *p1 = &arr;
52     //第二种方法
53     typedef int (ARRAY_POINTER_TYPE)[10];
54     ARRAY_POINTER_TYPE p2 = &arr;
55     //第三种方法
56     int(*p3)[10] = &arr;
57 }
58 
59 //结构体赋值
60 struct Person
61 {
62     char name[64];
63     int age;
64 };
65 //只要结构体内部不涉及到指针，并且指针指向堆内存，那么使用默认操作是没有问题的
66 struct Teacher
67 {
68     char* name;
69     int age;
70 };
71 
72 void test04()
73 {
74     //结构体赋值
75     struct Teacher p1, p2;
76     //p1 = p2;//会导致两个问题!
77 }
78 
79 
80 int main(){
81 
82     test01();
83     
84     system("pause");
85     return EXIT_SUCCESS;
86 }

2、结构体嵌套二级指针

练习：

内存模型图如下：

代码如下：

  1 #define _CRT_SECURE_NO_WARNINGS
  2 #include<stdio.h>
  3 #include<string.h>
  4 #include<stdlib.h>
  5 
  6 struct Teacher
  7 {
  8     char* name;
  9     char** students;
 10 };
 11 
 12 int allocateSpace(struct Teacher*** temp)
 13 {
 14     if(NULL == temp)
 15     {
 16         //错误码，不同错误码表示不同错误
 17         return -1;
 18     }
 19     
 20     struct Teacher** ts = malloc(sizeof(struct Teacher*) * 3);
 21     for(int i = 0; i < 3; ++i)
 22     {
 23         //给老师结构体指针分配空间
 24         ts[i] = malloc(sizeof(struct Teacher));
 25         
 26         //给老师名字分配空间
 27         ts[i]->name = malloc(sizeof(char) * 64);
 28         sprintf(ts[i]->name, "Teacher_%d", i + 1);
 29         
 30         //给学生指针分配内存
 31         ts[i]->students = malloc(sizeof(char*) * 4);
 32         for(int j = 0; j < 4; ++j)
 33         {
 34             ts[i]->students[j] = malloc(sizeof(char) * 64);
 35             sprintf(ts[i]->students[j], "%s_Stu_%d",ts[i]->name, j + 1);
 36         }
 37     }
 38     *temp = ts;
 39     return 0;
 40 }
 41 
 42 void printTeachers(struct Teacher** teachers)
 43 {
 44     if(NULL == teachers)
 45     {
 46         return;
 47     }
 48     for(int i = 0; i < 3; ++i)
 49     {
 50         printf("%s
", teachers[i]->name);
 51         for(int j = 0; j < 4; ++j)
 52         {
 53             printf("   %s
", teachers[i]->students[j]);
 54         }
 55     }
 56 }
 57 
 58 //释放内存
 59 void freeSpace(struct Teacher** teachers)
 60 {
 61     if(NULL == teachers)
 62     {
 63         return;
 64     }
 65     for(int i = 0; i < 3; ++i)
 66     {
 67         if(teachers[i] == NULL)
 68         {
 69             continue;
 70         }
 71         if(teachers[i]->name != NULL)
 72         {
 73             free(teachers[i]->name);
 74             teachers[i]->name = NULL;
 75         }
 76         for(int j = 0; j < 4; ++j)
 77         {
 78             if(teachers[i]->students[j] != NULL)
 79             {
 80                 free(teachers[i]->students[j]);
 81                 teachers[i]->students[j] = NULL;
 82             }
 83         }
 84         free(teachers[i]->students);
 85         teachers[i]->students = NULL;
 86         
 87             free(teachers[i]);
 88             teachers[i] = NULL;
 89 
 90     }
 91     free(teachers);
 92     teachers = NULL;
 93 }
 94 
 95 
 96 void test()
 97 {
 98     struct Teacher** teachers = NULL;
 99     
100     int ret = 0;
101     ret = allocateSpace(&teachers);
102     if(ret < 0)
103     {
104         printf("allocateSpace函数调用出错!
");
105         return;
106     }
107     //打印老师及其学生信息
108     printTeachers(teachers);
109     
110     //释放内存
111     freeSpace(teachers);
112     teachers = NULL;
113 }
114 
115 int main(){
116 
117     test();
118     
119     system("pause");
120     return EXIT_SUCCESS;
121 }

3、结构体偏移量

练习：

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 #include<stddef.h>//计算结构体成员的偏移量
 6 
 7 struct A
 8 {
 9     char a1;
10     int a2;
11 };
12 
13 void test01()
14 {
15     struct A a = {'b', 20};
16     printf("A.a2:%d
",*(int*)((char*)&a + offsetof(struct A, a2)));
17     printf("A.a2:%d
", *((int*)&a + 1));
18 }
19 
20 struct C
21 {
22     int a;
23     double b;
24 };
25 struct B
26 {
27     char a;
28     int b;
29     struct C c;
30 };
31 
32 void test02()
33 {
34     struct B b = {'a', 20, 30, 3.14};
35     int off1 = offsetof(struct B, c);
36     int off2 = offsetof(struct C, b);
37     
38     printf("%d
",  *(double*)(((char*)&b + off1) + off2));
39     printf("%d
",  &(b.c.b);//判断b地址是否正确
40     printf("%d
",  ((struct c*)((char*)&b + off1))->b);
41 }
42 
43 
44 int main(){
45 
46     test01();
47     
48     system("pause");
49     return EXIT_SUCCESS;
50 }

4、结构体字节对齐
在用sizeof运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。

从理论上讲，对于任何变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排列，而不是简单地顺序排列，这就是内存对齐。

（1）内存对齐

1）内存对齐原因

我们知道内存的最小单元是一个字节，当cpu从内存中读取数据的时候，是一个一个字节读取，所以内存对我们应该是入下图这样：

但是实际上cpu将内存当成多个块每次从内存中读取一个块这个块的大小可能是2、4、8、16等，
那么下面，我们来分析下非内存对齐和内存对齐的优缺点在哪？

内存对齐是操作系统为了提高访问内存的策略。操作系统在访问内存的时候，每次读取一定长度（这个长度是操作系统默认的对齐数，或者默认对齐数的整数倍）。如果没有对齐，为了访问一个变量可能产生二次访问。

至此大家应该能够简单明白，为什么要简单内存对齐？
·提高存取数据的速度。比如有的平台每次都是从偶地址处读取数据，对于一个int型的变量，若从偶地址单元处存放，则只需一个读取周期即可读取该变量；但是若从奇地址单元处存放，则需要2个读取周期读取该变量。
·某些平台只能在特定的地址处访问特定类型的数据，否则抛出硬件异常给操作系统。

2）如何内存对齐
■对于标准数据类型，它的地址只要是它的长度的整数倍。
■对于非标准数据类型，比如结构体，要遵循一下对齐原则：

1.数组成员对齐规则。第一个数组成员应该放在offset为0的地方，以后每个数组成员应该放在offset为min（当前成员的大小，#pargama pack(n))整数倍的地方开始（比如int在32位机器为4字节，#pargama pack(2)，那么从2的倍数地方开始存储）。
2.结构体总的大小，也就是sizeof的结果，必须是min（结构体内部最大成员，#pargama pack(n))的整数倍，不足要补齐。
3.结构体做为成员的对齐规则。如果一个结构体B里嵌套另一个结构体A，还是以最大成员类型的大小对齐，但是结构体A的起点为A内部最大成员的整数倍的地方。（struct B里存有structA，A里有char，int，double等成员，那A应该从8的整数倍开始存储。），结构体A中的成员的对齐规则仍满足原则1、原则2。

手动设置对齐模数：
■#pragma pack(show)
显示当前 packing alignment的字节数，以warning message的形式被显示。

■#pragma pack(push)
将当前指定的packing alignment数组进行压栈操作，这里的栈是the internal compiler stack，同事设置当前的packing alignment为n；如果n没有指定，则将当前的packing alignment数组压栈。

■#pragma pack(pop)
从internal compiler stack 中删除最顶端的reaord；如果没有指定n,则当前栈顶record即为新的packing alignement数值；如果指定了n，则n成为新的packing alignment值。

■#pragma pack(n)
指定packing的数值以字节为单位缺省数值是8合法的数值分别是1,2,4,8,16。

（2）练习：

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 #include<stddef.h>//计算结构体成员的偏移量
 6 
 7 //1.第一个元素偏移量是0
 8 //2.从第二个元素开始计算偏移量，20
 9 //3.计算整体偏移，找最大成员（double）为8，最终大小必须是8的倍数，大于20最小的8的倍数是24
10 struct Student{
11     int a;//0-3
12     char b;//1和8取最小，放到4
13     double c;//8和8取最小，放到8-15
14     float d;//4和8取最小，放到16-19
15 };
16 
17 void test01()
18 {
19     printf("%d
", sizeof(struct Student));
20 }
21 
22 int main(){
23 
24     test01();
25     
26     system("pause");
27     return EXIT_SUCCESS;
28 }

深入理解：（结构体嵌套结构体）

 1 #pragma pack(4)
 2 
 3 typedef struct _STUDENT{
 4     int a;
 5     char b;
 6     double c;
 7     float d;
 8 }Student;
 9 
10 typedef struct _STUDENT2{
11     char a;
12     Student b;
13     double c;
14 }Student2;
15 
16 void test01(){
17     //Student
18     //a从偏移量0位置开始存储
19     //b从4位置开始存储
20     //c从8位置开始存储
21     //d从12位置开存储
22     //所以Student内部对齐之后的大小为20，整体对齐，整体为最大类型的整数倍也就是8的整数倍为24
23     printf("sizeof Student:%d
",sizeof(Student));
24 
25     //Student2
26     //a从偏移量为0位置开始8
27     //b从偏移量为Student内部最大成员整数倍开始，也就是8开始24
28     //c从8的整数倍地方开始，也就是32开始
29     //所以结构体Sutdnet2内部对齐之后的大小为：40，由于结构体中最大成员为8，必须为8的整数倍所以大小为40
30     printf("sizeof Student2:%d
",sizeof(Student2));
31 }

二、文件操作
文件在今天的计算机系统中作用是很重要的。文件用来存放程序、文档、数据、表格、图片和其他很多种类的信息。作为一名程序员，您必须编程来创建、写入和读取文件。编写程序从文件读取信息或者将结果写入文件是一种经常性的需求。C提供了强大的和文件进行通信的方法。使用这种方法我们可以在程序中打开文件，然后使用专门的I/O函数读取文件或者写入文件。

1、文件相关概念
（1）文件的概念
一个文件通常就是磁盘上一段命名的存储区。但是对于操作系统来说，文件就会更复杂一些。例如，一个大文件可以存储在一些分散的区段中，或者还会包含一些操作系统可以确定其文件类型的附加数据，但是这些是操作系统，而不是我们程序员所要关心的事情。我们应该考虑如何在C程序中处理文件。

（2）流的概念
流是一个动态的概念，可以将一个字节形象地比喻成一滴水，字节在设备、文件和程序之间的传输就是流，类似于水在管道中的传输，可以看出，流是对输入输出源的一种抽象，也是对传输信息的一种抽象。

C语言中，I/O操作可以简单地看作是从程序移进或移出字节，这种搬运的过程便称为流（stream)。程序只需要关心是否正确地输出了字节数据，以及是否正确地输入了要读取字节数据，特定I/O设备的细节对程序员是隐藏的。

1）文本流
文本流，也就是我们常说的以文本模式读取文件。文本流的有些特性在不同的系统中可能不同。其中之一就是文本行的最大长度。标准规定至少允许254个字符。另一个可能不同的特性是文本行的结束方式。例如在Windows系统中，文本文件约定以一个回车符和一个换行符结尾。但是在Linux下只使用一个换行符结尾。

标准C把文本定义为零个或者多个字符，后面跟一个表示结束的换行符（ ).对于那些文本行的外在表现形式与这个定义不同的系统上，库函数负责外部形式和内部形式之间的翻译。例如，在Windows系统中，在输出时，文本的换行符被写成一对回车/换行符。在输入时，文本中的回车符被丢弃。这种不必考虑文本的外部形势而操纵文本的能力简化了可移植程序的创建。

2）二进制流
二进制流中的字节将完全根据程序编写它们的形式写入到文件中，而且完全根据它们从文件或设备读取的形式读入到程序中。它们并未做任何改变。这种类型的流适用于非文本数据，但是如果你不希望I/O函数修改文本文件的行未字符，也可以把它们用于文本文件。

c语言在处理这两种文件的时候并不区分，都看成是字符流，按字节进行处理。

我们程序中，经常看到的文本方式打开文件和二进制方式打开文件仅仅体现在换行符的处理上。

比如说，在widows下，文件的换行符是，而在Linux下换行符则是 .

当对文件使用文本方式打开的时候，读写的windows文件中的换行符会被替换成读到内存中，当在windows下写入文件的时候，被替换成再写入文件。如果使用二进制方式打开文件，则不进行和之间的转换。那么由于Linux下的换行符就是，所以文本文件方式和二进制方式无区别。

2、文件的操作
（1）文件流总览
标准库函数是的我们在C程序中执行与文件相关的I/O任务非常方便。下面是关于文件I/O的一般概况。

1.程序为同时处于活动状态的每个文件声明一个指针变量，其类型为FILE*。这个指针指向这个FILE结构，当它处于活动状态时由流使用。

2.流通过fopen函数打开。为了打开一个流，我们必须指定需要访问的文件或设备以及他们的访问方式（读、写、或者读写）。Fopen 和操作系统验证文件或者设备是否存在并初始化FILE。

3.根据需要对文件进行读写操作。

4.最后调用fclose函数关闭流。关闭一个流可以防止与它相关的文件被再次访问保证任何存储于缓冲区中的数据被正确写入到文件中并且释放 FILE结构。

标准I/O更为简单，因为它们并不需要打开或者关闭。

I/O函数以三种基本的形式处理数据：单个字符、文本行和二进制数据。对于每种形式都有一组特定的函数对它们进行处理。

（2）文件指针
我们知道，文件是由操作系统管理的单元。当我们想操作一个文件的时候，让操作系统帮我们打开文件，操作系统把我们指定要打开文件的信息保存起来，并且返回给我们一个指针指向文件的信息。文件指针也可以理解为代指打开的文件。这个指针的类型为FILE类型。该类型定义在stdio.h头文件中。通过文件指针，我们就可以对文件进行各种操作。

对于每一个ANSIC程序，运行时系统必须提供至少三个流-标准输入（stdin)、标准输出（stdout)、标准错误(stderr)，它们都是一个指向FILE结构的指针。标准输入是缺省情况下的输入来源，标准输出时缺省情况下的输出设置。具体缺省值因编译器而异，通常标准输入为键盘设备、标准输出为终端或者屏幕。

ANSI C并未规定FILE的成员，不同编译器可能有不同的定义。VS下FILE信息如下：

 1 struct _iobuf{
 2     char *_ptr;//文件输入的下一个位置
 3     int _cnt;//剩余多少字符未被读取
 4     char *_base;//指基础位置（应该是文件的起始位置）
 5     int _flag;//文件标志
 6     int _file;//文件的有效性验证
 7     int _charbuf;//检查缓冲区状况，如果无缓冲区则不读取
 8     int _bufsiz;//文件的大小
 9     char *_tmpfname;//临时文件名
10 };
11 typedef struct _iobuf FILE;

（3）文件缓冲区

■文件缓冲区
ANSIC标准采用“缓冲文件系统"处理数据文件所谓缓冲文件系统是指系统自动地在内存区为程序中每一个正在使用的文件开辟一个文件缓冲区从内存向磁盘输出数据必须先送到内存中的缓冲区，装满缓冲区后才一起送到磁盘去如果从磁盘向计算机读入数据，则一次从磁盘文件将一批数据输入到内存缓冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（给程序变量）。

那么文件缓冲区有什么作用呢？
如我们从磁盘里取信息，我们先把读出的数据放在缓冲区，计算机再直接从缓冲区中取|数据，等缓冲区的数据取完后再去磁盘中读取，这样就可以减少磁盘的读写次数，再加上计算机对缓冲区的操作大大快于对磁盘的操作，故应用缓冲区可大大提高计算机的运行速度。

（4）文件打开关闭
1）文件打开（fopen)

文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区，并将该结构的指针返回给用户程序，以后用户程序就可用此FILE指针来实现对指定文件的存取操作了。当使用打开函数时，必须给出文件名、文件操作方式（读、写或读写）。

1 FILE * fopen(const char * filename,const char * mode);
2 功能：打开文件
3 参数：
4     filename:需要打开的文件名，根据需要加上路径
5     mode：打开文件的权限设置
6 返回值：
7     成功：文件指针
8     失败：NULL

示例代码：

 1 void test(){
 2 
 3     FILE*fp=NULL;
 4 
 5     //"“这样的路径形式，只能在windows使用
 6     //"/”这样的路径形式，windows和1inux平台下都可用，建议使用这种
 7     //路径可以是相对路径，也可是绝对路径
 8     fp=fopen("../test","w");
 9     //fp=fopen("..\test","w");
10     
11     if（fp==NULL)/返回空，说明打开失败
12     {
13         //perror（）是标准出错打印函数，能打印调用库函数出错原因
14         perror（"open");
15         return-1;
16     }
17 }

应该检查fopen的返回值！如何函数失败，它会返回一个NULL值。如果程序不检查错误，这个NULL指针就会传给后续的I/O函数。它们将对这个指针执行间接访问，并将失败。

2）文件关闭（fclose)

文件操作完成后，如果程序没有结束，必须要用fclose0函数进行关闭，这是因为对打开的文件进行写入时，若文件缓冲区的空间未被写入的内容填满，这些内容不会写到打开的文件中。只有对打开的文件进行关闭操作时，停留在文件缓冲区的内容才能写到该文件中去，从而使文件完整。再者一旦关闭了文件，该文件对应的FILE结构将被释放，从而使关闭的文件得到保护，因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区。

1 int fclose(FILE * stream);
2 功能：关闭先前fopen）打开的文件。此动作让缓冲区的数据写入文件中，并释放系统所提供的文件资源。
3 参数：
4     stream:文件指针
5 返回值：
6     成功：0
7     失败：-1

它表示该函数将关闭FILE指针对应的文件，并返回一个整数值。若成功地关闭了文件，则返回一个0值，否则返回一个非0值.

练习：

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 void test01()
 7 {
 8     FILE* f = fopen("./test.txt", "r");
 9     if(NULL == f)
10     {
11         fprintf("打开文件失败!
");
12         return;
13     }
14     char ch;
15 #if 0
16     while(!feof(f))//此处判断的是文件结束标志flag，而非EOF。滞后性！
17     {
18         ch = fgetc(f);
19         
20         //问题？多了空格，由于EOF滞后性
21         if(feof(f)) //读到文件结尾的EOF,在文件的源结构体中用flag定义（false/true）
22         {
23             break;
24         }
25         
26         printf("%c", ch);
27     }
28 #endif
29     //优化
30     while((ch = fgetc(f)) != EOF)
31     {
32         printf("%c", ch);
33     }
34     
35     //关闭文件
36     fclose(f);
37     f = NULL;
38 }
39 
40 struct Person
41 {
42     char name[64];//使用char* name;需要注意，如果是在堆上开辟的空间，文件打开后指针指向会错误
43     int age;
44 };
45 
46 void test02()
47 {
48     struct Person p1 = {"aaa", 20};
49 }
50 
51 int main(){
52 
53     test01();
54     
55     system("pause");
56     return EXIT_SUCCESS;
57 }

（5）文件读写函数回顾
·按照字符读写文件：fgetc()，fputc()
·按照行读写文件：fputs()，fgets()
·按照块读写文件：fread()，fwirte()
·按照格式化读写文件：fprintf()，fscanf()
·按照随机位置读写文件：fseek()，ftell()，rewind()

1）字符读写函数回顾

 1 int fputc(int ch,FILE* stream);
 2 功能：将ch转换为unsigned char后写入stream指定的文件中
 3 参数：
 4     ch：需要写入文件的字符
 5     stream:文件指针
 6 返回值：
 7     成功：成功写入文件的字符
 8     失败：返回-1
 9 
10 int fgetc(FILE* stream);
11 功能：从stream指定的文件中读取一个字符
12 参数：
13     stream:文件指针
14 返回值：
15     成功：返回读取到的字符
16     失败：-1
17 
18 int feof(FILE* stream);
19 功能：检测是否读取到了文件结尾
20 参数：
21     stream:文件指针
22 返回值：
23     非0值：已经到文件结尾
24     0：没有到文件结尾

 1 void test(){
 2 
 3     //写文件
 4     FILE* fp_ write=NULL;
 5     //写方式打开文件
 6     fp_write=fopen("./mydata.txt","w+");
 7     if(fp_write==NULL){
 8         return;
 9     }
10 
11     char buf[]="this is a test for pfutc!";
12 
13     for(int i=0;i<strlen(buf);i++){
14         fputc(buf[i],fp_write);
15     }
16     fclose（fp_write);
17 
18     //读文件
19     FILE* fp_read=NULL;
20     fp_read=fopen("./mydata.txt","r");
21     if(fp read==NULL){
22         return;
23     }
24 
25 #if 0
26     //判断文件结尾注意：多输出一个空格
27     while(！feof(fp_read)){
28         printf("%c"，fgetc(fp_read));
29     }
30 #else
31     char ch;
32     while((ch=fgetc(fp read))!=EOF){
33         printf("%c",ch);
34     }
35 #endif
36 }

将把流指针fp指向的文件中的一个字符读出，并赋给ch，当执行fgetc0函数时，若当时文件指针指到文件尾，即遇到文件结束标志EOF（其对应值为-1)，该函数返回一个-1给ch，在程序中常用检查该函数返回值是否为-1来判断是否已读到文件尾，从而决定是否继续。

2）行读写函数回顾

 1 int fputs(const char * str,FILE * stream);
 2 功能：将str所指定的字符串写入到stream指定的文件中，字符串结束符’0'不写入文件。
 3 参数：
 4     str：字符串
 5     stream:文件指针
 6 返回值：
 7     成功：0
 8     失败：-1
 9 
10 char *fgets(char * str,int size,FILE* stream);
11 功能：从stream指定的文件内读入字符，保存到str所指定的内存空间，直到出现换行字符、读到文件结尾或是已读了size-1个字符为止，最后会自动加上字符’0’作为字符串结束。
12 参数：
13     str：字符串
14     size：指定最大读取字符串的长度(size-1）
15     stream：文件指针
16 返回值：
17     成功：成功读取的字符串
18     读到文件尾或出错：NULL

 1 void test(){
 2 
 3     //写文件
 4     FILE* fp_write=NMULL;
 5     //写方式打开文件
 6     fp write=fopen("./mydata.txt","w+");
 7     if(fp write==NMULL){
 8         perror（"fopen:"）;
 9         return;
10     }
11 
12     char* buf[]={
13         "01this is a test for pfutc!
"，
14         "02 this is a test for pfutc!
",
15         "03 this is a test for pfutc!
",
16         "04 this is a test for pfutc!
",
17     };
18 
19     for(int i=0;i<4;i++){
20         fputs(buf[i],fp_write);
21     }
22 
23     fclose(fp_write);
24 
25     //读文件
26     FILE* fp_read=NLL;
27     fp_read=fopen("./mydata.txt","r");
28     if(fp_read==NULL){
29         perror("fopen:");
30         return;
31     }
32 
33     //判断文件结尾
34     while(!feof(fp_read)){
35         char temp[1024]={0};
36         fgets(temp,1024,fp_read);
37         printf("%s"，temp);
38     }
39     fclose(fp_read);
40 }

3）块读写函数回顾

 1 size_t fwrite(const void *ptr,size_t size,size_t nmemb,FILE *stream);
 2 功能：以数据块的方式给文件写入内容
 3 参数：
 4     ptr：准备写入文件数据的地址
 5     size：size_t为unsigned int类型，此参数指定写入文件内容的块数据大小
 6     nmemb：写入文件的块数，写入文件数据总大小为：size*nmemb
 7     stream:已经打开的文件指针
 8 返回值：
 9     成功：实际成功写入文件数据的块数，此值和nmemb相等
10     失败：0
11 
12 size_t fread(void *ptr,size_t size,size_t nmemb,FILE *stream);
13 功能：以数据块的方式从文件中读取内容
14 参数：
15     ptr：存放读取出来数据的内存空间
16     size：size_t为unsigned int类型，此参数指定读取文件内容的块数据大小
17     nmemb：读取文件的块数，读取文件数据总大小为：size*nmemb
18     stream:已经打开的文件指针
19 返回值：
20     成功：实际成功读取到内容的块数，如果此值比nmemb小，但大于0，说明读到文件的结尾。
21     失败：0

 1 typedef struct _TEACHER{
 2     char name[64];
 3     int age;
 4 }Teacher;
 5 
 6 void test(){
 7 
 8     //写文件
 9     FILE* fp_ write=NULL;
10     //写方式打开文件
11     fp write=fopen("./mydata.txt","wb");
12     if(fp write==NULL){
13         perror("fopen:"）;
14         return;
15     }
16     Teacher teachers[4]={
17         {"0bama",33},
18         {"John",28},
19         {"Edward",45},
20         {"Smith",35}
21     };
22 
23     for(int i=0;i<4;i++){
24         fwrite(&teachers[i],sizeof(Teacher),1,fp_write);
25     }
26     //关闭文件
27     fclose(fp_write);
28 
29     //读文件
30     FILE* fp_read=NULL;
31     fp_read=fopen("./mydata.txt","rb");
32     if(fp_read==NULL){
33         perror("fopen:"）;
34         return;
35     }
36     
37     Teacher temps[4];
38     fread(&temps,sizeof(Teacher),4,fp read);
39     for(int i=0;i<4;i++){
40         printf("Name:%s Age:%d
",temps[i].name,temps[i].age):
41     }
42     fclose(fp_read);
43 }

4）格式化读写函数回顾

 1 int fprintf(FILE * stream,const char * format,...);
 2 功能：根据参数format字符串来转换并格式化数据，然后将结果输出到stream指定的文件中，指定出现字符串结束符’0'为止。
 3 参数：
 4     stream:已经打开的文件
 5     format:字符串格式，用法和printf()一样
 6 返回值：
 7     成功：实际写入文件的字符个数
 8     失败：-1
 9 
10 int fscanf(FILE* stream,const char* format,..);
11 功能：从stream指定的文件读取字符串，并根据参数format字符串来转换并格式化数据。
12 参数：
13     stream:已经打开的文件
14     format:字符串格式，用法和scanf（）一样
15 返回值：
16     成功：实际从文件中读取的字符个数
17     失败：-1

注意：fscanf遇到空格和换行时结束。

 1 void test(){
 2 
 3     //写文件
 4     FILE* fp_write=NULL;
 5     //写方式打开文件
 6     fp_write=fopen("./mydata.txt","w");
 7     if(fp_write==NULL){
 8         perror（"fopen:"）;
 9         return;
10     }
11 
12     fprintf(fp_write,"hello world:%d!",10);
13 
14     //关闭文件
15     fclose(fp_write);
16 
17     //读文件
18     FILE* fp_read=NULL;
19     fp_read=fopen("./mydata.txt","rb");
20     if(fp_read==NULL){
21         perror("fopen:"）;
22         return;
23     }
24 
25     char temps[1024]={0};
26     while(!feof(fp_read)){
27         fscanf(fpread,"%s",temps);
28         printf("%s",temps);
29     }
30     
31     fclose(fp_read);
32 }

5）随机读写函数回顾

 1 int fseek(FILE *stream,long offset,int whence);
 2 功能：移动文件流（文件光标）的读写位置。
 3 参数：
 4     stream：已经打开的文件指针
 5     offset：根据whence来移动的位移数（偏移量），可以是正数，也可以负数，如果正数，则相对于whence往右移动，如果是负数，则相对于whence往左移动。如果向前移动的字节数超过了文件开头则出错返回，如果向后移动的字节数超过了文件末尾，再次写入时将增大文件尺寸。
 6 whence：其取值如下：
 7     SEEK_SET：从文件开头移动offset个字节
 8     SEEK_CUR:从当前位置移动offset个字节
 9     SEEK_END：从文件末尾移动offset个字节
10 返回值：
11     成功：0
12     失败：-1
13 
14 1ong ftel1（FILE *stream);
15 功能：获取文件流（文件光标）的读写位置。
16 参数：
17     stream:已经打开的文件指针
18 返回值：
19     成功：当前文件流（文件光标）的读写位置
20     失败：-1
21 
22 void rewind(FILE *stream);
23 功能：把文件流（文件光标）的读写位置移动到文件开头。
24 参数：
25     stream:已经打开的文件指针
26 返回值：
27     无返回值

 1 typedef struct _TEACHER{
 2     char name[64];
 3     int age;
 4 }Teacher;
 5 
 6 void test(){
 7 
 8     //写文件
 9     FILE* fp_write=NULL;
10     //写方式打开文件
11     fp_write=fopen("./mydata.txt","wb");
12     if(fp_write==NULL){
13         perror（"fopen:"）;
14         return;
15     }
16 
17     Teacher teachers[4]={
18         {"0bama"，33}，
19         {"John"，28}，
20         {"Edward"，45}，
21         {"Smith"，35}
22     };
23 
24     for(int i=0;i<4;i++){
25         fwrite(&teachers[i],sizeof(Teacher),1,fp_write);
26     }
27 
28     //关闭文件
29     fclose(fp_write);
30 
31     //读文件
32     FILE* fp_read=NULL;
33     fp_read=fopen("./mydata.txt","rb");
34     if(fp_read==NULL){
35         perror（"fopen:"）;
36         return;
37     }
38 
39     Teacher temp;
40     //读取第三个数组
41     fseek(fp_read,sizeof(Teacher)*2,SEEK_SET);
42     fread(&temp,sizeof(Teacher),1,fp_read);
43     printf("Name:%s Age:%d
",temp.name,temp.age);
44 
45     memset(&temp,0,sizeof(Teacher));
46 
47     fseek(fp_read,-(int)sizeof(Teacher),SEEK_END);
48     fread(&temp,sizeof(Teacher),1,fp_read);
49     printf("Name:%s Age:%d
",temp.name,temp.age);
50 
51     rewind(fp_read);
52     fread(&temp,sizeof(Teacher),1,fp_read);
53     printf("Name:%s Age:%d
",temp.name,temp.age);
54 
55     fclose(fp_read);
56 }

大练习：配置文件读写！！！

内存模型分析：

config.ini

 1 //config.ini
 2 #只是我的IP地址
 3 ip:127.0.0.1
 4 #只是我的端口
 5 port:8080
 6 #这是我的用户名
 7 username:root
 8 #只是我的密码
 9 password:admin
10 
11 
12 
13 aaa:bbb
14 uuuuuuuuuuuuuuuuuuuu
15 
16 #1.加载配置文件
17 
18 #2.解析配置文件
19 #struct ConfigInfo
20 #{
21 #    char key[64];
22 #    char val[128];
23 #};

ConfigFile.h

 1 #define _CRT_SECURE_NO_WARNINGS //ConfigFile.h
 2 //防止头文件重复包含
 3 #pragma once
 4 
 5 #include<stdio.h>
 6 #include<string.h>
 7 #include<stdlib.h>
 8 
 9 struct ConfigInfo
10 {
11     char key[64];
12     char val[128];
13 };
14 
15 //目的为了在C++中调用C写的函数
16 #ifdef __cplusplus
17     extern "C"{
18 #endif
19     
20     //获得文件有效行数
21     int getLines_ConfigFile(File* file);
22     //加载配置文件
23     void loadFile_ConfigFile(const char* filePath, char*** fileData, int* lines);
24     //解析配置文件
25     void parseFile_ConfigFile(char** fileData, int lines, struct ConfigInfo** Info);
26     //获得指定配置信息
27     char* getInfo_ConfigFile(const char* key, struct ConfigInfo* Info, int line);
28     //释放配置文件信息
29     void destroInfo_ConfigFile(struct ConfigInfo* Info);
30     //判断当前行是否有效
31     int isValid_ConfigFile(const char* buf);
32     
33     
34 #ifdef __cplusplus
35     }
36 #endif

ConfigFile.c

  1 #include"ConfigFile.h"
  2 
  3 //获得文件有效行数
  4 int getLines_ConfigFile(File* file)
  5 {
  6     char buf[1024] = {0};
  7     int lines = 0;
  8     while(fgets(buf, 1024, file) != NULL)
  9     {
 10         if(!isValid_ConfigFile(buf))
 11         {
 12             continue;
 13         }
 14         memset(buf, 0, 1024);
 15         ++lines;
 16     }
 17     //把文件指针重置到文件的开头
 18     fseek(file, 0, SEEK_SET);
 19     
 20     return lines;
 21 }
 22 //加载配置文件
 23 void loadFile_ConfigFile(const char* filePath, char*** fileData, int* line)
 24 {
 25     FILE* file = fopen(filePath, "r");
 26     if(NULL == file)
 27     {
 28         return;
 29     }
 30     int lines = getLines_ConfigFile(file);
 31     
 32     //给每行数据开辟内存
 33     char** temp = malloc(sizeof(char*) * lines);
 34     
 35     char buf[1024] = {0};
 36     
 37     int index = 0;
 38     
 39     while(fgets(buf, 1024, file) != NULL)
 40     {
 41         //如果返回false
 42         if(!isValid_ConfigFile(buf))
 43         {
 44             continue;
 45         }
 46         temp[index] = malloc(strlen(buf) + 1);//此处后续处理，后边默认'
',后续更换为''
 47         strcpy(temp[index], buf);
 48         ++index;
 49         //清空buf
 50         memset(buf, 0, 1024);
 51     }
 52     //关闭文件
 53     fclose(file);
 54     
 55     *fileData = temp;
 56     *line = lines;
 57 }
 58 //解析配置文件
 59 void parseFile_ConfigFile(char** fileData, int lines, struct ConfigInfo** Info)
 60 {
 61     struct ConfigInfo* myinfo = malloc(sizeof(struct ConfigInfo) * lines);
 62     memset(myinfo, 0, sizeof(struct ConfigInfo) * lines);
 63     
 64     for(int i = 0; i < lines; ++i)
 65     {
 66         char* pos = strchr(fileData[i], ':');
 67         
 68         //拷贝数据
 69         strncpy(myinfo[i].key, fileData[i], pos - fileData[i]);
 70         strncpy(myinfo[i].val, pos + 1, strlen(pos + 1) - 1);
 71         
 72         //printf("key:%s val:%s
", myinfo[i].key, myinfo[i].val);//测试结果是否正确
 73     }
 74     
 75     //释放文件信息
 76     for(int i = 0; i < lines; ++i)
 77     {
 78         if(fileData[i] != NULL)
 79         {
 80             free(fileData[i]);
 81             fileData[i] = NULL;
 82         }    
 83     }
 84     
 85     *info = myinfo;
 86 
 87 }
 88 //获得指定配置信息
 89 char* getInfo_ConfigFile(const char* key, struct ConfigInfo* Info, int line)
 90 {
 91     for(int i = 0; i < line; ++i)
 92     {
 93         if(strcmp(key, info[i].key) == 0)
 94         {
 95             return info[i].val;
 96         }    
 97     }
 98     
 99     
100     return NULL;
101 }
102 
103 //释放配置文件信息
104 void destroInfo_ConfigFile(struct ConfigInfo* Info)
105 {
106     if(NULL == info)
107     {
108         return;
109     }
110     free(info);
111     info = NULL;
112 }
113 //判断当前行是否有效
114 int isValid_ConfigFile(const char* buf)
115 {
116     if(buf[0] == '#' || buf[0] == '
' || strchr(buf, ':') == NULL)
117     {
118         return 0;
119     }
120     return 1;
121 }

配置文件读写.c

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 #include"ConfigFile.h"
 6 
 7 void test()
 8 {
 9     char** fileData = NULL;
10     int lines = 0;
11     struct ConfigInfo* info = NULL;
12     //加载配置文件
13     loadFile_ConfigFile("./config.ini", &fileData, &lines);
14     
15     //printf("lines = %d
", lines);//测试行数是否正确
16     //解析配置文件
17     parseFile_ConfigFile(fileData, lines, &info);
18     printf("IP:%s
", getInfo_ConfigFile("ip", info, lines));
19     
20     //释放配置信息内存
21     destroInfo_ConfigFile(info);
22 }
23 
24 int main(){
25 
26     test();
27     
28     system("pause");
29     return EXIT_SUCCESS;
30 }

参考：

1）讲义：豆丁网：https://www.docin.com/p-2159552288.html
道客巴巴：https://www.doc88.com/p-6951788232280.html

在学习c语言提高总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。