C语言文件

1. 文件流

1.1. 文件流概念

C语言把文件看作是一个字符的序列,即文件是由一个一个字符组成的字符流,因此c语言将文件也称之为文件流。当读写一个文件时,可以不必关心文件的格式或结构

1.2. 文件类型

1.2.1. 文件分类

计算机的存储,物理上是二进制的。文本文件是基于字符编码的文件,常见的编码有ASCII编码,二进制文件是基于值编码的文件
文本文件:以ASCII码形式存放,一个字节存放一个字符存放每一个ASCII码。便于对字符串的逐个处理,但占用存储空间较多,而且花费时间转换
二进制文件:以值(补码)编码形式存放,把数据以二进制数的格式存放在文件中。占用存储空间较少,数据按其内存中的存储形式原样存放。

1.2.2. 图示代码展示

数据存入文件:short int a = 10000; // 0x2710
C语言文件_第1张图片
C语言文件_第2张图片

1.2.3. 乱码缘由

文本工具打开文件的过程:首先读取文件物理上对应的二进制比特流,然后按照所选的解码方式来解释这个流,将解释结果显示出来。一般的解码方式都是ASCII形式,接下来,每8个比特地来解释这个文件流
例如文件流01000000|01000001|01000010|01000011解码后就变成ABCD了
如果编码和解码不对应,就会乱码

1.3. 文件缓冲

要有缓冲区(buffer)的原因:

  • 从内存中读取数据比从文件中读取数据要快很多
  • 对文件的读写需要用到open、read、write等系统底层模块,而用户进程每调用一次,系统函数都要从用户态切换到内核态,等执行完毕后再返回用户态,这种切换要花费时间成本。
    C语言文件_第3张图片
    如果程序需要处理10k个整数,而这些整数事先存在某个文件中,如果程序每处理一个整数就要从文件中读取一个整数,那么每次都要进行硬件I/O、进程状态切换等操作,这样效率是非常低下的。如果每次从文件中读取1k个整数到内存,程序从内存中读取数据并处理,那么程序的性能就会提高,存储这1k个整数的内存区域就是一个缓冲区
int main()
{
  while (1)
  {
    printf("abcdef"); // 缓冲区满,会写入文件
    usleep(10000);
  }

  return 0; // 也可以通过fclose和fflush刷缓冲
}

2. 文件的打开和关闭

2.1. FILE结构体

FILE结构体是对缓冲区和文件读写状态的记录者,所有对文件的操作,都是通过FILE结构体完成的

typedef struct {
  short level; // 缓冲区满/空程度
  unsigned flags; // 文件状态标志
  char fd; // 文件描述符
  unsigned char hold; // 若无缓冲区不读取字符
  short bsize; // 缓冲区大小
  unsigned char *buffer; // 数据传送缓冲区位置
  unsigned char *curp; // 当前读写位置
  unsigned istemp; // 临时文件指示
  short token; // 用作无效检测
}FILE;

在开始执行程序时,将自动打开3个文件和相关的流:标准输入流(stdin)、标准输出流(stdout)、标准错误(stderr),他们都是FILE *型的指针流提供了文件和程序的

// 通过fopen打开一个文件,返回一个FILE *指针
// 以后所有对于文件的操作,即操作FILE *指针pf
// 句柄
int main()
{
  FILE *pf = fopen("test.txt", "r");
  return 0;
}

2.2. fopen

函数声明:FILE *fopen(const char * filename, const char * mode);
所在文件:stdio.h
函数功能:以mode的方式,打开一个filename命名的文件,返回一个指向该文件缓冲的FILE结构体指针
参数:char * filename:要打开,或是创建文件的路径;char * mode:打开文件的方式
返回值:FILE *:返回指向文件缓冲区的指针,该指针式后续操作文件的句柄

mode 处理方式 当文件不存在时 当文件存在时 向文件输入 从文件输出
“r” 读取 出错 打开文件 不能 可以
“w” 写入 建立新文件 覆盖原有文件 可以 不能
“a” 追加 建立新文件 在原有文件后追加 可以 不能
“r+” 读取/写入 出错 打开文件 可以 可以
“w+” 写入/读取 建立新文件 覆盖原有文件 可以 可以
“a+” 读取/追加 建立新文件 在原有文件后追加 可以 可以

如果读写的是二进制文件,则还要加b,比如rb,r+b等,unix/linux不区分文本和二进制文件

