文件处理

语法

文件指针被typedef新创建的类型

typedef struct
{
  short level;
  .......
}FILE;

打开与关闭

C

fopen 打开文件

打开就是创建一个流steann

文件的使用打开格式在P368

FILE *fopen(const char *文件的名字, const char *文件打开的方式)

例如

fp = fopen ("D:/Asm/file.txt", "w+");

路径是这个斜杠​​/​​

一些出现的英文意思

a: append

e: read

w: write

b: binary

二进制的形式打开和写入是针对于所有的文件格式….,好比​​.exe...​​

但是对于txt的文件,你可以用二进制的形式操作,,我们一般用文本的形式操作

fclose()关闭文件

文件的打开与关闭就像是水龙头

开了就要关闭..这是为了防止数据的流失

int fclose( FILE *file_ptr );

失败的原因

1. 路径无效
2. 文件名无效字符串
3. 用r的形式打开一个不存在的文件

if(fclose(fp)==EOF)
      puts("failed close");

freopen 把文件与stream互动

还不会把一个文件的东西追加到另外一个文件

输入可以用其它方式

把一个文件的东西读取到一个数组

然后把这个数组的东西写入另外一个文件中

#include <stdio.h>

int main ()
{
   FILE *fp;

   
   puts("hello");
       
   fp = freopen("d:/1.txt", "w+", stdout);
   
   printf("我是stdout,我要被写入文件\n");
   puts("123456789"); 
   fclose(fp);
   
   return(0);
}

这个代码可以实现把屏幕上提前就打印的东西写入到文件中

C++

文件流的数据类型

要在 C++ 中进行文件处理，必须在 C++ 源代码文件中包含头文件 。

open() 函数

open() 函数的标准语法，open() 函数是 fstream、ifstream 和 ofstream 对象的一个成员。

void open(const char *filename, ios::openmode mode);

在这里，open() 成员函数的

第一参数指定要打开的文件的名称和位置

第二个参数定义文件被打开的模式。

您可以把以上两种或两种以上的模式结合使用。

例如，如果您想要以写入模式打开文件，并希望截断文件，以防文件已存在，那么您可以使用下面的语法：

这是一个二进制位的操作

ofstream outfile;
outfile.open("file.dat", ios::out | ios::trunc );

类似地，您如果想要打开一个文件用于读写，可以使用下面的语法：

ifstream  afile;
afile.open("file.dat", ios::out | ios::in );

close() 函数

当 C++ 程序终止时，

它会自动关闭刷新所有流，释放所有分配的内存，并关闭所有打开的文件。

但程序员应该养成一个好习惯，在程序终止前关闭所有打开的文件。

下面是 close() 函数的标准语法，close() 函数是 fstream、ifstream 和 ofstream 对象的一个成员。

void close();

读取 O

C

getc

参数 文件指针

功能 逐个字节读取文件

返回值 读取到的一个(int)字节

注意事项 它不会读取回车,会读取换行

与​​getchar​​​不同的是,​​getchar​​默认是stdin

C 库函数 *int getc(FILE \stream) 从指定的流 stream 获取下一个无符号字符，并把位置标识符往前移动

int getc(FILE *stream)

很nb的是,getc遇到0D[回车符]不会读取,文件指针字节跳过0D

也就是说你的enter,产生了2字节的数据,回车huan行只会读取一个字节,只会读取换行0A

fp = fopen("read.txt", "r"); 
    while ((ch = getc(fp)) != EOF)
    {
        putc(ch,stdout);  // same as putchar(ch);
        count++;
    }
    fclose(fp);

ungetc

int ungetc(int char, FILE *stream)

参数

• char-- 这是要被推入的字符。该字符以其对应的 int 值进行传递。
• stream-- 这是指向 FILE 对象的指针，该 FILE 对象标识了输入流。

功能

C 库函数 *int ungetc(int char, FILE \stream) 把字符 char（一个无符号字符）推入到指定的当前流 stream 中，

