目录
文件
文件分两种，第一种是程序文件，后一种是数据文件。
程序文件：包括源程序文件（后缀为.c），目标文件（windows环境后缀为.obj）可执行程序（windows环境后缀为.exe）。
数据文件：文件的内同 不一定是程序，而是程序员运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出的文件。
文件名：
文件名包含三部分：文件路径+文件名主干+文件后缀
例：c：\code\test.txt
进行文件操作时需要用到流
"流"（stream）通常用于描述数据的传输或处理。流可以是输入流（input stream）或输出流（output stream），它们分别用于从外部源读取数据或将数据写入外部目标。
输入流：输入流用于从外部源（比如文件、键盘、网络等）读取数据到程序中。在C语言中，你可以使用标准输入流（stdin）来接收用户输入，也可以使用文件输入流来读取文件中的数据。
输出流：输出流用于将程序中的数据写入外部目标（比如文件、屏幕、网络等）。在C语言中，你可以使用标准输出流（stdout）来输出到屏幕上，也可以使用文件输出流将数据写入文件。
标准流
stdin-标准输入流，可以将数据写入一个文本文件，并将该文件重定向到程序的标准输入。
stdout-标准输出流，程序的输出重定向到文件或其他位置，可以使用标准输出(stdout)重定向。
stderr-标准错误流，大多数环境中输出到显示器上面。
标准流的类型是FILE*，通常称为文件指针。
文件指针
缓冲文件系统中，关键的概念是“文件类型指针”简称“文件指针”
每个被使用的文件都在内存中开辟了一个相应的文件信息区。这些信息保存在结构体变量中，该结构体由系统声明，取名FILE
结构体原型：
typedef struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
} FILE;
文件的读写
文件读写应先打开后关闭
ANSIC规定使用fopen函数打开文件，fclose来关闭文件。
//打开文件
FILE * fopen(const char * filename, const char * mode);
//关闭文件
int fclose(FILE * stream);
文件的使用方式
文件的顺序读写：
fgetc和fputc
fgetc 是C标准库中用于从文件中读取一个字符的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
int fgetc(FILE *stream);
stream：指向FILE结构体的指针，表示要读取字符的文件流。
fgetc 函数的作用是从指定的文件流中读取一个字符，并将该字符作为无符号字符返回。如果到达文件末尾或者发生错误，它会返回 EOF（End Of File）。
fputc 是C标准库中用于向文件中写入一个字符的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
int fputc(int character, FILE *stream);
character：要写入到文件的字符。stream：指向FILE结构体的指针，表示要写入字符的文件流。
fputc 函数的作用是向指定的文件流中写入一个字符。它会将指定的字符写入到文件中，并返回写入的字符。如果写入成功，则返回写入的字符；如果发生错误，返回 EOF。
fgets和fputs
fgets 是C标准库中用于从文件流中读取一行数据的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
char *fgets(char *str, int num, FILE *stream);
str：指向一个字符数组的指针，用于存储读取的字符串数据。num：要读取的最大字符数（包括空字符）。stream：指向FILE结构体的指针，表示要读取数据的文件流。
fgets 函数会从指定的文件流中读取一行数据（包括换行符），并将其存储到指定的字符数组中。它会一直读取直到遇到换行符 \n、文件结束符 EOF 或者读取了 num-1 个字符为止，并在最后添加一个 null 字符 \0 作为字符串的结尾。
fputs 是C标准库中用于向文件中写入字符串的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
int fputs(const char *str, FILE *stream);
str：要写入到文件的字符串。stream：指向FILE结构体的指针，表示要写入字符串的文件流。
fputs 函数的作用是向指定的文件流中写入一个以 null 结尾的字符串。它会将指定的字符串写入到文件中，并返回非负值（非错误）；如果发生错误，返回 EOF。
fscanf和fprintf
fscanf 是C标准库中用于从文件中读取格式化输入的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
int fscanf(FILE *stream, const char *format, ...);
stream：指向FILE结构体的指针，表示要读取数据的文件流。format：格式化字符串，指定了要读取的数据类型和格式。
fscanf 函数根据指定的格式字符串从文件流中读取数据，并根据格式进行解析和存储。它将读取的数据转换为相应的数据类型，并按照格式字符串的指示将数据存储到相应的变量中。
fprintf 是C标准库中用于将格式化数据输出到文件的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
int fprintf(FILE *stream, const char *format, ...);
stream：指向FILE结构体的指针，表示要输出数据的文件流。format：格式化字符串，指定了要输出的数据类型和格式。
fprintf 函数根据指定的格式字符串将数据格式化后输出到指定的文件流中。它类似于 printf 函数，但是可以将输出重定向到文件而不是标准输出。
fread和fwrite
fread 是C标准库中用于从文件中读取数据的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
ptr：指向存储读取数据的内存块的指针。size：要读取的每个数据项的字节数。nmemb：要读取的数据项的数量。stream：指向FILE结构体的指针，表示要读取数据的文件流。
fread 函数从文件流中读取数据，并将数据存储到指定的内存块中。它会返回实际读取的数据项数量，通常用于读取二进制数据。
fwrite 是 C 标准库中用于将数据写入文件的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
ptr：指向要写入文件的数据块的指针。size：每个数据项的大小（字节数）。nmemb：要写入的数据项的数量。stream：指向FILE结构体的指针，表示要写入数据的文件流。
fwrite 函数将指定数量的数据项从内存中写入到文件中。它通常用于写入二进制数据到文件。
使用部分
文件的打开和关闭
以下是打开文件和关闭文件的操作
#include <stdio.h>
int main()
{
FILE* pf = fopen("data.txt", "w");//创建文件 打开文件
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
//....
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}这样就创建了data.txt文件
在我这里，D:\clone仓库\test.c\test_3_26表示当前目录
.表示当前目录
..表示上一目录
fputc和fgetc的使用
使用fputc写入26个小写字母
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
int i = 0;
for (i = 0; i < 26; i++)
{
fputc('a' + i, pf);
}
fclose(pf);
pf = NULL;
return 0;
}
使用fgetc读取data.txt的内容
fputc和fgetc的读写都有一个共同的特点，就是光标会随着读写依次往后跳
使用fgetc函数读取data1.txt中的内容，再使用fputc函数输出到data.txt中
这里我先创建好了data1.txt并输入了内容abcdefghi。
另外需要注意的是当data2.txt开辟失败时，进行判断后，应先关闭文件data1.txt后置空。
int main()
{
//D:\clone仓库\test.c\test_3_26表示当前目录
//.表示当前目录
//..表示上一目录
FILE* pf1 = fopen("data1.txt", "r");//创建文件 打开文件
if (pf1 == NULL)
{
perror("fopen");
return 1;
}
FILE* pf2 = fopen("data2.txt", "w");
if (pf2 == NULL)
{
fclose(pf1);
pf1 = NULL;
perror("fopen->data2.txt");
return 1;
}
//写文件
int ch = 0;
while ((ch = fgetc(pf1)) != EOF)
{
fputc(ch, pf2);
}
//关闭文件
fclose(pf1);
fclose(pf2);
pf1 = NULL;
pf2 = NULL;
return 0;
}
fgets和fputs的使用
fputs一次写入一行
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
fputs("abcdefg\n", pf);
fputs("abcdefg\n", pf);
fputs("abcdefg\n", pf);
fclose(pf);
pf = NULL;
return 0;
}
fgets注意有三个参数，其中的num参数是最多读取多少个的意思，最多读取num-1个字符。
第一个参数是数组第二参数是num，第三个参数是文件指针，是把文件里的字符读取到数组中
这里data.txt是一堆字母，num是10，但一共读取了9个字符。
fscanf和fprintf的使用
读取带有格式化的字符
struct stu
{
char neme[30];
int age;
double score;
};
int main()
{
struct stu s = { "zhangsan", 29, 99.5 };
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fprintf(pf, "%s %d %.1lf", s.neme, s.age, s.score);
fclose(pf);
pf = NULL;
return 0;
}
注意使用fscanf和scanf一样要&（取地址）
这里创建了一个未初始化的s使用fscanf函数读取data.txt的内容读入s中，后用fprintf打印再屏幕上。
fread和fwrite的使用
二进制的读写
fwrite四个参数，第一个是要写数据的起始地址，第二个是一个元素的大小，第三个是写入的个数，第四个是流
再文件出现了乱码，这就是二进制翻译出的字符，不能识别
struct stu
{
char neme[30];
int age;
double score;
};
int main()
{
struct stu s = { "zhangsan", 19, 99.5 };
FILE* pf = fopen("data.txt", "wb");//二进制读写
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fwrite(&s, sizeof(s), 1, pf);//写到pf中
fclose(pf);
pf = NULL;
return 0;
}fread可以识别二进制的代码
struct stu
{
char neme[30];
int age;
double score;
}s;
int main()
{
//struct stu s = { "zhangsan", 19, 99.5 };
FILE* pf = fopen("data.txt", "rb");//二进制读写
if (pf == NULL)
{
perror("fopen");
return 1;
}
//fwrite(&s, sizeof(s), 1, pf);
//读文件
fread(&s, sizeof(s), 1, pf);//写到pf中
printf("%s %d %.1lf", s.neme, s.age, s.score);
fclose(pf);
pf = NULL;
return 0;
}比较一组函数
scanf/fscanf/sscanf
printf/fprintf/sprintf
前面已经介绍了fscanf和fprintf了，但这里还有一组函数，即sscanf和sprintf
scanf——针对标准输入流的格式化输入函数
printf——针对标准输出流的格式化输出函数
fscanf——针对所有输出流的的格式化输入函数
fprintf——针对所有输入流的格式化输出函数
sscanf
sscanf是从一个字符串中读取一个格式化的数据
sprintf
sprintf和printf都是使用格式化的数据，最大的差别在于sprintf多了一个参数
这个参数的作用是将格式化的数据转换成字符串。
使用
把一个结构体的格式化数据转换成字符串储存在了arr中，并输出到屏幕上。
struct stu
{
char name[39];
int age;
float score;
};
int main()
{
struct stu s = { "zhangsan", 38, 98.5 };
char arr[100] = { 0 };
sprintf(arr, "%s %d %lf", s.name, s.age, s.score);
printf("%s\n", arr);
return 0;
}
把字符串输入到新创建的结构体tmp中后将其格式化为结构体数据
struct stu
{
char name[39];
int age;
float score;
};
int main()
{
struct stu s = { "zhangsan", 38, 98.5 };
char arr[100] = { 0 };
struct stu tmp = { 0 };
sprintf(arr, "%s %d %f", s.name, s.age, s.score);
printf("%s\n", arr);
sscanf(arr, "%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
printf("%s, %d, %f", tmp.name, tmp.age, tmp.score);
return 0;
}
文件的随机读写
fseek
fseek 是 C 标准库中用于设置文件位置指针的函数，通常用于在文件中移动读写位置。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
int fseek(FILE *stream, long offset, int whence);
stream：指向FILE结构体的指针，表示要设置位置的文件流。offset：偏移量，指定相对于whence的移动距离。whence：基准点，指定相对位置的参考点，可以是SEEK_SET、SEEK_CUR或SEEK_END。
常用的 whence 参数取值如下：
SEEK_SET：从文件开头开始偏移。SEEK_CUR：从当前位置开始偏移。SEEK_END：从文件末尾开始偏移。
fseek 函数将文件位置指针移动到指定的位置，以便进行后续的读写操作。
ftell
ftell 是 C 标准库中用于获取文件位置指针当前位置的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
long ftell(FILE *stream);
stream：指向FILE结构体的指针，表示要获取位置的文件流。
ftell 函数返回当前文件位置指针相对于文件起始位置的偏移量（以字节为单位）。通常情况下，ftell 函数会返回一个 long 类型的值，表示当前位置的偏移量。
rewind
rewind 是 C 标准库中用于将文件位置指针重新定位到文件的起始位置的函数。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
void rewind(FILE *stream);
stream：指向FILE结构体的指针，表示要重新定位位置的文件流。
rewind 函数将文件位置指针移动到文件的起始位置，相当于使用 fseek(stream, 0L, SEEK_SET) 将文件位置指针移动到文件开头的操作。
使用部分
fseek的使用
SEEK_SET：从文件开头开始偏移。
SEEK_CUR：从当前位置开始偏移。
SEEK_END：从文件末尾开始偏移。
ftell的使用
根据ftell的特性，配合fseek可统计文件中的字符数。当然不止这一种，根据ftell函数的特性可开发除不同的用法。
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fputs("abcdefg", pf);
fclose(pf);
pf = fopen("data.txt", "r");
long size = 0;
int ch = 0;
fseek(pf, 0, SEEK_END);
ch = fgetc(pf);
size = ftell(pf);
printf("%ld bytes.\n", size);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
rewind的使用
int main()
{
FILE* pf = fopen("data.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fputs("abcdefg", pf);
fclose(pf);
pf = fopen("data.txt", "r");
int ch = fgetc(pf);
printf("%c\n", ch);
ch = fgetc(pf);
printf("%c\n", ch);
rewind(pf);
ch = fgetc(pf);
printf("%c\n", ch);
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
文件读取结束的判定
feof
在 C 标准库中，feof 函数用于检查文件流的结束标记，判断文件是否已经结束。它的原型定义在 <stdio.h> 头文件中，通常的函数原型如下：
int feof(FILE *stream);
stream：指向FILE结构体的指针，表示要检查是否到达文件结尾的文件流。
feof 函数检查给定文件流的结束标记。如果文件流的结束标记被设置，则 feof 返回非零值（即真），表示文件已经结束；否则返回 0（假），表示文件尚未结束。
注意：在文件读取的过程中不能用feof函数的返回值直接判定文件是否结束。
1.判断文本文件是否结束，判断返回值是否为EOF
2.二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
fread判断返回值是否小于实际要读的个数。
文本文件例子：
int main()
{
int c;//int，非char，要求处理EOF
FILE* pf = fopen("data.txt", "w");
if (!pf)
{
perror("fopen");
return EXIT_FAILURE;
}
while (c = fgetc(pf) != EOF)
{
putchar(c);
}
if (ferror(pf))
{
puts("I/O error when reading");
}
else if (feof(pf))
{
puts("End of file reached successfully");
}
fclose(pf);
return 0;
}二进制文件的例子：
#include <stdio.h>
enum { SIZE = 5 };
int main(void)
{
double a[SIZE] = { 1.,2.,3.,4.,5. };
FILE* fp = fopen("test.bin", "wb"); // 必须用二进制模式
fwrite(a, sizeof * a, SIZE, fp); // 写 double 的数组
fclose(fp);
double b[SIZE];
fp = fopen("test.bin", "rb");
size_t ret_code = fread(b, sizeof * b, SIZE, fp); // 读 double 的数组
if (ret_code == SIZE) {
puts("Array read successfully, contents: ");
for (int n = 0; n < SIZE; ++n) printf("%f ", b[n]);
putchar('\n');
}
else { // error handling
if (feof(fp))
printf("Error reading test.bin: unexpected end of file\n");
else if (ferror(fp)) {
perror("Error reading test.bin");
}
}
fclose(fp);
}
文件缓冲区
294
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