2.3. fclose

函数声明:int fclose(FILE * stream)
所在文件:stdio.h
函数功能:fclose()用来关闭先前fopen()打开的文件,此动作会让缓冲区内的数据写入文件中,并释放系统所提供的文件资源
参数:FILE * stream:指向文件缓冲的指针
返回值:int,成功返回0,失败返回EOF(-1)

int main()
{
  FILE *fp = fopen("data.txt", "w");
  fputc("china is great", fp);
  fclose(fp); // fflush(fp) // 设置断点调试
  return 0;
}

3. 一次读写一个字符(文本操作)

3.1. fputc

函数声明:int fputc(int ch, FILE * stream)
所在文件:stdio.h
函数功能:将ch字符,写入文件
参数:FILE * stream:指向文件缓冲的指针;int ch:需要写入的字符
返回值:int:写入成功,返回写入成功字符,如果失败,返回EOF

#define F_PRINT_ERR(e)        \
  do                          \
  {                           \
    if (e == NULL)            \
    {                         \
      printf("open error\n"); \
      exit(-1);               \
    }                         \
  } while (0)

int main()
{
  FILE *fp = fopen("xx.txt", "w+");
  F_PRINT_ERR(fp);
  for (int ch = 'a'; ch <= 'z'; ch++)
  {
    putchar(fputc(ch, fp));
  }
  fclose(fp);

  return 0;
}

3.2. fgetc

函数声明:int fgetc(FILE * stream)
所在文件:stdio.h
函数功能:从文件流中读取一个字符并返回
参数:FILE * stream:指向文件缓冲的指针
返回值:int:正常,返回读取的字符;读到文件尾或出错时,为EOF
读取字符的结束条件,通常是依据返回值。

int main()
{
  FILE *fp = fopen("main.c", "r");
  F_PRINT_ERR(fp);
  FILE *f = fopen("/Users/mingqi/Desktop/output.txt", "w+");
  F_PRINT_ERR(f);

  char ch;
  while ((ch = fgetc(fp)) != EOF)
  {
    putchar(ch);  // 打印字符到标准输出
    fputc(ch, f); // 将字符写入 f 文件
  }
  fclose(f);
  fclose(fp);
  return 0;
}

3.3. feof

函数声明:int feof(FILE * stream)
所在文件:stdio.h
函数功能:判断文件是否读到文件结尾
参数:FILE * stream:指向文件缓冲的指针
返回值:int,0未读到文件结尾,非零读到文件结尾
feof这个函数,是去读标志位判断文件是否结束的。即在读到文件结尾时再读一次,标志位才会置位,此时再来作判断文件处理结束状态,文件到结尾。如果用于打印,则会出现多打印一次的现象。

int main()
{
  FILE *fp = fopen("xx.txt", "w+");
  F_PRINT_ERR(fp);
  for (int ch = 'a'; ch <= 'z'; ch++)
  {
    putchar(fputc(ch, fp));
  }
  rewind(fp);

  printf("====\n");

  char ch;
  // feof检测文件结束标志,1结束,0未结束
  // 会导致多读一个字符,标志位检测置后
  /* while (!feof(fp))
  {
    ch = fgetc(fp);
    printf("%x -> %c\n", ch, ch);
  } */

  // 解决
  // ch = fgetc(fp);
  while ((ch = fgetc(fp)) && !feof(fp))
  {
    printf("%x -> %c\n", ch, ch);
    ch = fgetc(fp);
  }
  fclose(fp);
  return 0;
}

3.4. 练习

3.4.1. 实现linux中cp命令的功能

int main(int argc, char *argv[])
{
  if (argc < 3)
  {
    printf("Usage: %s src dest\n", argv[0]);
    return 0;
  }
  FILE *fp = fopen(argv[1], "r");
  if (fp == NULL)
    return -1;
  FILE *fp2 = fopen(argv[2], "w");
  if (fp2 == NULL)
  {
    fclose(fp2);
    return -1;
  }
  char ch;
  while ((ch = fgetc(fp)) != EOF)
  {
    fputc(ch, fp2);
    ch = fgetc(fp);
  }
  fclose(fp);
  fclose(fp2);
}

3.4.2. 文件的加密与解密

