当前位置：网站首页>C language file operation for conquering C language

When we learned about structures earlier , The program that wrote the address book , When the address book runs , You can add... To the address book 、 Delete data ,

At this time, the data is stored in memory , When the program exits , The data in the address book naturally does not exist , The next time you run the address book program , The data has to be re entered , It's hard to use such an address book .

We were thinking that since it was an address book, we should record the information , Only when we choose to delete data , The data no longer exists . This involves the problem of data persistence ,

Our general methods of data persistence are , Store the data in a disk file 、 Stored in the database . Using files, we can store data directly on the hard disk of the computer , Data persistence is achieved .

2. What is a document

The files on disk are files .

But in programming , There are two kinds of documents we usually talk about ： Program files 、 Data files （ Classified from the perspective of file function ）

2.1 Program files

Include source files （ The suffix is .c）, Target file （windows Environment suffix is .obj）, Executable program （windows Environment suffix is .exe）.

2.2 Data files

The content of the file is not necessarily a program , It's the data that the program reads and writes when it runs , For example, the file from which the program needs to read data , Or output content file .

This chapter discusses data files .

In the previous chapters, the input and output of the processed data are targeted at the terminal , That is, input data from the keyboard of the terminal , The operation results are displayed on the display . In fact, sometimes we output information to disk , When necessary, read the data from the disk to the memory for use , Here to deal with Is the file on the disk

2.3 file name

A file should have a unique file ID , So that users can identify and reference .

The filename contains 3 part ： File path + File name trunk + file extension

for example ： c:\code\test.txt

For convenience , Document identification is often referred to as file name .

Be careful ：

The file extension must be checked

3. Opening and closing of files

3.1 The file pointer

Buffer file system , The key concept is “ File type pointer ”, abbreviation “ The file pointer ”.

Each used file has a corresponding file information area in memory , It is used to store information about files （ Such as the name of the document , File status and current file location, etc ）. This information is stored in a structure variable . The structure type is system declared , The name FILE.

for example ,VS2013 The compiler environment provides stdio.h The header file has the following file type declaration ：

struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
};
typedef struct _iobuf FILE;

Different C Compiler FILE Types don't contain exactly the same content , But it's the same .

Every time you open a file , The system will automatically create a FILE Structural variables , And fill in the information , Users don't have to care about details .

It's usually through a FILE To maintain this FILE Structural variables , This is more convenient to use .

Now we can create a FILE* Pointer variable for :

FILE* pf;// File pointer variable

Definition pf It's a point FILE Pointer variable of type data . You can make pf Point to the file information area of a file （ It's a structural variable ）. Through the information in the file information area, you can access the file . in other words , Through the file pointer variable, you can find the file associated with it .

3.2 Opening and closing of files

Files should be read and written first Open file , After use, you should Close file .

In programming , While opening the file , Will return to one FILE* A pointer variable to the file , It is also equivalent to establishing the relationship between pointer and file .

ANSIC To prescribe the use of fopen Function to open a file ,fclose Incoming closing document Pieces of .

// Open file
FILE * fopen ( const char * filename, const char * mode );
// Close file
int fclose ( FILE * stream );

Open it as follows ：

How files are used	meaning	If the specified file does not exist
“r”（ read-only ）	To enter data , Open an existing text file	error
“w”（ Just write ）	To output data , Open a text file	Create a new file
“a”（ Additional ）	Add data to the end of the text file	Create a new file
“rb”（ read-only ） To enter data ,	Open a binary file	error
wb”（ Just write ）	To output data , Open a binary file	Create a new file
“ab”（ Additional ）	Add data to the end of a binary file	error
“r+”（ Reading and writing ）	For reading and writing , Open a text file	error
“w+”（ Reading and writing ）	For reading and writing , Create a new file	Create a new file
“a+”（ Reading and writing ）	Open a file , Read and write at the end of the file	Create a new file
“rb+”（ Reading and writing ）	Open a binary file for reading and writing	error
“wb+”（ Reading and writing ）	For reading and writing , Create a new binary file	Create a new file
“ab+”（ Reading and writing ）	Open a binary file , Read and write at the end of the file	Create a new file

Code 1 ：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* pf = fopen("code11.c", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Writing documents 

	// Close file 
	fclose(pf);
	pf = NULL;
	return 0;
}

With w The form opens , If not, a new file will be created automatically
Opening it again will overwrite the previous content

4. Sequential reading and writing of files

function	Function name	Apply to
Character input function	fgetc	All input streams
Character output function	fputc	All output streams
Text line input function	fgets	All input streams
Text line output function	fputs	All output streams
Format input function	fscanf	All input streams
Format output function	fprintf	All output streams
Binary input	fread	file
Binary output	fwrite	file

