C语言自定义类型与文件操作

构造类型

枚举类型

若定义不相关的常量使用宏定义；若定义一组相关的常量使用枚举。switch中case后访问的就是枚举。

• 定义：

  我们一般情况下定义常量使用宏定义(#define)，宏定义适合没有关联关系的常量；但有时需要对一组有关联关系的量进行定义，例如：星期、月份、方向(上下左右中)等，若使用宏定义，可读性差，这时使用枚举。

• 说明

  • 枚举类型定义了一组常量，我们在开发中直接使用这些常量。
  • 枚举类型也可以类似结构体一样定义变量操作 (不常用)
  • 枚举有默认值，从0开始依次+1；同时也可以指定它的默认值，后续的依次根据赋值+1

• 特点：

  定义一组常量，类似于定义了多个自定义常量(宏定义)

  提供了代码的可读性

• 语法

//定义枚举类型名以后可以定义该枚举类型的变量
enum 枚举类型名 变量列表;//定义枚举类型的同时定义该枚举类型的变量
enum 枚举类型名{枚举元素列表} 变量列表;//直接定义枚举变量
enum {枚举元素列表} 变量列表;enum Week
{//定义枚举元素SUN = 10,MON,TUE,WED,THU,FRI,SAT
};//访问枚举元素
printf("%d,%d,%d\n",SUN,WED,SAT);//定义枚举类型变量(先定义，后赋值)
enum Week week;
//初始化
week = TUE;//定义枚举变量同时赋值
enum Week week1 =THU;

typedef

• 说明：给类型重命名，不会影响类型本身

• 作用：给已有的类型起别名

• 格式：

  //先定义结构体类型，再重命名
  typedef 已有类型名 新别名;
  struct Student
  {int id;char name[20];char sex;
  };//类型重命名
  typedef struct Student Stu;//定义结构体变量
  struct Stu stu = {1,"张三"，'M'};//定义结构体的同时重命名
  typedef struct PersonInfo
  {int a;double b;
  } Per;//结构体的别名，本质上还是数据类型struct Per per = {1,5};
  

• 应用场景：

  • 数据类型复杂(结构体、共用体、枚举、结构体指针、无符号长整形)时使用
  • 为了跨平台兼容如：
    1. size_t：类型重命名后数据类型：typedef unsigned long size_t
    2. unit_16:类型重名后数据类型

文件操作

概述

• 什么是文件

  文件是保存在外存储器(U盘，移动硬盘)的数据的集合。

• 文件操作体现在哪几个方面

  1. 文件内容的读取
  2. 文件内容的写入

  数据的读取和写入可被视为针对文件进行输入(Input)和输出(Output)操作，此时数据像水流一样从外存储器流向内存。或者从内存流向外存储器，所以系统形象的称文件操作为文件流。

  C语言程序对文件的操作采用"文件缓存机制"。就是说在程序对文件的数据读写并不是直接操作文件中的数据，而是系统会为文件在内存中创建"文件缓冲区"，程序对文件的操作，其实是在缓冲区进行。

• 文件的分类

  • 根据数据的存储方式划分
    1. 文本文件(ASCII文件)
    2. 二进制文件

• 文件的标识

  • 文件系统中：路径+文件名 例如：E:\YQ\code\Homework\20241217
  • C语言程序中：文件指针(文件类型指针)，语法：FILE* 指针变量名

• 文件操作的步骤：

  1. 打开文件
  2. 文件处理(读写文件)
  3. 关闭文件

文件的操作

文件的打开与关闭

打开文件

打开文件，让系统为文件创建文件缓冲区

• 函数名：fopen()

• 头文件：#inculde <stdio.h>

• 函数原型：FILE* fopen(const char *path,const char *mode);

• 函数功能：打开文件，并为文件创建缓冲区

• 形参

  • path：目标文件的路径

  • mode：文件打开的方式(r-读、w-写、re-读写)

  type	读写性	文本/进制文件	新建/打开
  r	读	文本	打开文件
  w	写	文本	新建文件
  a	添加	文本	有就打开无则建新
  r+	读写	无限制	打开
  w+	读写	无限制	建新文件
  a+	读写添加	无限制	有就打开无则建新

• 返回值

  • 成功：返回文件指针FILE*(缓冲区首地址)
  • 失败：返回NULL

关闭文件

文件关闭，文件使用完毕，一定要释放内存

• 函数名：fclose()
• 头文件：#inculde <stdio.h>
• 函数原型：int fclose(FILE* fp);
• 函数功能：
  • fp已经打开的文件指针
• 返回值
  • 成功：返回0
  • 失败：返回EOF(-1)

文件打开与关闭案例

#include <stdio.h>int main(int argc, char *argv[])
{// 在命令行执行./a.out的时候，传递一个需要打开的目录文件的地址if (argc < 2){printf("输入有误，请按照<%s文件路径>格式输入\n", argv[0]);return -1;}// 根据文件路径打开文件FILE *fp = fopen(argv[1], "r");// 校验文件是否读取成功if (!fp){perror("文件打开失败!");return -1;}puts("文件打开成功!\n");int ret = fclose(fp);if (ret == -1)perror("文件关闭失败");puts("文件关闭成功");return 0;
}

文件的顺序读写

单字符读取

• 函数名：fgetc
• 头文件：#inculde <stdio.h>
• 函数原型：int fgetc(FILE* fp);
• 函数功能：从fp代表的文件中获取一个字符
• 形参
  • fp：我们操作的文件指针
• 返回值
  • 成功：返回读取的字符
  • 失败：或者文件末尾，返回EOF(-1)

方式一（ASCII码）

#include <stdio.h>int main(int argc, char *argv[])
{// 在命令行执行./a.out的时候，传递一个需要打开的目录文件的地址if (argc < 2){printf("输入有误，请按照<%s文件路径>格式输入\n", argv[0]);return -1;}// 根据文件路径打开文件FILE *fp = fopen(argv[1], "r");// 校验文件是否读取成功if (!fp){perror("文件打开失败!");return -1;}char re = 0;// 循环读取文件中所有字符while ((re = fgetc(fp)) != -1){printf("%c", re);}puts("文件打开成功!\n");int ret = fclose(fp);if (ret == -1)perror("文件关闭失败");puts("文件关闭成功");return 0;
}

方式二（ASCII值）

#include <stdio.h>int main(int argc, char *argv[])
{// 在命令行执行./a.out的时候，传递一个需要打开的目录文件的地址if (argc < 2){printf("输入有误，请按照<%s文件路径>格式输入\n", argv[0]);return -1;}// 根据文件路径打开文件FILE *fp = fopen(argv[1], "r");// 校验文件是否读取成功if (!fp){perror("文件打开失败!");return -1;}int re = 0;// 循环读取文件中所有字符while ((re = fgetc(fp)) != EOF){printf("%c", re);}puts("文件打开成功!\n");int ret = fclose(fp);if (ret == -1)perror("文件关闭失败");puts("文件关闭成功");return 0;
}

多字符读取

• 函数名：fgets（）
• 头文件：#inculde <stdio.h>
• 函数原型：char *fgets(char *buf,int size,FILE *fp)
• 函数功能：从fp代表的文件中获取size个字符(size大小以字节为单位)，放置在buf代表的内存中
• 形参
  • buf：内存空间首地址用于存放读取的字节
  • size：待读取的字符，实际读取size
  • fp：已经打开文件指针
• 返回值
  • 成功：返回buf
  • 失败：或者文件末尾，返回NULL

案例：

#include <stdio.h>
#include <string.h>int main(int argc, char *argv[])
{// 在命令行执行./a.out的时候，传递一个需要打开的目录文件的地址if (argc < 2){printf("输入有误，请按照<%s文件路径>格式输入\n", argv[0]);return -1;}// 根据文件路径打开文件FILE *fp = fopen(argv[1], "r");// 校验文件是否读取成功if (!fp){perror("文件打开失败!");return -1;}char ch[64] = {0};// 循环读取文件中所有字符while (fgets(ch, 64, fp) != NULL){printf("%s", ch);memset(ch, 0, sizeof(ch));}puts("文件打开成功!\n");int ret = fclose(fp);if (ret == -1)perror("文件关闭失败");puts("文件关闭成功");return 0;
}

单字符写入

• 函数名：fputc()；
• 头文件：#inculde <stdio.h>
• 函数原型： int fputc(int c,FILE* fp);
• 函数功能：想fp代表的文件中写入一个字符
• 形参
  • int c：待写入的字符
  • fp：已打开文件指针
• 返回值
  • 成功：返回字符c
  • 失败：返回EOF(-1)

#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{// 在命令行执行./a.out的时候，传递一个需要打开的目录文件的地址if (argc < 3){printf("输入有误，请按照<%s 文件路径 文本数据>格式输入\n", argv[0]); // ./a.out./ demo01.c hello return -1;}// 根据提供的文件路径，打开文件(mode:r,w,rw)FILE *fp = fopen(argv[1], "w");// 校验文件是否读取成功if (!fp){perror("文件打开失败！\n");return -1;}puts("文件打开成功！");// 单字符写入// 借助循环，一个字符一个字符写入while (*argv[2] != '\0'){fputc(*argv[2], fp); //argv[2]++;           // 指针偏移}// 关闭打开的文件int ret = fclose(fp);if (ret == -1){perror("文件关闭失败！");return -1;}puts("文件关闭成功！");return 0;
}