#define CODE 10
// 加密
int main()
{
  FILE *pfSrc = fopen("main.c", "r+");
  F_PRINT_ERR(pfSrc);

  FILE *pfDes = fopen("maincode.c", "w+");
  F_PRINT_ERR(pfDes);

  char ch;
  while ((ch = fgetc(pfSrc)) != EOF)
  {
    ch += CODE;
    fputc(ch, pfDes);
  }
  fclose(pfSrc);
  fclose(pfDes);
  return 0;
}
// 解密
int main()
{
  FILE *pfSrc = fopen("maincode.c", "r+");
  F_PRINT_ERR(pfSrc);

  FILE *pfDes = fopen("maindecode.c", "w+");
  F_PRINT_ERR(pfDes);

  char ch;
  while ((ch = fgetc(pfSrc)) != EOF)
  {
    ch -= CODE;
    fputc(ch, pfDes);
  }
  fclose(pfSrc);
  fclose(pfDes);
  return 0;
}

4. 一次读写一行字符(文本操作)

行在不同平台是有差异的,window平台’\r\n’,linux平台是’\n’;linux读windows中的换行,会多读一个字符,windows读linux中的换行,没有问题

4.1. fputs

函数声明:int fputs(char *str, FILE *fp)
所在声明:stdio.h
函数功能:把str指向的字符串写入fp指向的文件中
参数:char * str:指向的字符串的指针;FILE * fp:指向文件流结构的指针
返回值:int:正常,返0,出错,返EOF

int main()
{
  FILE *pf = fopen("xx.txt", "w");
  F_PRINT_ERR(pf);
  fputs("aaaaaa", pf);
  fputs("bbbbbb", pf);
  fputs("cccccc", pf);
  fclose(pf);
  return 0;
}

4.2. fgets

函数声明:char *fgets(char *str, int length, FILE *fp)
所在文件:stdio.h
函数功能:从fp所指向的文件中,至多读length-1个字符,送入字符数组str中,如果在读如length-1个字符结束前遇到\n或EPF,读入即结束,字符串读入后在最后加一个\0字符
fgets函数返回有三个条件:

  1. 读n-1个字符前遇到\n,读取结束(\n被读取)
  2. 读n-1个字符前遇到EOF,读取结束
  3. 读到n-1个字符

参数:char * str:指向需要读入数据的缓冲区;int length:每一次读数字符的字数;FILE * fp:文件流指针
返回值:char *:正常,返回str指针;出错或遇到文件结尾,返空指针NULL

按行读取,重点是判断结束条件,通常做法是依据返回值

// 在去读n-1个字符前遇到\n,连同\n一并读进来
// 在去读n-1个字符时,即没有遇到\n也没有EOF,此时就读到了n-1个字符,并在其后添加了\0
// 在去读n-1个字符时,即没有遇到\n,遇到EOF,并在其后添加了\0
int main()
{
  FILE *pf = fopen("xx.txt", "r");
  F_PRINT_ERR(pf);

  char buf[1024];
  fgets(buf, 2, pf);
  printf("buf = %s", buf);
  return 0;
}

4.3. feof

int main()
{
  FILE *pf = fopen("xx.txt", "w+");
  if (NULL == pf)
    exit(-1);

  fputs("aaaaaaaaa\n", pf);
  fputs("bbbbbbbbb\n", pf);
  fputs("ccccccccc\n", pf);
  fputs("ddddddddd", pf);

  rewind(pf);
  char buf[1024];
  // while (fgets(buf, 1024, pf) && !feof(pf))
  // {
  //   printf("%s", buf);
  // }

  while (fgets(buf, 1024, pf) != NULL)
  {
    printf("%s", buf);
  }
  return 0;
}

4.4. 注意事项

读到buf内的字符串,可含有空白格式控制字符,比如’\n’,‘\r\n’,'\t’等,如果直接用作比较等用途,可能得不到正确的结果

int main11()
{
  FILE *pf = fopen("xx.ini", "r+");
  if (NULL == pf)
    exit(-1);
  char name[1024];
  scanf("%s", name);
  char buf[1024];
  fgets(buf, 1024, pf);

  char *p = buf + strlen(buf) - 1; // 指向字符串的最后一个字符
  while (p >= buf && (*p == '\t' || *p == '\n' || *p == '\r'))
  { // 去掉末尾的制表符和换行符
    *p = '\0';
    p--;
  }

  if (strcmp(name, buf) == 0)
    printf("欢迎登录\n");
  else
    printf("登录失败\n");
  return 0;
}

4.5. 练习