返回值

如果成功，则返回被推入的字符，否则返回 EOF，且流 stream 保持不变。

#include <stdio.h>

int main ()
{
   FILE *fp;
   int c;
   char buffer [256];

   fp = fopen("in.txt", "r");
   while(!feof(fp))
   {
      c = getc (fp);
      /* 把 一行的第一个!替换为 + */
      if( c == '!' )
         ungetc ('+', fp);
      else
         ungetc(c, fp);
         
      fgets(buffer, 255, fp);
      fputs(buffer, stdout);
   }
   return(0);
}

fgetc 逐个字节的读取到字符变量

int fgetc(FILE *file_ptr)

从文件中一个一个字符的读取，把无符号 char 返回为一个int，一直读到文件末尾或者发生错误

同时,file_ptr会发生改变,不断的指向下一个单元

printf("%c", fgetc(fp));

getc

fgets 读取很多个到一个数组

参数:

str: 一个接收数据的字符串

n: 读取的最大字符数（包括最后的空字符）

stream: 文件指针或者其它流,好比​​stdin​​

功能:

读取字符串

返回值:

字符串地址||遇到EOF就返回0

char *fgets(char *str, int len, FILE *stream)

读取结束的标志

1.len-1个大小

2.换行符号后面

3.文件最后,读取到EOF就返回0

读取结束在arr[len-1]处设置为0

​​\n​​换行符使 fgets 停止读取，但它被函数视为有效字符并包含在复制到 str 的字符串中。

fgets 只能读取 num - 1 个字符，包括最后的换行符，在复制到 str 的字符后自动附加终止空字符​​‘\0’​​

所以所以遇到换行就stop

#include <stdio.h>

int main()
{
   FILE *fp;
   char str[60];

   /* 打开用于读取的文件 */
   fp = fopen("d:/file.txt" , "r");
   if(fp == NULL) 
   {
      perror("打开文件时发生错误");
      return(-1);
   }
   if( fgets (str, 60, fp)!=NULL ) 
   {
      /* 当读取 (n-1) 个字符/读取到换行符/到达文件末尾时，它会停止 */
       //读取到str
      puts(str);
   }
   fclose(fp);
   
   return(0);
}

fscanf() 把文件按一定的格式化写入到数组

​​ ```c fscanf(D, "格式化%",S); ``` ​​

返回接收参数的个数

注意fscanf遇到​​空格​​会结束本次读操作。

fscanf 读取字符串时，读取任意数量的非空白字符，在找到的第一个空白字符处停止。在存储序列的末尾自动添加终止空字符​​‘\0’​​。

所以遇到空格或者\n就stop

例子1

fscanf(fp,"%d",&Num);

它可以实现把文件第一个位置的整形数据读取到整形变量Num中,,,,这与我们只要用

用strean’流去接受数据,或者fp去接收数据h会不一样…

例子2

fscanf(fp,"%s%s",English_Temp_Arr,Chinese_Temp_Arr);

于是%s %s会读取fp的字符串,遇到空格就读取结束,遇到空格就读取结束..

分别读取到数组中English_Temp_Arr,Chinese_Temp_Arr

每每调用一次fscanf,..fp的指向就会修改

#include <stdio.h>
#include <stdlib.h>


int main()
{
   char str1[10], str2[10], str3[10];
   int year;
   FILE * fp;
   int len=0;

   fp = fopen ("d:/file.txt", "w+");
   fputs("We are in 2014", fp);
   
   rewind(fp);
   len=fscanf(fp, "%s %s %s %d", str1, str2, str3, &year);
   
   printf("Read String1 |%s|\n", str1 );
   printf("Read String2 |%s|\n", str2 );
   printf("Read String3 |%s|\n", str3 );
   printf("Read Integer |%d|\n", year );
   printf("len |%d|\n", len );

   fclose(fp);
   
   return(0);
}

输出

Read String1 |We|
Read String2 |are|
Read String3 |in|
Read Integer |2014|
len |4|
请按任意键继续. . .