多字符写入

• 函数名：fputs()；
• 头文件：#inculde <stdio.h>
• 函数原型： int fputs(const char* buf,FILE* fp);
• 函数功能：想fp代表的文件中写入多个字符
• 形参
  • buf：待写入的字符数组
  • fp：已打开文件指针
• 返回值
  • 成功：返回非负整数>0
  • 失败：返回EOF(-1)

/*** 多字符写入*/
#include <stdio.h>
int main(int argc, char **argv)
{if (argc < 3){printf("输入有误，请按照<%s 文件路径 文本数据>格式输入\n", argv[0]);return -1;}FILE *fp = fopen(argv[1], "w");if (!fp){perror("文件打开失败！");return -1;}// 单字符写入// ./a.out file1.txt I_Love_Yourfputs(argv[2], fp);fclose(fp);return 0;
}

文件拷贝

#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{// 在命令行执行./a.out的时候，传递一个需要打开的目录文件的地址if (argc < 2){printf("输入有误，请按照<%s 被读文件路径 被写文件路径>格式输入\n", argv[0]); // ./a.out./ demo01.c return -1;}// 根据提供的文件路径，打开文件(mode:r,w,rw)FILE *fp_r = fopen(argv[1], "r");FILE *fp_w = fopen(argv[2], "w");// 校验文件是否读取成功if (!fp_r || !fp_w){perror("文件打开失败！\n");return -1;}puts("文件打开成功！");// 创建一个缓冲区（也就是每次读取字节的大小）char buf[64] = {0};// 循环读取文件中所有字符while (fgets(buf, 64, fp_r) != NULL){// 写入文件fputs(buf, fp_w);// 每读取一次，都需要清空缓冲区memset(buf, 0, sizeof(buf));}// 关闭打开的文件int ret1 = fclose(fp_r);int ret2 = fclose(fp_w);if (ret1 == -1 || ret2 == -1){perror("文件关闭失败！");return -1;}puts("文件关闭成功！");return 0;
}

