5. File operation

The data generated when the program runs are all temporary data , Once the program is finished, it will be released .

Data can be persisted through files

C++ File operations in need to include header files $<fstream>$

There are two file types ：

1. text file ： The document is written in the form of text ASCII The code form is stored in the computer
2. Binary ： The file is stored in the computer in binary form of text , Users can't read them directly .

There are three categories of operation files ：

1. ofstream： Write operations
2. ifstream： Read operations
3. fstream： Read and write operations

5.1 text file

5.1.1 Writing documents

The steps to write a file are as follows ：

1. Include header file #include $<fstream>$
2. Create a flow object ofstream ofs;
3. Open file ofs.open(“ File path ”, Open mode );
4. Writing data ofs<<“ Written data ”;
5. Close file ofs.close();

File open mode ：

Open mode	explain
ios::in	Open a file for reading
ios::out	Open a file for writing
ios::ate	Initial position ： End of document
ios::app	Write the file by appending
ios::trunc	If the file exists, delete it first , To create a
ios::binary	Binary mode

Be careful ： File open mode can be used with , utilize | The operator
for example ： Writing files in binary mode ：ios::binary | ios::out

#include<iostream>
using namespace std;
#include<fstream> //  The header file contains  

//  text file   Writing documents 

void test01()
{
    
	// 1.  Include header file  fstream
	// 2.  Create a flow object 
	ofstream ofs;
	
	// 3.  Specify how to open 
	ofs.open("test.txt", ios::out);
	
	// 4.  Write content 
	ofs << " full name ： Zhang San " <<endl;
	ofs << " Gender ： male " <<endl;
	ofs << " Age ：18" <<endl;
	
	// 5.  Close file 
	ofs.close(); 
		
} 

int main()
{
    
	test01();
	
	system("pause");
	return 0;	
} 

summary ：

1. File operations must contain header files fstream
2. Reading a file can take advantage of ofstream, perhaps fstream class
3. When opening a file, you need to specify the path of the operation file , And how to open it
4. utilize << You can write data to a file
5. Operation completed , To close the file

5.1.2 Reading documents

Reading a file is similar to writing a file , But there are many ways to read

The steps to read the file are as follows ：

1. Include header file #include $<fstream>$
2. Create a flow object ifstream ifs;
3. Open the file and judge whether it is opened successfully ifs.open(“ File path ”, Open mode );
4. Reading data Four reading methods
5. Close file ifs.close()

Example ：

#include<iostream>
using namespace std;
#include<fstream> //  The header file contains  
#include<string>


//  text file   Reading documents  

void test01()
{
    
	// 1  Include header file 
	// 2  Create a flow object 
	ifstream ifs;
	 
	// 3  Open file   And judge whether it is opened successfully 
	ifs.open("test.txt", ios::in);
	if (!ifs.is_open())
	{
    
		cout << " File opening failure " << endl;
		return;
	}
	
	// 4  Reading data 
	//  The first one is 
	//char buf[1024] = {0};
	//while(ifs>>buf) 
	//{
    
	// cout << buf <<endl;
	//}
	
	//  The second kind 
	//char buf[1024] = {0};
	//while (ifs.getline(buf, sizeof(buf)))
	//{
    
	// cout << buf << endl;
	//}
	
	//  The third kind of 
	//string buf;
	//while (getline(ifs, buf))
	//{
    
	// cout << buf << endl;
	//} 
	
	//  A fourth 
	char c;
	while((c = ifs.get()) != EOF)  		// EOF end of file
	{
    
		cout << c;
	}
	 
	
	// 5  Close file  
	ifs.close();
} 

int main()
{
    
	test01();
	
	system("pause");
	return 0;	
} 

summary ：

1. Reading a file can take advantage of ifstream, perhaps fstream class
2. utilize is_open Function to determine whether the file is opened successfully
3. close Close file

5.2 Binary

Read and write files in binary mode

The opening mode should be specified as ：ios::binary

5.2.1 Writing documents

Binary file writing mainly uses stream object to call member function write

The function prototype ：ostream& write(const char * buffer, int len);

Parameter interpretation ： Character pointer buffer Point to a piece of memory .len Is the number of bytes read and written .

Example ：

#include<iostream>
using namespace std;
#include<fstream> 

//  Binary   Writing documents 
class Person
{
    
public:
	char m_Name[64]; 	//  full name  
	int m_Age;			//  Age  
		
};

void test01()
{
    
	// 1  Include header file 
	// 2  Create a flow object 
	ofstream ofs;
	
	// 3  Open file 
	ofs.open("person.txt", ios::out | ios::binary);
	
	// 4  Writing documents 
	Person p = {
    " Zhang San ", 18};
	ofs.write((const char *)&p, sizeof(Person));
	
	
	// 5  Close file  
	ofs.close();
	
} 

int main() {
    
	
	test01();
	
	system("pause");
	return 0;
}

summary ：
File output stream object Can pass write function , Write data in binary mode

5.2.2 Reading documents

Reading files in binary mode mainly uses stream objects to call member functions read

The function prototype ：istream& read(char *buffer, int len);

Parameter interpretation ： Character pointer buffer Point to a piece of memory .len Is the number of bytes read and written .

Example ：

#include<iostream>
using namespace std;
#include<fstream> 

class Person
{
    
public:
	char m_Name[64];		//  full name  
	int m_Age;				//  Age  
}; 


//  Binary   Reading documents  
void test01()
{
    
	// 1  Include header file 
	
	// 2  Create a flow object 
	ifstream ifs; 
	
	// 3  Open file   Judge whether the file is opened successfully  
	ifs.open("person.txt", ios::in | ios::binary);
	
	if(!ifs.is_open())
	{
    
		cout << " File opening failure " << endl;
		return;
	}
	
	// 4  Reading documents 
	Person p;
	ifs.read((char *)&p, sizeof(Person));
	cout << " full name ：" << p.m_Name << "  Age ： " << p.m_Age << endl; 
	
	
	// 5  Close file  
	ifs.close();
} 


int main() {
    
	
	test01();
	
	system("pause");
	return 0;
}

File input stream object Can pass readh function , Read data in binary mode