C++

在 C++ 编程中，我们使用流提取运算符（ >> ）从文件读取信息，就像使用该运算符从键盘输入信息一样。唯一不同的是，在这里您使用的是 ifstream 或 fstream 对象，而不是 cin 对象

写入

C

putc

与​​putchar​​​不同的是,​​putchar​​的会默认stdout

​​putc(output,stdout)=putchar​​

库函数 *int putc(int char, FILE \stream) 把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。

int putc(int char, FILE *stream)

fputc 逐个字符的写入

这个函数可以返回被写入的字符

#include <stdio.h>
 
int main ()
{
   FILE *fp;
   int ch;
 
   fp = fopen("d:/file.txt", "w+");
   for( ch = 33 ; ch <= 100; ch++ )
   {
      fputc(ch, fp);//这个方向有点奇怪.从左面写入到右边
   }
   
   fclose(fp);
 
   return(0);
}

文件中的内容

fputs 很多很多的写入

参数

​​const char *str​​: 要写入的东西

​​FILE *stream​​文本文件指针

功能:

放东西进入文件

返回值:

int fputs(const char *str, FILE *stream)

注意事项:

fputc不会添加换行符

#include <stdio.h>

int main ()
{
   FILE *fp;

   fp = fopen("d:/file.txt", "w+");

   fputs("这是 C 语言。\n", fp);
   fputs("这是一种系统程序设计语言。\ndqx", fp);

   fclose(fp);
   
   return(0);
}

文件

fprintf 格式化写入文件

int fprintf(FILE *file_ptr, “%s.%d..写入的格式”, “写入的字符串1”，写入的数值2...)；

fprintf(file_ptr, "%s %s %s %d", "We", "are", "in", 2014);

不同于printf,

printf是直接写入stdout

fprintf多了一个写入stream的操作,

它不仅可以写入stdout输出流

也可以选择写入文件流

fwrite 二进制写入

size_t fwrite(const void *arr, size_t type_arr,size_t lengthof_arr,  FILE *file_prt)

参数

1️⃣const void *arr, 一个数据来源的地址,

可以是数组,写入时指明长度,可以是值,指明数值的尺度

2️⃣size_t type_arr

每个成员的尺度

3️⃣size_t lengthof_arr

多少个成员

4️⃣FILE *file_prt

文件指针

返回值

写入成功,返回写入的数量

double arr[]={1.2,3.4,6.7};
fp = fopen( "file.txt" , "w" );
fwrite(arr, sizeof(double), sizeof(arr)/sizeof(arr[0]) ,fp );

好像的话,只要满足

fwrite(str, x , y, fp );

x和y没有严格的要求,它实际上会读取x*y个字节,然后写入

fread 二进制读取

size_t fread(void *就收数据的数组/指针, size_t 接收的长度, size_t 每个长度的大小, FILE *文本文件的指针)

读取文件到末尾后它会返回​​0​​

而不是​​EOF​​

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)

参数

1️⃣void *arr, 一个接受数据的地址,

可以是数值,写入时指明长度,可以是数组,指明数组尺度

2️⃣size_t type_arr

每个成员的长度

3️⃣size_t lengthof_arr

多少个成员

必须lengthof*type>=接受的数据

4️⃣FILE *file_prt

文件指针

返回值

读取成功,返回读取的数量

#include <stdio.h>
#include <string.h>
 
int main()
{
   FILE *fp;
   char c[] = "123456789";
   char buffer[20];
 
   /* 打开文件用于读写 */
   fp = fopen("in.txt", "w+");
 
   /* 写入数据到文件 */
   fwrite(c, strlen(c) + 1, 1, fp);
 
   /* 查找文件的开头 */
   fseek(fp, 0, SEEK_SET);
 
   /* 读取并显示数据 */
   fread(buffer, strlen(c)+1, 1, fp);
   printf("%s\n", buffer);
   fclose(fp);
   
   return(0);
}