判别文件结束

• 函数名：feof(fp)
• 头文件：#inculde <stdio.h>
• 函数原型：int feof(FILE* fp);
• 函数功能：在读fp指向的文件时判断是否遇到文件结束
• 形参
  • fp：已打开的文件指针
• 返回值
  • 文件未读取完毕：返回0
  • 文件已读取完毕：返回非0

数据块的读写

数据块的读取(二进制)

• 函数名：fread

• 函数原型：size_t fread(void *ptr,size_t size,size_t count,FILE *fp);

• 函数功能：从fp指向的文件中以字节为单位(一个数据块)读取count个数据块存放在内存中

• 形参

  • ptr：内存空间首地址，用于存放读取的数据
  • size：数据块大小，以字节为单位
  • count：待读取的数据块的个数
  • fp：已打开的文件指针

• 返回值

  • 成功：返回实际读取的字节数大小
  • 失败：读取完毕返回<0

  #include <stdio.h>
  #define SIZE 2struct Student
  {char name[20];int num;int age;char address[50];
  } stus[SIZE];/*保存学生信息到文件
  */int save()
  {FILE *fp;int i;if ((fp = fopen("stu", "wb")) == NULL) // stu保存文件的名称{perror("文件打开失败!");return -1;}// 写入数据for (i = 0; i < SIZE; i++){fwrite(&stus[i], sizeof(struct Student), 1, fp);}// 关闭文件fclose(fp);return 0;
  }int main()
  {int i;printf("请输入学生的信息:姓名、学号、年龄、住址\n");for (i = 0; i < SIZE; i++){scanf("%s%d%d%s", stus[i].name, &stus[i].num, &stus[i].age, stus[i].address);// 保存文件}save();return 0;
  }
  

数据块的写入

• 函数名：fwrite
• 函数原型：size_t fwrite(const void *ptr,size_t size,size_t count,FILE *fp);
• 函数功能：向fp指向的文件中以字节为单位(一个数据块)写入count个数据块到fp
• 形参
  • ptr：内存空间首地址，用于存放写入的数据
  • size：数据块大小，以字节为单位
  • count：待写入的数据块的个数
  • fp：已打开的文件指针
• 返回值
  • 成功：返回实际写入的字节数大小
  • 失败：写入完毕返回<0

#include <stdio.h>
#define SIZE 2 // 存放学生的个数
// 创建学生结构体
struct Student
{char name[20];int num;int age;char addr[50];
} stus[SIZE];
int main(int argc, char *argv[])
{int i;FILE *fp;if ((fp = fopen("stu", "rb")) == NULL) // rb 以二进制读取{perror("文件打开失败！");return -1;}// 循环读取二进制读取for (i = 0; i < SIZE; i++){fread(&stus[i], sizeof(struct Student), 1, fp);// 将读取的数据输出到控制台printf("%-10s%-4d%-4d%-20s\n", stus[i].name, stus[i].num, stus[i].age, stus[i].addr);}// 关闭文件fclose(fp);return 0;
}

文件的随机读写

说明：C语言允许在读写文件内容时，可在指定位置上读写数据

文件随机读写的核心操作：文件位置指针的定位

文件位置指针移动方法：

1. rewind

   • 头文件：#include <stdio.h>
   • 函数原型：void rewind(FILE *fp);
   • 函数功能：将文件位置指针定位到文件开头
   • 形参：
     • fp：已经打开文件的指针
   • 返回值：空类型

   #include <stdio.h>/*有一个磁盘文件第一次将他内容通过控制台输出第二次将其复制到另一个文件
   */int main()
   {// 创建两个指针，用来接收打开的文件FILE *fp1, *fp2;// 校验if (!fp1 && !fp2){perror("文件打开失败!");return -1;}puts("文件打开成功!\n");// 打开文件fp1 = fopen("1.txt", "r");fp2 = fopen("2.txt", "w");// 第一次，读取文件内容通过控制台打印while (!feof(fp1)) // feof函数检测文件是否读完{putchar(getc(fp1));}rewind(fp1);// 第二次，读取文件内容将其拷贝至2.txtwhile (!feof(fp1)){putc(getc(fp1), fp2);}fclose(fp1);fclose(fp2);return 0;
   }
   

2. fseek

   • 头文件：#include <stdio.h>

   • 函数原型： int fseek(File *fp,long offset,int whence);

   • 函数功能：将文件位置指针定位到指定位置

   • 形参

     • fp：已打开的文件的指针

     • offset：相对参考位置的偏移量

     • whence：参考位置

       • SEEK_SET或0：表示文件头

       • SEEK_CUR或1：表示当前读写位置

       • SEEK_END或2：表示文件尾

   • 返回值：

     • 成功：0

     • 失败：-1

   #include <stdio.h>
   #include <stdlib.h>/*在磁盘文件上存储10个学生的数据要求1，3，5，7，9这五个学生信息输入计算机，并显示
   */// 定义学生结构体
   struct Student
   {char name[20];int id;char sex;
   };typedef struct Student Stu;Stu stus[3] = {0};int main()
   {FILE *fp = NULL;int len = sizeof(stus) / sizeof(stus[0]);printf("%d", len);// 写入数据if ((fp = fopen("stu", "wb")) == NULL) // stu保存文件的名称{perror("文件打开失败!");return -1;}printf("请输入学生的信息:姓名、学号、性别\n");for (int i = 0; i < len; i++){scanf("%s%d %c", stus[i].name, &stus[i].id, &stus[i].sex);}fwrite(stus, sizeof(Stu), len, fp);fclose(fp); // 关闭文件// 打开文件if ((fp = fopen("stu", "rb")) == NULL){perror("文件打开失败!");return -1;}for (int i = 0; i < len; i += 2){// 跳过文件位置，改变文件指针的指向fseek(fp, i * sizeof(Stu), 0);fread(&stus[i], sizeof(Stu), 1, fp);printf("%s %d %c\n", stus[i].name, stus[i].id, stus[i].sex);}fclose(fp);return 0;
   }
   

3. ftell

   • 头文件#include <stdio.h>
   • 函数原型：long ftell(FILE* fp);
   • 函数功能：获取文件指针当前位置
   • 形参
     • fp：已打开文件的指针
   • 返回值
     • 成功：文件位置指针的当前位置
     • 失败：-1

#include <stdio.h>
int main(int argc, char *argv[])
{long p;FILE *fp;if ((fp = fopen(argv[1], "a")) == NULL) // 此时的mode：a代表追加（a是append）{perror("文件打开失败！");return -1;}// 获取当前位置p = ftell(fp);printf("p=%ld\n", p);// 向文件添加数据fputs("data", fp);p = ftell(fp);printf("p=%ld\n", p);fclose(fp);return 0;
}