4.5.1. 读取配置文件,过滤掉#

int main()
{
  FILE *pf = fopen("code.txt", "r+");
  if (NULL == pf)
    exit(-1);
  char buf[1024];
  FILE *pfbak = fopen("code.conf.bak", "w");
  if (NULL == pfbak)
  {
    fclose(pf);
    exit(-1);
  }
  while (fgets(buf, 1024, pf))
  {
    if (*buf == '#' || *buf == '\n' || *buf == ' ' || *buf == '\t')
      continue;
    printf("%s", buf);
    fputs(buf, pfbak);
  }
  fclose(pf);
  fclose(pfbak);
  return 0;
}

5. 一次读写一块字符(二进制操作)

所有的文件接口函数,都是以’\0’、‘\n’或EOF表示读取结束的。’\0’、'\n’都是文本文件的重要标识,而二进制文件,往往以块的形式写入或读出。而所有的二进制接口对于这些标识,是不敏感的

5.1. fwrite/fread

函数声明:int fwrite(void *buffer, int num_bytes, int count, FILE *fp)
int fread(void *buffer, int num_bytes, int count, FILE *fp)
所在文件:stdio.h
函数功能:把buffer指向的数据写入fp指向的文件中,或是把fp指向的文件中的数据读到buffer中
参数:char * buffer:指要输入/输出数据存储区的首地址的指针;int num_bytes:每个要读/写的字段的字节数;int count:要读/写的字段的个数;FILE *fp:要读/写的文件指针
返回值:int,成功,返回读/写的字段数;出错或文件结束,返回0

int main()
{
  char buf[1024] = "a\nbc\0defd";
  FILE *pfa = fopen("xx.txt", "w+");
  fputs(buf, pfa);

  char readArr[1024];
  rewind(pfa);
  fgets(readArr, 1024, pfa);
  printf("%s", readArr);

  fclose(pfa);

  FILE *pfb = fopen("yy.txt", "wb");
  fwrite((void *)buf, 1, 8, pfb);

  rewind(pfb);
  fread((void *)readArr, 1, 8, pfb);
  for (int i = 0; i < 8; i++)
  {
    printf("%x -> %c\n", readArr[i], readArr[i]);
  }

  fclose(pfb);
  return 0;
}

5.2. 试读文本文件

试图用fread读取文本文件的时候,发现文本中的格式已经没有意义了,只是一个普通的字符
C语言文件_第4张图片

5.2.1. 写特殊字符进文件

int main()
{
  FILE *fpw = fopen("bin.txt", "wb");
  if (fpw == NULL)
    exit(-1);
  char *p = "china \n is \0 great";
  fwrite(p, 1, strlen(p) + 6, fpw);
  fclose(fpw);
  return 0;
}

5.2.2. 从文件中读特殊字符

int main()
{
  FILE *fpr = fopen("bin.txt", "rb");
  if (fpr == NULL)
    exit(-1);
  char buf[1024];
  int n;
  n = fread(buf, 1, 1024, fpr);
  printf("n = %d\n", n);
  for (int i = 0; i < n; i++)
  {
    printf("%#x\n", buf[i]);
  }
  fclose(fpr);
  return 0;
}

5.2.3. 返回值陷阱

没有\n/EOF/len-1作为读出的结束标志,fread依靠读出块多少来标识读结果和文件结束标志。
以最小的单元格式进行读,或是以写入的最小单元进行读。

int main()
{
  char buf[1024] = "12345678";
  FILE *pf = fopen("bin.txt", "w+");
  if (NULL == pf)
    exit(-1);
  // fwrite((void *)buf, 1, 8, pf);
  fwrite((void *)buf, 8, 1, pf);

  rewind(pf);

  char read[10];
  // 读到完整块的个数
  int n;
  // n = fread((void *)read, 1, 8, pf); // n = 8
  // printf("n = %d\n", n);
  // n = fread((void *)read, 1, 8, pf); // n = 0
  // printf("n = %d\n", n);

  // n = fread((void *)read, 8, 1, pf); // n = 1
  // printf("n = %d\n", n);
  // n = fread((void *)read, 8, 1, pf); // n = 0
  // printf("n = %d\n", n);

  // n = fread((void *)read, 7, 1, pf); // n = 1
  // printf("n = %d\n", n);
  // n = fread((void *)read, 7, 1, pf); // n = 0
  // printf("n = %d\n", n);

  // n = fread((void *)read, 3, 1, pf); // n = 1
  // printf("n = %d\n", n);
  // n = fread((void *)read, 3, 1, pf); // n = 1
  // printf("n = %d\n", n);
  // n = fread((void *)read, 3, 1, pf); // n = 1
  // printf("n = %d\n", n);

  // n = fread((void *)read, 1, 3, pf); // n = 3
  // printf("n = %d\n", n);
  // n = fread((void *)read, 1, 3, pf); // n = 3
  // printf("n = %d\n", n);
  // n = fread((void *)read, 1, 3, pf); // n = 2
  // printf("n = %d\n", n);
  // n = fread((void *)read, 1, 3, pf); // n = 0
  // printf("n = %d\n", n);

  while ((n = fread((void *)read, 1, 3, pf)) > 0)
  {
    for (int i = 0; i < n; i++)
    {
      printf("%c", read[i]);
    }
  }

  fclose(pf);
  return 0;
}