//头文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定义文件拷贝函数
int File_Copy()
{

    FILE *sfp = fopen("s.txt", "r+"),
         *dfp = fopen("d.txt", "w+");
    int ret=0;
    int i=0;
    char buff[100] = {0};
    
    if (!sfp && !dfp)
    {
        perror("fopen error");
        return -1;
    }

    for(i='A';i<='z';i++)
        fputc(i,sfp);
    rewind(sfp);
      
    while (1)
    {    
        ret =fread(buff, 4, 2, sfp);
        fwrite(buff, 2, 4, dfp);
        //memset(buff,0,100);
        if (ret == 0)
            break;
    }
    fclose(sfp);
    fclose(dfp);
}
int main()
{
    File_Copy();
    return 0;
}

C++

在 C++ 编程中，我们使用流插入运算符（ << ）向文件写入信息，就像使用该运算符输出信息到屏幕上一样。唯一不同的是，在这里您使用的是 ofstream 或 fstream 对象，而不是 cout 对象。

文件位置

fseek与fstell返回的是long类型变量

于是文件的访问字节数据就一直停在了long的大小范围之内,然后

fgetpos与fsetpos打破了这个限制

fpos_t 文件偏移量类型

他只是一个专门用于文件偏离保存的类型…就像是size_t类型

fseek 文件偏移

参数

stream 文本文件指针

offset 偏移量,有正负之分

whence 当前文件的位置

功能

函数会改变fp的位置,让它指向了whence+offset的位置,这里是一个有理数的相加

返回值

偏移正确 返回0

偏移错误 返回-1

int fseek(FILE *stream, long int offset, int whence )

#include <stdio.h>

int main ()
{
   FILE *fp;
   
   fp=fopen("d:/dqx.txt","w+");
   fputs("how are ? i am   fine",fp);
   
   fseek(fp,10,SEEK_SET);
   fputs("dqx is",fp);
   
   
   fclose(fp);
   return(0);
}

结果

how are ? dqx is fine

真正写入的位置是

[offset+whence]

同时,他是以0为开始的位置

ftell 返回 返回当前指针距离开始的偏移量

参数

文件指针

功能

假如文件有3字节,如果文件指针在末尾,就返回3

为什么是3

把文件看做一个数组

[0],[1],[2],末尾就是[3]

long int ftell(FILE *stream)

#include <stdio.h>

int main ()
{
   FILE *fp;
   int len;
   char ascii; 

   fp = fopen("d:/1.txt", "r");
   if( fp == NULL ) 
   {
      perror ("打开文件错误");
      return(-1);
   }
    
   fseek(fp, 0, SEEK_END);
    //让fp指向文本末尾0+SEEK_END

   len = ftell(fp);
   printf("1.txt 的总大小 = %d 字节\n", len);
   
   fclose(fp);

   return(0);
}

这是实践发现的

文本的实际大小是写入大小+2

fgetpos 获取文件的位置

int fgetpos(FILE *file_ptr, fpos_t *location)

参数

• stream-- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
• pos-- 这是指向 fpos_t 对象的指针。

功能

location=文件指针的位置

返回值

如果成功，该函数返回零。如果发生错误，则返回非零值。

fsetpos 设置文件的位置

参数

• stream-- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
• pos-- 这是指向 fpos_t 对象的指针，该对象包含了之前通过 fgetpos 获得的位置。

功能

文件指针的位置=location

返回值

如果成功，该函数返回零值，否则返回非零值，并设置全局变量 errno 为一个正值，该值可通过 perror 来解释。

int fsetpos(FILE *stream, const fpos_t *location)

#include <stdio.h>

int main ()
{
   FILE *fp;
   fpos_t position;

   fp = fopen("in.txt","w+");
   fgetpos(fp, &position);
   fputs("Hello, World!", fp);
  
   fsetpos(fp, &position);
   fputs("I will over flow", fp);
   fclose(fp);
   
   return(0);
}

