The File Functions in C

在平时写程序时，程序员经常要用到IO操作，用的最多的一般是与控制台进行交互(标准的输入输出)，但往往也需要对已命名的文件进行读写操作。本文主要分析C语言对文件操作的支持，在以后的文章中再另外分析C++中标准的IO库。(2010-3-26 wcdj)

---

[磁盘文件数据存储方式]
实际上，文件是在计算机内存中以二进制表示的数据在外部存储介质上的另一种存放形式。文件通常分为二进制文件和文本文件。二进制文件是包含在ASCII及扩展ASCII字符中编写的数据或程序指令的文件。一般是可执行文件(exe)、图形、图像、声音等文件。而文本文件(通常也成为ASCII文件)，它的每一字节存放的是可表示为一个字符的ASCII代码的文件。这里把文件区分为二进制文件和文本文件，但实际上它们都是以二进制数据的方式来存储的。文本文件里所存储的每一个字节都可以转化为一个可读的字符。譬如'a'，'b'，但在内存中并不会存储'a'，'b'，而是存储它们的ASCII码：61h和62h。

[请勿混淆]
在计算机中所有文件都是二进制的。所谓文本，Unicode都是编码方式，按某种编码方式读出来的时候才产生的不同。
数据就是数据，关键看你怎么使用了，如果说区别，就是文本文件载入的时候，会把回车/r换行/n，2个符号转换成回车/n符号，而吃掉换行符/r，存盘的时候把这个吃掉的换行符再吐回去。至于也可以把文本文件当初数据文件来读，纯粹是看应用了。就好比有人问10进制，16进制的区别，纯粹就是一回事。
二进制文件和文本文件都是数据，只不过看问题的角度不同而已，他们都是一样的。好比'1'，你用文本文件看是'1',你用16进制工具看是0x31，实际上都是0x31，或者是0011 0001(十进制49)。
从文件系统的角度，所有的文件都是一个顺序的比特集合，区别在于程序如何解读这些数据，一段数据可以看成是文本，图像或者声音。

[C语言对文件操作的支持]
在C语言中，对于文件的操作都是利用FILE结构体来进行的。包括文件的打开、文件的读写、文件的关闭、文件指针的定位等。

[一道基本的对文件操作的例子]

/* C语言操作文件的方式： 面试题：先从一个已存在的文件f1中读取一个整数，例如12345， 再将这个整数保存到另外一个文件f2中，要求在以记事本打开该文件时，显示的是:12345。 函数原型： FILE * __cdecl fopen(const char *, const char *); size_t __cdecl fread(void *, size_t, size_t, FILE *); size_t __cdecl fwrite(const void *, size_t, size_t, FILE *); int __cdecl fprintf(FILE *, const char *, ...); void __cdecl clearerr(FILE *); int __cdecl fclose(FILE *); char * __cdecl itoa(int, char *, int); int __cdecl atoi(const char *); */ #include <stdio.h> #include <stdlib.h>// itoa struct mystruct { int i; char ch; }; int main(void) { FILE *stream1,*stream2; // read form f1 and print to f2 struct mystruct s; s.i = 0; s.ch = 'A'; int ival=0; long lval=0; printf("%d/n",sizeof(int));// 4 bytes printf("%d/n",sizeof(long));// 4 bytes if ((stream1 = fopen("f1.txt", "rb")) == NULL) /* open file f1.txt */ { fprintf(stderr, "Cannot open f1.txt./n"); return 1; } //fread(&ival,sizeof(int),1,stream1);// error, because see below //fread(&lval,sizeof(int),1,stream1);// error, read still 4 bytes /* in this way, ival equals to 875770417, that is, in binary is 00110100 00110011 00110010 00110001 4 3 2 1 in fact, 00110101 00110100 00110011 00110010 00110001 5 4 3 2 1 in this way, it will read file in a bit unit */ char cRead[6]={0}; fread(cRead,sizeof(cRead),1,stream1);// ok, in this way, it will read file in a byte unit printf("cRead=%s/n",cRead);// 12345 ival=atoi(cRead);// convert char* to int type printf("ival=%d/n",ival); if ((stream2 = fopen("f2.txt", "a+")) == NULL) /* open file f1.txt */ { fprintf(stderr, "Cannot open f2.txt./n"); return 1; } /* write struct s to file */ //fwrite(&s, sizeof(s), 1, stream);// error, Unrecognizable Code ! fprintf(stream2,"%d %c/n",s.i,s.ch);// ok, print 0 A in the file //fwrite(&ival,sizeof(int),1,stream);// error, cannot print 12345 fprintf(stream2,"%d/n",ival);// ok, print 12345 // the second way to print ival char ch[]={1+48,2+48,3+48,4+48,5+48}; fwrite(ch,sizeof(ch),1,stream2);// ok, print 12345 // the third way to print ival char ch2[5]; itoa(ival,ch2,10);// convert int to char* fwrite(ch2,sizeof(ch2),1,stream2);// ok, print 12345 fclose(stream1); /* close file */ return 0; } /* f2.txt中的内容： 0 A 12345 1234512345 */