5.3. 二进制读写才是本质

当用UE打开一个二进制文件(图片,视频)时,发现文件中到处都是文本的标志性字符,但是对于fread和fwrite来说,都是一个普通的字节;所以二进制文件的读写就要用对文本标记不敏感的fread和fwrite来进行

int main()
{
  int a[10] = {0xff, 0x0, 10, 2, 3, 4, 5, 6, 7, 8};
  FILE *fp = fopen("xx.txt", "wb+"); // xx.txt文件打开是乱码
  if (fp == NULL)
    return -1;
  fwrite(a, sizeof(int[10]), 1, fp);
  rewind(fp);
  int n = 0;
  int data;
  while ((n = fread(&data, sizeof(int), 1, fp)) > 0)
  {
    printf("n = %d data = %x \n", n, data);
  }
  fclose(fp);
  return 0;
}

5.3.1. 文件的加密与解密

加密语法格式

file -d src.wmv sec.wmv
file -x sec.wmc anohtersrc.wmv
// xx.ext -c src dest
// xx.exe -d src dest
// argv[0] argv[1] argv[2] argv[3]
void encode(char *buf, int n)
{
  for (int i = 0; i < n; i++)
  {
    buf[i]++;
  }
}
void decode(char *buf, int n)
{
  for (int i = 0; i < n; i++)
  {
    buf[i]--;
  }
}
int main(int argc, char *argv[])
{
  if (argc != 4)
  {
    printf("use xx.exe -d[-c] src dest\n");
    exit(-1);
  }
  FILE *pfr = fopen(argv[2], "rb+");
  if (pfr == NULL)
    exit(-1);
  FILE *pfw = fopen(argv[3], "wb+");
  if (pfw == NULL)
  {
    fclose(pfr);
    exit(-1);
  }

  int buf[1024];
  int n;
  // 加密
  if (strcmp(argv[1], "-c") == 0)
  {
    while ((n = fread((void *)buf, 1, 1024, pfr)) > 0)
    {
      encode(buf, n);
      fwrite((void *)buf, 1, n, pfw);
    }
  }
  // 解密
  else if (strcmp(argv[1], "-d") == 0)
  {
    while ((n = fread((void *)buf, 1, 1024, pfr)) > 0)
    {
      decode(buf, n);
      fwrite((void *)buf, 1, n, pfw);
    }
  }
  else
  {
    printf("arg error\n");
  }
  fclose(pfr);
  fclose(pfw);
  return 0;
}

5.4. 读写结构是长项

结构体中的数据类型不统一,此时最时候用二进制的方式进行读写。二进制的接口可以读文本,而文本的接口不可以读二进制

// 结构体会采用fread/fwrite来写
// 1. 类型不同意
// 2. 可以将二进制转化为文本,使其统一,降低效率,占用多余的存储空间
typedef struct student
{
  int num;
  char name[30];
  char sex;
  float math;
  float english;
  float chinese;
} Stu;
// 写
int main22()
{
  Stu s[3] = {
      {1001, "wukong", 'x', 99, 99, 99},
      {1002, "songjiang", 'x', 66, 44, 88},
      {1003, "baoyu", 'x', 22, 66, 88},
  };
  FILE *pfs = fopen("stu.data", "w+");
  if (pfs == NULL)
    exit(-1);
  for (int i = 0; i < 3; i++)
  {
    fwrite((void *)&s[i], sizeof(Stu), 1, pfs);
  }
  fclose(pfs);

  return 0;
}
int main()
{
  FILE *pfw = fopen("stu.data", "r+");
  if (pfw == NULL)
    exit(-1);
  Stu s[3];
  int n;
  while (n = fread((void *)s, sizeof(Stu), 1, pfw) > 0) // 3 2 0
  {
    for (int i = 0; i < n; i++)
    {
      printf("num = %d\n", s[i].num);
      printf("name = %s\n", s[i].name);
      printf("sex = %c\n", s[i].sex);
      printf("math = %.2f\n", s[i].math);
      printf("english = %.2f\n", s[i].english);
      printf("chinese = %.2f\n", s[i].chinese);
      printf("======\n");
    }
  }

  return 0;
}

