C/C ++ basic file read/write

In the programming process, file operations are a common problem. In C ++ builder, you can use multiple methods to operate files, I will introduce this in detail in the following parts:

1. C-based file operations;

2. File Operations Based on C ++;

　　1. C-based file operations

In ansi c, file operations are divided into two methods: stream file operations and I/O file operations, which are described below.

1) stream File Operations

This file operation has an important structure file, which is defined in stdio. h as follows:

　　

The following is a reference clip: Typedef struct { Int level;/* fill/empty level of buffer */ Unsigned flags;/* file Status flags */ Char FD;/* file descriptor */ Unsigned char hold;/* ungetc char if no buffer */ Int bsize;/* buffer size */ Unsigned char _ far * buffer;/* Data Transfer Buffer */ Unsigned char _ far * CURP;/* current active pointer */ Unsigned istemp;/* temporary file indicator */ Short token;/* used for validity checking */ } File;/* This is the file object */

The file structure contains the basic attributes of file operations. All file operations must be performed through the pointer of this structure. Common functions for such file operations are as follows:

Function

Fopen () Open stream

Fclose () Close the stream

Fputc () writes a character to the stream

Fgetc () reads a character from the stream

Fseek () locates the specified character in the stream

Fputs () writes a string to a stream

Fgets () reads a row or a specified character from the stream.

Fprintf () Outputs Data to the stream in the format

Fscanf () reads data from the stream in the format

Returns the true value when feof () reaches the end of a file.

Returns the value of ferror () When an error occurs.

Rewind () resets the file locator to the beginning of the file

Remove () delete an object

Fread () reads a specified number of characters from a stream

Fwrite () writes a specified number of characters to the stream.

Tmpfile () generates a temporary file stream

Tmpnam () generates a unique file name

The following describes these functions.

1. fopen ()

Fopen is prototype: file * fopen (const char * filename, const char * mode). fopen implements three functions: open a stream for use, connect a file to the stream and return a filr pointer to the stream.

The filename parameter points to the name of the file to be opened. mode indicates the string in the open state. The value is as follows:

String meaning

"R" open a file in read-only mode

"W" open a file in write-only mode

"A" open the file in append Mode

"R +" open the file in read/write mode. If no file error occurs

"W +" opens a file in read/write mode. If no file is generated, a new file is generated.

A file can be opened in text or binary mode. The difference between the two is that in text mode, carriage return is treated as a character '/N ', the binary mode considers it to be two characters: 0x0d and 0x0a. If you read 0x1b in the file, the text mode considers it to be the file Terminator, that is, the binary model does not process the file, the text method converts the data in a certain way.

By default, the system is enabled in text mode. You can modify the value of all variables _ fmode to modify this setting. For example, _ fmode = o_text; then, the default mode is set to text mode; _ fmode = o_binary; the default enable mode is binary.

You can also specify the open mode in the mode string. For example, "rb" indicates that the read-only file is opened in binary mode, "W + t" or "WT +" indicates opening the read/write file in text mode.

This function returns a file pointer, so it does not need to be initialized after declaring a file pointer. Instead, it uses fopen () to return a pointer and connect it to a specific file. If it succeeds or fails, null is returned.

Example:

　　

The following is a reference clip: File * FP; If (FP = fopen ("123.456", "WB ")) Puts ("file opened successfully "); Else Puts ("file opening success or failure ");

2. fclose ()

Fclose () is used to close files opened with fopen (). Its prototype is int fclose (File * FP). If the file is successful, 0 is returned. If the file is failed, EOF is returned.

When the program ends, remember to close the opened file. Otherwise, it may cause data loss. I used to make such errors.

Example: fclose (FP );

3. fputc ()

Write a character to the stream. The prototype is int fputc (int c, file * stream). If this character is returned successfully, EOF is returned for failure.

Example: fputc ('x', FP );

4. fgetc ()

Read a character from the stream. The prototype is int fputc (File * stream). If this character is returned successfully, EOF is returned if it fails.

Example: Char struct = fgetc (FP );

