C + + Learning Note-c++ Read and write to TXT file

I. Input and output of the file

Header file FStream defines three types of supporting files Io:ifstream reading data from a given file, Ofstream writing data to a given file, and fstream reading to the specified data. These types are like the operations of CIN and cout, we can read and write files with the IO operator, and we can use Getline to fetch data from a ifstream.

1. Getline () function

The function prototypes for Getline are:

[CPP]View Plaincopy

1. istream& Getline (istream& is, string& str, char delim);
2. istream& Getline (istream&& is, string& str, char delim);
3. istream& Getline (istream& is, string& str);
4. istream& Getline (istream&& is, string& str);

Usually we use the Getline function to read an entire line, which takes an input stream and a string object, and the function reads the content from the given input stream until it encounters a newline character, and then deposits the read into a string object.

In addition, when the function is istream& getline (istream& is, string& str, char delim), the function encounters Delim also stops.

2. Using File Stream objects

When we want to read a file, we can define a file stream object and associate the object with the file, each of which defines a member function called open to complete a series of system-related operations.

The prototype of the Open function is:

[CPP]View Plaincopy

1. VOID Open (const char* filename, ios_base::openmode mode = ios_base::out);
2. VOID Open (const string& filename, Ios_base::openmode mode = ios_base::out);

There are several types of file modes (mode):

[CPP]View Plaincopy

1. Ofstream outfile ("E:\\out.txt", Ofstream::app);

The code above opens the OUT.txt file, and if it does not exist, the system creates the TXT file and navigates to the end of the file.
Open files must be closed after use, FStream provides the member function close () to complete this operation.

Example: reading data from a hello.txt file and writing it to OUT.txt

[CPP]View Plaincopy

2. #include "stdafx.h"
4. #include <vector>
6. #include <string>
8. #include <fstream>
10. #include <iostream>
12. Using namespace std;
14. int _tmain (int argc, _tchar* argv[])
16. {
18. Ifstream myfile ("E:\\hello.txt");
20. Ofstream outfile ("E:\\out.txt", Ofstream::app);
22. string temp;
24. if (!myfile.is_open ())
26. {
28. cout << "File not successfully opened" << Endl;
30. }
32. While (Getline (myfile,temp))
34. {
36. outfile<<temp;
38. }
40. Myfile.close ();
42. return 0;
44. }

Two, a string stream

The string header file defines three types to support memory Io,istringstream writing data to a string, Ostringstream reading data from a string, StringStream can read data from a string or write data to a string, just as a string is an IO stream.

1, the use of Istringstream

[CPP]View Plaincopy

2. #include "stdafx.h"
4. #include <string>
6. #include <sstream>//header files required for the use of Istringstream
8. #include <iostream>
10. Using namespace std;
12. int _tmain (int argc, _tchar* argv[])
14. {
16. String str = "I am a Boy";
18. Istringstream is (str);
20. string S;
22. While (is >> s)
24. {
26. cout << s << endl;
28. }
30. return 0;
32. }

The output is:

I

Am

A

Boy

Example: Write a program that saves rows from a file in a vector<string>, and then uses Istringstream to read a data element from a vector, reading one word at a time.

[CPP]View Plaincopy

2. #include "stdafx.h"
4. #include <vector>
6. #include <string>
8. #include <fstream>
10. #include <sstream>
12. #include <iostream>
14. Using namespace std;
16. int _tmain (int argc, _tchar* argv[])
18. {
20. Vector<string> VEC;
22. Ifstream myfile ("E:\\hello.txt");
24. string temp;
26. if (!myfile.is_open ())
28. {
30. cout << "File not successfully opened" << Endl;
32. }
34. While (Getline (myfile,temp))
36. {
38. Vec.push_back (temp);
40. }
42. For (Auto it = Vec.begin (); It! = Vec.end (); it++)
44. {
46. cout << *it << Endl;
48. }
50. cout << "-----------------use Istringstream------------------------" << Endl;
52. For (Auto it = Vec.begin (); It! = Vec.end (); it++)
54. {
58. Istringstream record (*it);
60. string S;
62. While (record >> s)
64. cout << s << endl;
66. }
68. return 0;
70. }

Operation Result:

The following discussion is transferred from www.cndev-lab.com, program author: Guan Ning

[CPP]View Plaincopy

2. #i nclude <iostream>
4. #i nclude <sstream>
6. Using namespace std;
8. int main ()
10. {
12. Istringstream ISTR;
14. Istr.str ("1 56.7",);
16. //The above two processes can be simply written as Istringstream istr ("1 56.7");
18. cout << istr.str () <<endl;
20. int A;
22. float B;
24. istr>>a;
26. cout<<a<<endl;
28. istr>>b;
30. cout<<b<<endl;
32. System ("pause");
34. }

In the above example, when constructing a string stream, the space becomes the internal boundary of the string parameter, and the input "assignment" operation of a A/b object in the example proves this, and the space of the string becomes the decomposition point of the integer data and the floating-point data. Using the method of demarcation we actually completed the split conversion process of string-to-integer object and floating-point object.

The use of the STR () member function allows the Istringstream object to return a string string, such as the output operation in this example (Cout<<istr.str ();).

2, the use of Ostringstream

Ostringstream is also constructed from a string object, and the Ostringstream class inserts a character into a string.
The Ostringstream constructor is as follows:

[CPP]View Plaincopy

1. Ostringstream::ostringstream (string str);

The following discussion is transferred from www.cndev-lab.com, program author: Guan Ning

[CPP]View Plaincopy

2. #i nclude <iostream>
4. #i nclude <sstream>
6. #i nclude <string>
8. Using namespace std;
10. int main ()
12. {
14. Ostringstream Ostr;
16. //ostr.str ("abc");//If a string parameter is set at the time of construction, then the increment operation does not increase from the end, but modifies the original data, and the excess portion grows
18. Ostr.put (' d ');
20. Ostr.put (' e ');
22. ostr<<"FG";
26. String gstr = Ostr.str ();
28. cout<<gstr;
30. System ("pause");
32. }

In the previous example code, we can continuously insert a single character or string into the ostr by using the put () or left-shift operator, and return the full string data after the growth through the STR () function, but it is worth noting that when the object is constructed with string data in it, Then the growth operation will not increase from the end, but modify the original data, beyond the growth of the part.

C + + Learning Note-c++ Read and write to TXT file