rewind 让file_ptr重新回到文件的头部

void rewind(FILE *stream)

函数会把file_ptr指向文件的头部,不会有返回值

参数就是​​file_ptr​​

#include <stdio.h>

int main()
{
   char str[] = "This is runoob.com";
   FILE *fp;
   int ch;

   /* 首先让我们在文件中写入一些内容 */
   fp = fopen( "file.txt" , "w" );
   fwrite(str , 1 , sizeof(str) , fp );
   fclose(fp);

   //打开文件并且读取 
   fp = fopen( "file.txt" , "r" );
   while(1)
   {
      ch = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", ch);
   }
   //到了这里,fp已经不在头部,而在尾部 (如果不去关闭文件再重新打开的话)

   rewind(fp);
   //让fp再次回到文件的头部 
   
   printf("\n");
   while(1)
   {
      ch = fgetc(fp);
      if( feof(fp) )
      {
          break ;
      }
      printf("%c", ch);
     
   }
   fclose(fp);

   return(0);
}

其它

feof 文件末尾标志

int feof(FILE *file_ptr)

会在文件末尾设置一个end标志，

读取到文件结尾,函数返回非零

否则返回0

用于文件的遍历不错

while(1)
   {
      c = fgetc(fp);
      if( feof(fp) )
          break ;
      printf("%c", c);
   }

ferror

C 库函数 *int ferror(FILE \stream) 测试给定流 stream 的错误标识符。

int ferror(FILE *stream)

参数

stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流

返回值

当读写文件错误的时候,ferror返回一个非零值

否则返回0

perror("Error: ");

void perror(const char *str)

C 库函数 *void perror(const char \str) 把一个描述性错误消息输出到标准错误 stderr。

首先输出字符串 str，后跟一个冒号，然后是一个空格

参数

• str-- 这是 C 字符串，包含了一个自定义消息，将显示在原本的错误消息之前。

返回值

该函数不返回任何值。

#include <stdio.h>

int main ()
{
   
   FILE *fp;

   /* 首先重命名文件 */
   rename("file.txt", "newfile.txt");

   /* 现在让我们尝试打开相同的文件 */
   fp = fopen("file.txt", "r");
   if( fp == NULL ) 
   {
      perror("错了");
      return(-1);
   }
   fclose(fp);
      
   return(0);
}

setbuf 读取文本到缓冲区

void setbuf(FILE *stream, char *buffer)

参数

FILE *stream, 一个流

char *buffer 一个缓冲区

功能

把指向流的数据显缓冲在缓冲区,然后通过fflush送到流

返回值

注意事项

buffer -- 这是分配给用户的缓冲，它的长度至少为 BUFSIZ 字节，BUFSIZ 是一个宏常量，表示数组的长度

char buf[BUFSIZ];
setbuf(stdout, buf);

例子

#include <stdio.h>

int main()
{
  char buff[BUFSIZ];
  int i=0;
  setbuf(stdout, buff);
  
  puts("123");
  puts("456");
  fflush(stdout);
  puts("yes");
  return(0);
}

输出的语句会被送达缓冲区

0x31,0x32,0x33,0xa,0x34,0x35,0x36,0xa,

然后fflush把缓冲区的数据送到流stdout

setvbuf 相比较setbuf,它多了模式mode可言

C 库函数 **int setvbuf(FILE \stream, char \buffer, int mode, size_t size) 定义流 stream 应如何缓冲。

int setvbuf(FILE *stream, char *buffer, int mode, size_t size)

参数

• stream-- 这是指向 FILE 对象的指针，该 FILE 对象标识了一个打开的流。
• buffer-- 这是分配给用户的缓冲。如果设置为 NULL，该函数会自动分配一个指定大小的缓冲。
• mode-- 这指定了文件缓冲的模式：

关于mode

• size--这是缓冲的大小，以字节为单位。

功能

返回值

如果成功，则该函数返回 0，否则返回非零值。

和setbuf没太多的区别