5. fseek ()

This function is generally used in files opened in binary mode. It is used to locate the specified position in the stream. The prototype is int fseek (File * stream, long offset, int whence ); if 0 is returned successfully, the offset parameter indicates the number of characters to be moved, and the whence parameter indicates the moving benchmark. The value is:

Symbol constant value reference position

Start with seek_set 0

Seek_cur 1 Current read/write location

Seek_end 2 file tail

Example: fseek (FP, 1234l, seek_cur); // move the read/write position 1234 bytes backward from the current position (L suffix indicates a long integer)

Fseek (FP, 0l, 2); // move the read/write location to the end of the file

6. fputs ()

Write a string to the stream. The prototype is int fputs (const char * s, file * stream );

Example: fputs ("I love you", FP );

7. fgets ()

Read a row or a specified character from the stream. The prototype is char * fgets (char * s, int N, file * stream). Read n-1 characters from the stream, unless one line is read, the parameter S is used to receive strings. If the string is successful, the pointer of S is returned. Otherwise, null is returned.

For example, if the text at the current position of an object is as follows:

Love, I have

But ........

If you use

Fgets (str1, 4, file1 );

After execution, str1 = "lov" reads 4-1 = 3 characters.

Fgets (str1, 23, file1 );

Run STR = "love, I have" to read a row (excluding '/N' at the end of the row ').

8. fprintf ()

Input the stream in the format. The prototype is int fprintf (File * stream, const char * Format [, argument,…]). The method is the same as printf (), but it is not written to the console, but to the stream.

Example: fprintf (FP, "% 2D % s", 4, "HAHAHA ");

9. fscanf ()

Read from the stream in the format. Its prototype is int fscanf (File * stream, const char * Format [, address,…]); The method is the same as scanf (), but it is not read from the console, but from the stream.

Example: fscanf (FP, "% d", & X, & Y );

10. feof ()

Check whether the end of the file is reached. If it is true, 0 is returned. The prototype is int feof (File * stream );

Example: If (feof (FP) printf ("ended at the end of the file ");

11. ferror ()

The prototype is int ferror (File * stream). The latest error code of the returned stream can be cleared by clearerr (). The prototype of clearerr () is void clearerr (File * stream );

Example: printf ("% d", ferror (FP ));

12. Rewind ()

Return the current read/write location to the start of the file. The prototype is void rewind (File * stream). In fact, this function is equivalent to fseek (FP, 0l, seek_set );

Example: rewind (FP );

12. Remove ()

Delete the file. The prototype is int remove (const char * filename). The parameter is the name of the file to be deleted. 0 is returned if the file is successfully deleted.

Example: Remove ("C: // Io. sys ");

13. fread ()

Read a specified number of characters from the stream. The prototype is size_t fread (void * PTR, size_t size, size_t N, file * stream). The PTR parameter stores the read data, void * pointers can be replaced by pointers of any type, such as char * and int *. Size indicates the number of bytes in each block. N indicates the number of read blocks. If yes, returns the number of actually read parts (not the number of bytes). This function is generally used in files opened in binary mode.

Example:

　　

The following is a reference clip: Char X [4230]; File * file1 = fopen ("C: // msdos. sys", "R "); Fread (x, 200, 12, file1); // read 2400*12 = bytes in total

14. fwrite ()

Corresponds to fread and writes the specified data to the stream. The prototype is size_t fwrite (const void * PTR, size_t size, size_t N, file * stream ); the PTR parameter is the data pointer to be written. The Void * pointer can be replaced by any type of pointer, such as char * and int *. The size is the number of bytes per block; n is the number of blocks to be written. If the number of actually written blocks is returned (not the number of bytes), this function is generally used in files opened in binary mode.

Example:

　　

The following is a reference clip: Char X [] = "I Love You "; Fwire (x, 6, 12, FP); // write 6*12 = 72 bytes Write "I love" to the stream FP 12 times, a total of 72 bytes

15. tmpfile ()

The prototype is file * tmpfile (void). A temporary file is generated, opened in "W + B" mode, and a pointer to the temporary stream is returned. If the stream fails, null is returned. At the end of the program, the file will be automatically deleted.

Example: file * fp = tmpfile ();

16. tmpnam ();

Its prototype is char * tmpnam (char * s). A unique file name is generated. In fact, tmpfile () calls this function. The parameter S is used to save the obtained file name, returns the pointer. If the pointer fails, null is returned.

For example, tmpnam (str1 );

2) Direct I/O file operations

This is another file operation provided by C. It processes the file by directly saving/retrieving the file, and the streaming file operation is carried out through the buffer; streaming file operations are performed around a file pointer, and such file operations are performed around a file's "handle". What is a handle? It is an integer that uniquely identifies a file (in windows, the handle concept is extended to the identifier of all device resources. Common functions for such file operations are listed in the following table. These functions and their symbols are defined in Io. h and fcntl. H, and corresponding header files must be added for use.

Function Description

Open () open a file and return its handle

Close () close a handle

Lseek () locates at the specified position of the file

Read () block Read File

Write () block Write File

Whether the EOF () test file is complete

Filelength () gets the file length

Rename () rename a file

Chsize () changes the file length

The following describes these functions:

1. open ()

Open a file and return its handle. If it fails, a value smaller than 0 will be returned. The prototype is int open (const char * path, int access [, unsigned mode]); the path parameter is the name of the file to be opened, the access mode is open, and the mode is optional. This parameter indicates the properties of a file. It is mainly used in UNIX systems and has no significance in DOS/windows. The file opening mode is shown in the following table.

Symbol Meaning symbol meaning

O_rdonly read-only mode o_wronly write-only mode o_rdwr read/write mode

O_ndelay is used to append o_creat to o_creat in the Unix system. If the file does not exist, it is created.

O_trunc cut the file length to 0 o_excl and o_creat. If the file has an error, the o_binary binary method is returned.

O_text text

You can use the "|" operator to connect to multiple requirements. For example, o_append | o_text indicates opening a file in text mode and append mode.

Example: int handle = open ("C: // msdos. sys", o_binary | o_creat | o_write)

2. Close ()

Close a handle. The prototype is int close (INT handle). If the handle is successful, 0 is returned.

Example: Close (handle)

3. lseek ()

Locate to the specified position. The prototype is long lseek (INT handle, long offset, int fromwhere). The offset parameter is the moving amount, and fromwhere is the moving reference position, the value is the same as fseek (). seek_set: File Header, seek_cur: Current Position of the file, and seek_end: End of the file. This function returns the new file access location after execution.

Example:

Lseek (handle,-1234l, seek_cur); // moves the access location 1234 bytes forward from the current location.

X = lseek (hnd1, 0l, seek_end); // move the access location to the end of the file. x = The End of the file, that is, the length of the file.

4. Read ()

Read a block from the file. The prototype is int read (INT handle, void * Buf, unsigned Len). The parameter Buf stores the read data, and Len is the read byte. The function returns the bytes actually read.

Example: Char X [200]; read (hnd1, X, 200 );

5. Write ()

Write a piece of data to the file. The prototype is int write (INT handle, void * Buf, unsigned Len). The parameter meaning is the same as read (), and the actual written bytes are returned.

Example: Char X [] = "I Love You"; write (handle, X, strlen (x ));

7. EOF ()

Similar to feof (), if the test file ends, 1 is returned; otherwise, 0 is returned; prototype: int EOF (INT handle );

Example: While (! EOF (handle1 )){......};

8. filelength ()

The length of the returned file. The prototype is long filelength (INT handle). It is equivalent to lseek (handle, 0l, seek_end)

Example: long x = filelength (handle );

9. Rename ()

Rename the file. The prototype is int Rename (const char * oldname, const char * newname). The parameter oldname is the old file name and newname is the new file name. 0 is returned successfully.

Example: Rename ("C: // config. sys", "C: // config. w40 ");

10. chsize ();

Change the file length. The prototype is int chsize (INT handle, Long SIZE). The parameter size indicates the new length of the file. 0 is returned for success; otherwise,-1 is returned, if the specified length is smaller than the file length, the file is truncated. If the specified length is greater than the file length, add '/0' after the file '.

Example: chsize (handle, 0x12345 );

If you are familiar with assembly, you may find that this method is similar to the handler file operation called by the DOS Function of the assembly language. For example, open () is like the 3ch function call of the DOS service, in fact, there are two types of functions that can be directly completed using DOS functions, such as _ open () and _ dos_open. If you are interested, you can query the help of BCB.

Same as streaming file operations, this also provides Unicode Character operation functions, such as _ wopen (), for wide character programming in 9x/NT, if you are interested, you can query the help of BCB.

In addition, this operation also includes functions such as lock (), unlock (), and locking () for multi-user operations, but it is not used much in BCB, so I will not introduce it, however, if you want to use C to write CGI, this is the common sense. If you have such requirements, you have to look at your own help.

In C ++, there is a stream class. All I/O is based on this "stream" class, including the file I/O we want to know, stream has two important operators:

1. Plug-in (<)

Output data to the stream. For example, the system has a default standard output stream (cout), which generally refers to the display. Therefore, cout <"Write stdout" <'/N '; output the string "Write stdout" and line feed character ('/N') to the standard output stream.

2. Analyze (>)

Input data from the stream. For example, the system has a default standard input stream (CIN), which generally refers to the keyboard. Therefore, CIN> X; read data of a specified type (that is, the type of variable X) from the standard input stream.

In C ++, operations on files are implemented through the fstream (file stream) subclass of stream. Therefore, to operate files in this way, you must add the header file fstream. h. The following describes how to operate such files.

1. open the file

In the fstream class, a member function open () is used to open a file. Its prototype is:

Void open (const char * filename, int mode, int access );

Parameters:

Filename: name of the file to be opened

Mode: how to open the file

Access: Open File Attributes

The file opening method is defined in class IOs (which is the base class of all stream I/O classes). The common values are as follows:

IOS: APP: open a file in append Mode

IOS: ate: After the file is opened, it is located at the end of the file. IOS: app contains this attribute.

IOS: Binary: open a file in binary mode. The default mode is text. For the differences between the two methods, see the previous article.

IOS: In: open the file as input

IOS: Out: open an output file

IOS: nocreate: The file is not created, so opening fails if the file does not exist.

IOS: noreplace: Does not overwrite the file. Therefore, if the file fails to be opened

IOS: trunc: if the file exists, set the file length to 0.

You can use "or" to connect the preceding attributes, for example, IOS: Out | IOs: binary.

The attribute value for opening a file is:

0: normal file, open access

1: Read-Only files

2: Implicit File

4: system files

You can use "or" or "+" to connect the above attributes. For example, 3 or 1 | 2 means opening the file with read-only and implicit attributes.

For example, open the file C:/config. sys in binary input mode.

Fstream file1;

File1.open ("C: // config. sys", IOS: Binary | IOs: In, 0 );

If the OPEN function only has one parameter for the file name, it is opened by reading/writing a common file, that is:

File1.open ("C: // config. sys "); <=> file1.open (" C: // config. sys ", IOS: In | IOs: Out, 0 );

In addition, fstream has the same constructor as open (). For the above example, you can open the file at the time of definition:

Fstream file1 ("C: // config. sys ");

In particular, fstream has two sub-classes: ifstream (input file stream) and ofstream (outpu file stream). ifstream opens the file as input by default, ofstream opens the file in output mode by default.

Ifstream file2 ("C: // PDOS. Def"); // open the file as input

Ofstream file3 ("C: // x.123"); // open the file as an output

Therefore, in actual applications, select different classes as needed: If you want to open them as input, use ifstream to define them; if you want to open them as output, define it with ofstream. If you want to open it in input/output mode, define it with fstream.

2. close the file

You must close the opened file after it is used. fstream provides the member function close () to complete this operation, for example, file1.close (); to close the file connected to file1.