Code 1 :fputc

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* pf = fopen("C:\\Users\\46285\\source\\repos\\code\code11.c", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Writing documents 
	fputc('b', pf);
	fputc('i', pf);
	fputc('t', pf);

	// Close file 
	fclose(pf);
	pf = NULL;

	return 0;
}

Here I open the file by relative path
Pay attention to joining \ Transference

Add ： Flow is a highly abstract concept ,C Language program , Just run , It is turned on by default 3 A flow

stdin - Standard input stream - keyboard
stdout - Standard output stream - The screen
stderr - Standard error flow - The screen

Code 2 :fgetc

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* pf = fopen("code11.c", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Reading documents 
	int ret = fgetc(pf);
	printf("%c\n", ret);
    ret = fgetc(pf);
	printf("%c\n", ret);
	ret = fgetc(pf);
	printf("%c\n", ret);

	// Close file 
	fclose(pf);
	pf = NULL;

	return 0;
}

Code three :fputs

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* pf = fopen("code11.c", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Writing documents - Write in line 
	fputs("abcdef\n", pf);
	fputs("qwertyuiop\n", pf);

	// Close file 
	fclose(pf);
	pf = NULL;
	return 0;
}

Code four :fgets

there num It includes \0

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	char arr[10] = "xxxxxx";
	FILE* pf = fopen("code11.c", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}

	// Reading documents 
	fgets(arr, 4, pf);
	printf("%s\n", arr);

	// Close file 
	fclose(pf);
	pf = NULL;
	return 0;
}

Code five :fscanf and fprintf

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
struct S
{
	char arr[10];
	int num;
	float sc;
};

int main()
{
	struct S s = { "abcdef", 10, 5.5f };
	// Write the formatted data to a file 
	FILE* pf = fopen("code11.c", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	// Reading documents 
	fscanf(pf, "%s %d %f", s.arr, &(s.num), &(s.sc));

	// Print 
	fprintf(stdout, "%s %d %f\n", s.arr, s.num, s.sc);

	// Close file 
	fclose(pf);
	pf = NULL;
	return 0;
}

Code six :fwrite

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
struct S
{
	char arr[10];
	int num;
	float sc;
};

int main()
{
	struct S s = { "abcde", 10, 5.5f };
	// Write in binary form 
	FILE*pf = fopen("code11.c", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Writing documents 
	fwrite(&s, sizeof(struct S), 1, pf);

	// Close file 
	fclose(pf);
	pf = NULL;

	return 0;
}

Binary character or character , Although we can't understand the latter, we can use fread

Code seven :fread

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
struct S
{
	char arr[10];
	int num;
	float sc;
};

int main()
{
	struct S s = {0};
	// Read in binary form 
	FILE*pf = fopen("code11.c", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Reading documents 
	fread(&s, sizeof(struct S), 1, pf);

	printf("%s %d %f\n", s.arr, s.num, s.sc);

	// Close file 
	fclose(pf);
	pf = NULL;

	return 0;
}

fread and fwrite Are for binary ,

Add ： Realization of address book

Mail list - Dynamic version

The address book can store 1000 Personal information , Everyone's information ： name + Age + Gender + Telephone + Address
Increase people's information
Delete the information of the designated person
Modify the information of the designated person
Find the information of the designated person
Sort the information of the address book

Mail list - Document version

When exiting... Is added , The function of saving address book
Added the function of retyping to start loading the address book

4.1 Compare a set of functions ：

scanf/fscanf/sscanf
printf/fprintf/sprintf

sprintf and sscanf

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
struct S
{
	char arr[10];
	int age;
	float f;
};

int main()
{
	struct S s = { "hello", 20, 5.5f };
	struct S tmp = { 0 };

	char buf[100] = {0};
	//sprintf  Put a formatted data , Convert to string 
	sprintf(buf, "%s %d %f", s.arr, s.age, s.f);
	printf("%s\n", buf);

	// from buf Restore a structure data in the string 
	sscanf(buf, "%s %d %f", tmp.arr, &(tmp.age), &(tmp.f));
	printf("%s %d %f\n", tmp.arr, tmp.age, tmp.f);

	return 0;
}

Although the two values are the same , But the form of printing is completely different ,
These two are like the conversion between formatted data and characters

5. Random reading and writing of documents

All of the following code test.txt It's all this

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Read the file 
	int ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	// Close file 
	fclose(pf);
	pf = NULL;

	return 0;
}

5.1 fseek

Locate the file pointer according to its position and offset .

int fseek ( FILE * stream, long int offset, int origin );

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Read the file 
	int ch = fgetc(pf);
	printf("%c\n", ch);

	// Adjust file pointer 
	fseek(pf, -1, SEEK_CUR);
	ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	// Close file 
	fclose(pf);
	pf = NULL;

	return 0;
}

5.2 ftell

Returns the offset of the file pointer from its starting position

long int ftell ( FILE * stream );

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Read the file 
	int ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	// The offset of the pointer from the starting position 
	int ret = ftell(pf);
	printf("%d\n", ret);

	ch = fgetc(pf);
	printf("%c\n", ch);

	// Close file 
	fclose(pf);
	pf = NULL;

	return 0;
}