fflush 刷新缓冲区

int fflush(FILE *stream)

刷新stream流,

刷新成功|stream为空, 返回非零

刷新失败 返回0

如果参数是空指针,默认刷新所有缓冲区

如果参数不为空,把缓冲区所有没有被写入的数据发送到fp栈顶文件,然后缓冲区清空

remove 永久删除文件

int remove(const char *filename)//里面是一个字符串罢了

删除如果成功，则返回零。

如果错误，则返回 -1，并设置 errno。

另外垃圾桶找不到文件了,可以说真的删除找不到了

rename 重命名文件的名字

int rename(const char *old_filename, const char *new_filename)

const char *old_filename: 原来文件的名字

const char *new_filename: 新的文件名字

#include <stdio.h>

int main ()
{
   int ret;
   char oldname[] = "d:/file.txt";
   char newname[] = "d:/dqx.txt";
   
   ret = rename(oldname, newname);
   
   if(ret == 0) 
   {
      printf("文件重命名成功");
   }
   else 
   {
      printf("错误：不能重命名该文件");
   } 
   return(0);
}

如果找到了"d:/file.txt"

但是没有找到d:/dqx.txt";

那么源文件会被永久的删除

程序暂时还不会报错,正常的退出

ferror 文件获取的错误类型

int ferror(FILE *file_ptr)

返回文件发生错误的类型,

出错就返回非零的编号

没出错就返回0

if( ferror(fp) )
   {
      printf("读取文件：file.txt 时发生错误\n");
   }

clearerr 文件错误的清理

void clearerr(FILE *file_ptr)

清除文件发生的错误

tmpfile 创建临时文件

以二进制更新模式(wb+)创建临时文件

流关闭的时候或者在程序终止的时候自动删除。

#include <stdio.h>

int main ()
{
   FILE *fp;

   fp = tmpfile();
   printf("临时文件被创建\n");

   /* 您可以在这里使用临时文件
   
   ...
   ...
   ...
   
    */

   fclose(fp);

   return(0);
}

tmpnam 返回临时文件名字的指针

char *tmpnam(char *arr)

返回一个指向字符串arr的指针

​​arr​​是一个字符串数组

参数​​arr​​​也可以为​​NULL​​

#include <stdio.h>

int main()
{
  char* ptr;
  char buffer[L_tmpnam];
  //L_tmpnam = 16

  
  //库函数被调用1次 [0]
  ptr=tmpnam(buffer);
  printf("临时名称 : %s\n", buffer);
  printf("临时名称 : %s\n", ptr);
  //库函数被调用2次 [1]
  printf("临时名称 : %s\n", tmpnam(NULL));
  

  
  return(0);
}

例子

一个字节一个字节的读取与写入

它会读取到你的文件最后

while(1)
  {
    c = fgetc(sfp);
    if( feof(sfp) )
        break ;
      fprintf(dfp,"%c",c);//二进制文件一个一个的写入??? 
  }

用fread/fwrite 复制一个文件的细节

//头文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定义文件拷贝函数
int File_Copy()
{

    FILE *sfp = fopen("s.txt", "r+"),//如果要写入,它会像w一杨写入,,,完全覆盖重新写
         *dfp = fopen("d.txt", "w+");
    int ret=0;
    int i=0;
    char buff[100] = {0};
    if (!sfp && !dfp)
    {
        perror("fopen error");
        return -1;
    }

    for(i='A';i<='z';i++)//逐个字节的写入
        fputc(i,sfp);
    rewind(sfp);//把流指针恢复到头部
      
    while (1)
    {    
        ret =fread(buff, 4, 2, sfp);//我们要保证读取的字节数>=写入的字节数才有意义
        fwrite(buff, 2, 3, dfp);//读取8个,只是写入了头6个
        memset(buff,0,100);//刷新buff
        if (ret == 0)
            break;
    }
    fclose(sfp);
    fclose(dfp);
}
int main()
{
    File_Copy();
    return 0;
}