5.5. 练习-管理系统

将链表作为内存数据模型,将文件作为数据库,将终端作为交互界面,读文件生成链表,修改链表写入文件。

5.5.1. 初始化数据库

typedef struct student
{
  char name[30];
  char sex;
  int age;
  float score;
} Stu;
typedef struct _StuNode
{
  Stu data;
  struct _StuNode *next;
} StuNode;
void initData2File() {
  Stu s[4] = {
      {"liudehua", 'x', 50, 100},
      {"zhangxueyou", 'x', 60, 90},
      {"liming", 'x', 40, 80},
      {"guofucheng", 'x', 60, 95},
  };
  FILE *pf = fopen("stu.data", "w+");
  if (NULL == pf)
    exit(-1);
  fwrite((void *)s, sizeof(s), 1, pf);
  fclose(pf);
  return;
}

这个函数将初始化一个学生数据的数组,并将其写入一个名为 stu.data 的文件中。如果文件打开失败,程序将退出。

5.5.2. 读数据库,生成内存数据模型,链表

StuNode *createListFromFile(char *filePath) {
  FILE *pf = fopen(filePath, "r+");
  if (NULL == pf)
    exit(-1);
  StuNode *head = (StuNode *)malloc(sizeof(StuNode));
  head->next = NULL;

  StuNode *cur = (StuNode *)malloc(sizeof(StuNode));
  while (fread((void *)&cur->data, sizeof(Stu), 1, pf)) {
    cur->next = head->next;
    head->next = cur;
    cur = (StuNode *)malloc(sizeof(StuNode));
  }
  free(cur);
  return head;
}

指定文件中读取学生数据,并将其转换为链表形式。读取每个学生数据时,创建一个新的链表节点并插入到链表头部

5.5.3. 遍历链表

void traverseStuList(StuNode *head) {
  printf("\t\t\t Student Management System\n\n");
  printf("\tname\t\t\tsex\t\tage\t\tscore\n");
  head = head->next;
  while (head) {
    printf("\t%-10s\t\t%c\t\t%d\t\t%.2f\t\t\n", head->data.name, head->data.sex, head->data.age, head->data.score);
    head = head->next;
  }
  putchar(10);
}

5.5.4. 添加学生节点

void addListStu(StuNode *head) {
  StuNode *cur = (StuNode *)malloc(sizeof(StuNode));
  printf("name:");
  scanf("%s", cur->data.name);
  getchar();
  printf("sex:");
  scanf("%c", &cur->data.sex);
  getchar();
  printf("age:");
  scanf("%d", &cur->data.age);
  getchar();
  printf("score:");
  scanf("%f", &cur->data.score);
  cur->next = head->next;
  head->next = cur;
}

创建一个新的学生节点并将其插入到链表头部。

5.5.5. 查找学生

StuNode *searchListStu(StuNode *head) {
  char name[30];
  printf("pls input your search name:");
  scanf("%s", name);
  head = head->next;
  while (head) {
    if (strcmp(head->data.name, name) == 0)
      break;
    head = head->next;
  }
  return head;
}

根据学生姓名在链表中查找学生并返回对应的节点。

5.5.6. 删除学生节点

void deleteListStu(StuNode *head) {
  StuNode *pfind = searchListStu(head);
  if (pfind == NULL) {
    printf("删除的不存在");
    getchar();
    getchar();
    return;
  }
  while (head->next != pfind)
    head = head->next;
  head->next = pfind->next;
  free(pfind);
  return;
}

首先查找要删除的学生节点,然后从链表中删除该节点并释放其内存。

5.5.7. 链表长度