[Reference]

// [1] /* size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream ); Write block of data to stream Writes an array of count elements, each one with a size of size bytes, from the block of memory pointed by ptr to the current position in the stream. The postion indicator of the stream is advanced by the total number of bytes written. The total amount of bytes written is (size * count). Parameters ptr Pointer to the array of elements to be written. size Size in bytes of each element to be written. count Number of elements, each one with a size of size bytes. stream Pointer to a FILE object that specifies an output stream. Return Value The total number of elements successfully written is returned as a size_t object, which is an integral data type. If this number differs from the count parameter, it indicates an error. Example */ /* fwrite example : write buffer */ #include <stdio.h> int main () { FILE * pFile; char buffer[] = { 'x' , 'y' , 'z' }; pFile = fopen ( "myfile.bin" , "wb" ); fwrite (buffer , 1 , sizeof(buffer) , pFile ); fclose (pFile); return 0; } /* A file called myfile.bin is created and the content of the buffer is stored into it. For simplicity, the buffer contains char elements but it can contain any other type. sizeof(buffer) is the length of the array in bytes (in this case it is three, because the array has three elements of one byte each). */ // [2] /* size_t fread ( void * ptr, size_t size, size_t count, FILE * stream ); Read block of data from stream Reads an array of count elements, each one with a size of size bytes, from the stream and stores them in the block of memory specified by ptr. The postion indicator of the stream is advanced by the total amount of bytes read. The total amount of bytes read if successful is (size * count). Parameters ptr Pointer to a block of memory with a minimum size of (size*count) bytes. size Size in bytes of each element to be read. count Number of elements, each one with a size of size bytes. stream Pointer to a FILE object that specifies an input stream. Return Value The total number of elements successfully read is returned as a size_t object, which is an integral data type. If this number differs from the count parameter, either an error occured or the End Of File was reached. You can use either ferror or feof to check whether an error happened or the End-of-File was reached. Example */ /* fread example: read a complete file */ #include <stdio.h> #include <stdlib.h> int main () { FILE * pFile; long lSize; char * buffer; size_t result; pFile = fopen ( "myfile.bin" , "rb" ); if (pFile==NULL) {fputs ("File error",stderr); exit (1);} // obtain file size: fseek (pFile , 0 , SEEK_END); lSize = ftell (pFile); rewind (pFile); // allocate memory to contain the whole file: buffer = (char*) malloc (sizeof(char)*lSize); if (buffer == NULL) {fputs ("Memory error",stderr); exit (2);} // copy the file into the buffer: result = fread (buffer,1,lSize,pFile); if (result != lSize) {fputs ("Reading error",stderr); exit (3);} /* the whole file is now loaded in the memory buffer. */ // terminate fclose (pFile); free (buffer); return 0; } /* This code loads myfile.bin into a dynamically allocated memory buffer, which can be used to manipulate the content of a file as an array.*/ // [3] int fscanf ( FILE * stream, const char * format, ... ); /* Read formatted data from stream Reads data from the stream and stores them according to the parameter format into the locations pointed by the additional arguments. The additional arguments should point to already allocated objects of the type specified by their corresponding format tag within the format string. Parameters stream Pointer to a FILE object that identifies the stream to read data from. format C string that contains one or more of the following items: Whitespace character: the function will read and ignore any whitespace characters (this includes blank spaces and the newline and tab characters) which are encountered before the next non-whitespace character. This includes any quantity of whitespace characters, or none. Non-whitespace character, except percentage signs (%): Any character that is not either a whitespace character (blank, newline or tab) or part of a format specifier (which begin with a % character) causes the function to read the next character from the stream, compare it to this non-whitespace character and if it matches, it is discarded and the function continues with the next character of format. If the character does not match, the function fails, returning and leaving subsequent characters of the stream unread. Format specifiers: A sequence formed by an initial percentage sign (%) indicates a format specifier, which is used to specify the type and format of the data to be retrieved from the stream and stored in the locations pointed by the additional arguments. A format specifier follows this prototype: [=%[*][width][modifiers]type=] where: http://www.cplusplus.com/reference/clibrary/cstdio/fscanf/ (see more) additional arguments The function expects a sequence of references as additional arguments, each one pointing to an object of the type specified by their corresponding %-tag within the format string, in the same order. For each format specifier in the format string that retrieves data, an additional argument should be specified. These arguments are expected to be references (pointers): if you want to store the result of a fscanf operation on a regular variable you should precede its identifier with the reference operator, i.e. an ampersand sign (&), like in: int n; fscanf (stream,"%d",&n); Return Value On success, the function returns the number of items succesfully read. This count can match the expected number of readings or be less -even zero- in the case of a matching failure. In the case of an input failure before any data could be successfully read, EOF is returned. Example */ /* fscanf example */ #include <stdio.h> int main () { char str [80]; float f; FILE * pFile; pFile = fopen ("myfile.txt","w+"); fprintf (pFile, "%f %s", 3.1416, "PI"); rewind (pFile); fscanf (pFile, "%f", &f); fscanf (pFile, "%s", str); fclose (pFile); printf ("I have read: %f and %s /n",f,str); return 0; } /* This sample code creates a file called myfile.txt and writes a float number and a string to it. Then, the stream is rewinded and both values are read with fscanf. It finally produces an output similar to: I have read: 3.141600 and PI */ // [4] /* FILE Object containing information to control a stream This type of object identifies a stream and contains the information needed to control it, including a pointer to its buffer, its position indicator and all its state indicators. FILE objects are usually created by a call to either fopen or tmpfile, which both return a reference to one of these objects. The content of a FILE object is not meant to be read from outside the functions of the cstdio library; In fact, its main purpose is to be referenced as an argument in all stream-involving functions of this library to identify the stream to be affected. Its memory allocation is automatically performed by either fopen or tmpfile, and is the responsibility of the library to free the resources once the stream has been closed using fclose or other means. On inclusion of the cstdio header file, three objects of type FILE * (pointer to FILE)are automatically created. These are associated with the standard input, output and error streams, and can be accessed respectively through the pointers stdin, stdout and stderr. Example */ #include <stdio.h> int main() { FILE * pFile; char buffer [100]; pFile = fopen ("myfile.txt" , "r"); if (pFile == NULL) perror ("Error opening file"); else { while ( ! feof (pFile) ) { fgets (buffer , 100 , pFile); fputs (buffer , stdout); } fclose (pFile); } return 0; } /* This example reads the content of a text file called myfile.txt and sends it to the standard output stream. */