5.3 rewind

Return the file pointer to the beginning of the file

void rewind ( FILE * stream );

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Read the file 
	int ch = fgetc(pf);
	printf("%c\n", ch);

	ch = fgetc(pf);
	printf("%c\n", ch);

	// Return the file pointer to the starting position 
	rewind(pf);

	// The offset of the pointer from the starting position 
	int ret = ftell(pf);
	printf("%d\n", ret);

	ch = fgetc(pf);
	printf("%c\n", ch);

	// Close file 
	fclose(pf);
	pf = NULL;

	return 0;
}

6. Text files and binaries

According to the organization of data , Data files are called text file perhaps Binary .

Data is stored in memory in binary form , If the output without conversion is to external memory , Namely Binary .

If it's required to use ASCII In the form of code , You need to convert before storing . With ASCII The file stored in the form of characters is writing This document .

How is a data stored in memory ？

All characters are written in ASCII stored , Numerical data can be used either ASCII stored , It can also be stored in binary form .

If there are integers 10000, If the ASCII Code output to disk , The disk is occupied by 5 Bytes （ One byte per character ）, And binary output , On the disk 4 Bytes （VS2019 test ）.

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
//0000 0000 0000 0000 0010 0111 0001 0000
//00 00 27 10
int main()
{
	int a = 10000;
	FILE* pf = fopen("test.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	// Writing documents 
	fwrite(&a, sizeof(int), 1, pf);

	fclose(pf);
	pf = NULL;
	return 0;
}

If you are interested, you can try this one above

7. Determination of the end of file reading

7.1 Misused feof

Keep in mind ： During file reading , Out-of-service feof The return value of the function is directly used to determine whether the end of the file .

It is Apply when the file reading is finished , The judgment is that the read failed and ended , Or end of file

Example ： Write code to test.txt A copy of the document , Generate test2.txt

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* pfread = fopen("test.txt", "r");
	if (pfread == NULL)
	{
		return 1;
	}
	FILE* pfwrite = fopen("test2.txt", "w");
	if (pfwrite == NULL)
	{
		fclose(pfread);
		pfread = NULL;
		return 1;
	}
	// File opened successfully 
	// Read and write files 
	int ch = 0;
	while ((ch = fgetc(pfread)) != EOF)
	{
		// Writing documents 
		fputc(ch, pfwrite);
	}
	
	if (feof(pfread))
	{
		printf(" End of file flag encountered , The file ends normally \n");
	}
	else if(ferror(pfread))
	{
		printf(" File read failed end \n");
	}

	// Close file 
	fclose(pfread);
	pfread = NULL;
	fclose(pfwrite);
	pfwrite = NULL;

	return 0;
}

8. File buffer

ANSIC The standard is “ Buffer file system ” Processing of data files , The so-called buffer file system means that the system automatically opens up a block in memory for each file being used in the program “ File buffer ”. Data output from memory to disk is first sent to a buffer in memory , After the buffer is filled, it is sent to the disk together . If you read data from disk to computer , Then read the data from the disk file and input it into the memory buffer （ Fill the buffer ）, And then send the data from the buffer to the program data area one by one （ Program variables, etc ）. The size of the buffer depends on C The compiler system decides .

As for why there is the concept of buffer , Don't even think about it , To improve efficiency

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <windows.h>
//VS2013 WIN10 Environmental testing 
int main()
{
	FILE* pf = fopen("test.txt", "w");
	fputs("abcdef", pf);// Put the code in the output buffer first 

	printf(" sleep 10 second - The data has been written , open test.txt file , Found no content in the file \n");
	Sleep(10000);
	printf(" Refresh buffer \n");
	fflush(pf);// When the buffer is flushed , Write the data in the output buffer to a file （ disk ）

	printf(" Sleep again 10 second - here , Open again test.txt file , There's something in the file \n");
	Sleep(10000);

	fclose(pf);
	// notes ：fclose When closing a file , It also flushes the buffer 
	pf = NULL;

	return 0;
}

fflush In high version VS It can't be used on (vs2019 Use in fflush useless )

Here we can get a Conclusion ：

Because there is a buffer ,C Language when operating files , You need to flush the buffer or close the file at the end of the file operation , If you don't do , May cause problems in reading and writing files .( Some topics also need to consider the issue of buffer zones )

--------------------------------------------------------------------------------------------------------------------------------- End of this chapter

原网站

版权声明
本文为[LYC_ four hundred and sixty-two million eight hundred and fifty]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/02/202202160419127182.html