int lenListStu(StuNode *head) {
  int len = 0;
  head = head->next;
  while (head) {
    len++;
    head = head->next;
  }
  return len;
}

5.5.8. 排序链表

void sortListStu(StuNode *head) {
  int len = lenListStu(head);
  StuNode *prep, *p, *q;
  for (int i = 0; i < len - 1; i++) {
    prep = head;
    p = prep->next;
    q = p->next;
    for (int j = 0; j < len - 1 - i; j++) {
      if (strcmp(p->data.name, q->data.name) > 0) {
        prep->next = q;
        p->next = q->next;
        q->next = p;

        prep = q;
        q = p->next;
        continue;
      }
      prep = prep->next;
      p = p->next;
      q = p->next;
    }
  }
}

5.5.9. 将链表保存到文件

void saveList2File(StuNode *head, char *filePath) {
  FILE *pf = fopen(filePath, "w+");
  if (pf == NULL)
    exit(-1);
  head = head->next;
  while (head) {
    fwrite((void *)&head->data, sizeof(Stu), 1, pf);
    head = head->next;
  }
  fclose(pf);
}

5.5.10. 销毁链表

void destroyListStu(StuNode *head) {
  StuNode *t;
  while (head) {
    t = head;
    head = head->next;
    free(t);
  }
}

5.5.11. 主函数

void main() {
  // initData2File();
  StuNode *head = createListFromFile("stu.data");

  while (1) {
    system("cls");
    traverseStuList(head);
    printf("1->add\t 2->search\t 3->delete\t 4->exit\n");
    int choice;
    StuNode *pfind;
    scanf("%d", &choice);
    switch (choice) {
    case 1:
      addListStu(head);
      break;
    case 2:
      if (pfind = searchListStu(head)) {
        printf("能找到");
        printf("\t%-10s\t\t%c\t\t%d\t\t%.2f\t\t\n", pfind->data.name, pfind->data.sex, pfind->data.age, pfind->data.score);
      } else {
        printf("找不到");
      }
      getchar();
      getchar();
      break;
    case 3:
      deleteListStu(head);
      break;
    case 4:
      sortListStu(head);
      break;
    case 5:
      saveList2File(head, "stu.data");
      destroyListStu(head);
      return;
    default:
      printf("输入有误");
    }
  }
}

6. 文件指针偏移

6.1. rewind

函数声明:void rewind(FILE * stream)
所在文件:stdio.h
函数功能:将文件指针重新指向一个流的开头
参数:FILE *:流文件句柄
返回值:void:无返回值
如果一个文件具有读写属性,当写完文件需要读的时候,会遇到文件结尾的现象,此时就需要rewind

6.2. ftell

函数声明:long ftell(FILE * stream)
所在文件:stdio.h
函数功能:得到流式文件的当前读写位置,其返回值是当前读写位置偏离文件头部的字节数
参数:FILE *:流文件句柄
返回值:int:成功,返回当前读写位置偏离文件头部的字节数。失败,返回-1

6.3. fseek

函数声明:int fseek(FILE * stream, long offset, int where);
所在文件:stdio.h
函数功能:偏移文件指针
参数:FILE * stream:文件句柄;long offset:偏移量;int where:偏移起始位置
返回值:int:成功返回0,失败返回-1
常见的起始位置有宏定义:

#define SEEK_CUR 1 当前位置
#define SEEK_END 2 文件结尾
#define SEEK_SET 0 文件开头
fseek(fp, 100L, 0); // 把fp指针移动到离文件开头100字节处
fseek(fp, 100L, 1); // 把fp指针移动到离文件当前位置100字节处
fseek(fp, 100L, 2); // 把fp指针退回到离文件结尾100字节处
int main()
{
  FILE *pf = fopen("xx.txt", "w+");
  fputs("abcdefg", pf);
  int n = ftell(pf);
  printf("n = %d\n", n); // n = 7

  rewind(pf);
  n = ftell(pf);
  printf("n = %d\n", n); // n = 0

  fseek(pf, 0, SEEK_END);
  n = ftell(pf);
  printf("n = %d\n", n); // n = 7

  fseek(pf, 0, SEEK_SET);
  n = ftell(pf);
  printf("n = %d\n", n); // n = 0

  fseek(pf, 1, SEEK_CUR);
  n = ftell(pf);
  printf("n = %d\n", n); // n = 1
  return 0;
}

你可能感兴趣的:(c语言,开发语言)