• C++的IO流

    目录

    1.C语言的输入与输出

    2.流是什么

    3.C++的IO流

    4.C++文件IO流

    5.StringStream 

            

     

    1.C语言的输入与输出

    (1)在C语言当中，我们使用最频繁的输入输出方式就是scanf与printf：

    • scanf： 从标准输入设备（键盘）读取数据，并将读取到的值存放到某一指定变量当中。
    • printf： 将指定的数据输出到标准输出设备（屏幕），使用时需要注意宽度输出和精度输出的控制。

    C语言借助了相应的缓冲区来进行输入与输出:
     

            

    (2)对输入输出缓冲区的理解：

    • 可以屏蔽掉低级I/O的实现。 低级I/O的实现依赖操作系统本身内核的实现，所以如果能够屏蔽这部分的差异，可以很容易写出可移植的程序。
    • 可以使用这部分的内容实现“行”读取的行为。 对于计算机而言是没有“行”这个概念的，有了这部分，就可以定义“行”的概念，然后解析缓冲区的内容，返回一个“行”。
       

                            

                                            

    2.流是什么

    • “流”即是流动的意思，是物质从一处向另一处流动的过程，是对一种有序连续且有方向性的数据的抽象描述。
    • C++流是指信息从外部输入设备（如键盘）向计算机内部（如内存）输入和从计算机内部向外部输出设备（如显示器）输出的过程。这种输入输出的过程被形象的比喻为“流”。
    • 流的特性： 有序连续、具有方向性。
    • 为了实现这种流动，C++定义了I/O标准类库，当中的每个类都称为流/流类，用以完成某方面的功能。

                            

                                                    

                    

    3.C++的IO流

    C++系统实现了一个庞大的类库，其中ios为基类，其他类都是直接或间接派生自ios类 :

                             

     (1)C++标准IO流

    C++标准库提供了4个全局流对象（cin、cout、cerr、clog）：

    • 使用cout进行标准输出，即数据从内存流向控制台（显示器）。
    • 使用cin进行标准输入，即数据通过键盘输入到程序中。
    • 使用cerr进行标准错误的输出。
    • 使用clog进行日志的输出。

    从上图可以看出，cout、cerr、clog都是由ostream类实例化出的三个不同的对象，因此这三个对象基本没什么区别，只是应用场景不同

                            

    ①在使用cin、cout时必须要包含iostream文件，并引入std标准命名空间

    1. #include  //包含iostream文件
    2. using namespace std; //引入std标准命名空间
    3.  
    4. int main()
    5. {
    6. 	int a = 0;
    7. 	cin >> a;
    8. 	cout << a << endl;
    9. 	return 0;
    10. }

    • 或是在使用时指定cout和cin所属的命名空间

    1. #include  //包含iostream文件
    2. int main()
    3. {
    4. 	int a = 0;
    5. 	std::cin >> a; //使用时指定所属命名空间
    6. 	std::cout << a << std::endl; //使用时指定所属命名空间
    7. 	return 0;
    8. }

                     

    ② cin为缓冲流。键盘输入的数据保存在缓冲区中，当要提取时，是从缓冲区中提取。如果一次输入过多，则多余的数据会留在缓冲区以供之后提取，如果输入错了，必须在回车之前进行修改，回车键按下就无法进行修改了，只有把输入缓冲区中的数据取完后，才会要求输入新的数据。 

    • 若在第一次输入时便以空格为分隔输入了两个数据，则在下一次需要提取数据的时候就直接从缓冲区进行提取。 
    1. #include 
    2. using namespace std;
    3.  
    4. int main()
    5. {
    6. 	int a = 0, b = 0;
    7. 	cin >> a; //输入：1 2
    8. 	cout << a << endl;
    9.  
    10. 	cin >> b; //直接从输入缓冲区提取
    11. 	cout << b << endl;
    12. 	return 0;
    13. }

                                     

    ③输入数据类型必须与要提取的数据类型一致，否则出错。出错只是在流的状态字state中对应位置（置1），程序继续。

                                            

    ④空格和回车都可以作为数据之间的分隔符，所以多个数据可以在一行输入，也可以分行输入。但如果是字符型和字符串，则空格无法用cin输入，字符串中也不能有空格，回车符也无法读入。

    • 例如，我们使用cin无法将含空格的字符串"hello world"输入到string对象中。
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	string s;
    8. 	cin >> s;          //输入："hello world"
    9. 	cout << s << endl; //输出："hello"
    10. 	return 0;
    11. }
    • 对于含有空格的字符串，我们需要使用getline函数进行读取，因为getline函数只有遇到’\n’才会停止读取。
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	string s;
    8. 	getline(cin, s);   //输入："hello world"
    9. 	cout << s << endl; //输出："hello world"
    10. 	return 0;
    11. }

                            

    ⑤. cin和cout可以直接输入和输出内置类型的数据。因为标准库已经将所有内置类型的输入和输出进行了重载。 

                                             ​​​​​​​

                             

     ⑥对于自定义类型，如果要支持cin和cout的标准输入输出，则需要对<<和>>进行重载。

    • istream&  operator>>(istream& in, Date& d)   return  in   //返回cin 对象，支持连续输入
    • ostream& operator<<(ostream& out, const Date& d)  return out  //返回cout 对象，支持连续输出
    1. #include 
    2. using namespace std;
    3. class Date
    4. {
    5.     -设置为友员,类外函数可以访问类内变量
    6. 	friend istream& operator>>(istream& in, Date& d); 
    7. 	friend ostream& operator<<(ostream& out, const Date& d);
    8. public:
    9. 	Date(int year = 0, int month = 0, int day = 0)
    10. 		:_year(year)
    11. 		, _month(month)
    12. 		, _day(day)
    13. 	{}
    14. private:
    15. 	int _year;
    16. 	int _month;
    17. 	int _day;
    18. };
    19.  
    20. //对>>进行重载
    21. istream& operator>>(istream& in, Date& d)
    22. {
    23. 	in >> d._year >> d._month >> d._day;
    24. 	return in;
    25. }
    26.  
    27. //对<<进行重载
    28. ostream& operator<<(ostream& out, const Date& d)
    29. {
    30. 	out << d._year << "-" << d._month << "-" << d._day;
    31. 	return out;
    32. }
    33.  
    34. int main()
    35. {
    36. 	Date d;
    37. 	cin >> d;          //输入：1 2 3
    38. 	cout << d << endl; //输出：1-2-3
    39. 	return 0;
    40. }

                             

    ⑦.在线OJ中的输入和输出。

    • C语言
    1. while (scanf("%d", &a) != EOF)
    2. {
    3. 	//...
    4. }
    • C++
    1. while (cin >> a)
    2. {
    3. 	//...
    4. }

                             

    ⑧建议

    •  C++尽量去用cin和cout，能用它就用他
    • 用cout和cin不方便的地方，再去用scanf和printf (例如精度控制)

                            

                                    

    4.C++文件IO流

    •  C++根据文件内容的数据格式将文件分为二进制文件和文本文件，采用文件流对象操作文件的一般步骤如下：

                     

    ①定义一个文件流对象 , 操作文件的类有三个 

    类对应操作场景
    ofstream将数据写入文件
    ifstream将数据读出文件
    fstream输入输出都能用(读+写)

                     

     ②使用文件流对象的成员函数打开一个磁盘文件，使得文件流对象和磁盘文件之间建立联系。

    • 文件常见的打开方式如下：
    打开方式功能
    in以读的方式打开文件
    out以写的方式打开文件
    binary以二进制方式对文件进行操作
    ate输出位置从文件的末尾开始
    app以追加的方式对文件进行写入
    trunc先将文件内容清空再打开文件

                     

    ③使用提取和插入运算符对文件进行读写操作，或使用成员函数进行读写。

    • 对文件进行提取和插入操作的常用成员函数：
    成员函数功能
    put插入一个字符到文件
    write插入一段字符到文件
    get从文件提取字符
    read从文件提取多个字符
    tellg获取当前字符在文件当中的位置
    seekg设置对文件进行操作的位置
    >>运算符重载将数据形象地以“流”的形式进行输入
    <<运算符重载将数据形象地以“流”的形式进行输出

                     

    ④关闭文件。 

    文件流对象.close();

                                             

    (1)读取字符的三种方式

    1. void readfile()
    2. {
    3. 	ifstream ifs("test.cpp");
    4. 	char ch;
    5.     
    6.     -1
    7. 	while ((ch = ifs.get()) != eof)   
    8. 	{
    9. 		cout << ch;
    10. 	}
    11.  
    12.     -2
    13. 	while (ifs.get(ch))   
    14. 	{
    15. 		cout << ch;
    16. 	}
    17.      
    18.     -3
    19. 	while (ifs)  
    20. 	{
    21. 		cout << (char)ifs.get();
    22. 	}
    23. }

                     

    (2)以二进制的方式操作文件

    • 对文件进行写入操作：
    1. //以二进制的形式对文件进行写入
    2. void WriteBinary()
    3. {
    4. 	ofstream ofile; //定义文件流对象- 只写
    5. 	ofile.open("test.bin", ofstream::out | ofstream::binary); //以二进制写入的方式打开test.bin文件
    6. 	char data[] = "2022-8-16";
    7. 	ofile.write(data, strlen(data)); //将data字符串写入文件
    8. 	ofile.put('!'); //将字符'!'写入文件
    9. 	ofile.close(); //关闭文件
    10. }
    • 对文件进行读取操作： 
    1.  //以二进制的形式对文件进行读取
    2. void ReadBinary()
    3. {
    4.     ifstream ifile; //定义文件流对象-读
    5.     ifile.open("test.bin", ofstream::in | ofstream::binary); //以二进制读取的方式打开test.bin文件
    6.     ifile.seekg(0, ifile.end); //跳转到文件末尾
    7.     int length = ifile.tellg(); //获取当前字符在文件当中的位置，即文件的字符总数
    8.     ifile.seekg(0, ifile.beg); //重新回到文件开头
    9.     char data[100];
    10.     ifile.read(data, length); //将文件当中的数据全部读取到字符串data当中
    11.  
    12.     cout << data << endl;
    13.     ifile.close(); //关闭文件
    14. }

                     

    (3)以文本方式操作文件

    •  对文件进行写入操作：
    1. //以文本的形式对文件进行写入
    2. void WriteTxt()
    3. {
    4. 	ofstream ofile; //定义文件流对象
    5. 	ofile.open("test.txt"); //以写入的方式打开test.txt文件
    6. 	char data[] = "2022-8-16";
    7. 	ofile.write(data, strlen(data)); //将data字符串写入文件
    8. 	ofile.put('!'); //将字符'!'写入文件
    9. 	ofile.close(); //关闭文件
    10. }
    • 对文件进行读取操作：
    1. //以文本的形式对文件进行读取
    2. void ReadTxt()
    3. {
    4. 	ifstream ifile; //定义文件流对象
    5. 	ifile.open("test.txt"); //以读取的方式打开test.txt文件
    6. 	ifile.seekg(0, ifile.end); //跳转到文件末尾
    7. 	int length = ifile.tellg(); //获取当前字符在文件当中的位置，即文件的字符总数
    8. 	ifile.seekg(0, ifile.beg); //重新回到文件开头
    9. 	char data[100];
    10. 	ifile.read(data, length); //将文件当中的数据全部读取到字符串data当中
    11.  
    12. 	cout << length << endl;
    13. 	cout << data << endl;
    14. 	ifile.close(); //关闭文件
    15. }

                     

    (4)使用>>和<<对文件进行操作

    • 对文件进行写入操作：
    1. //对文件进行写入操作
    2. void WriteFile()
    3. {
    4. 	ofstream ofs("data.txt"); //定义文件流对象，并打开文件
    5. 	ofs << "2022-8-16"; //字符串“流入”文件
    6. 	ofs.close(); //关闭文件
    7. }
    • 对文件进行读取操作： 
    1. //对文件进行读取操作
    2. void ReadFile()
    3. {
    4. 	ifstream ifs("data.txt"); //定义文件流对象，并打开文件
    5. 	char data[100];
    6. 	ifs >> data; //文件数据“流入”字符串data
    7. 	ifs.close(); //关闭文件
    8. }

                     

    (5)补充

    • 可以在定义文件流对象的同时指定将要打开的文件名，以及文件的打开方式。
    •  使用ofstream类对象的open函数时，若不指定打开方式，则默认以写的方式打开文件；使用ifstream类对象的open函数时，若不指定打开方式，则默认以读的方式打开文件；使用fstream类对象的open函数时，若不指定打开方式，则默认以写+读的方式打开文件。 
    • 二进制读写简单，高效快捷。缺点︰除了字符和字符串，从内存中写到文件，查看时是乱码

                    

                    

                             

    5.StringStream 

     (1)在C语言中，我们若是想要将一个整型变量的数据转化为字符串格式有两种方法

    • 使用itoa函数进行转化
    1. int a = 10;
    2. char arr[10];
    3. itoa(a, arr, 10); //将整型的a转化为十进制字符数字存储在字符串arr当中
    • 使用sprintf函数进行转化。
    1. int a = 10;
    2. char arr[10];
    3. sprintf(arr, "%d", a); //将整型的a转化为字符串格式存储在字符串arr当中
    • 虽然itoa函数和sprintf函数都能完成转化，但是在两个函数在转化时，都需要先给出保存结果的空间，而空间的大小是不太好界定的，除此之外，转化格式不匹配时，可能还会得到错误的结果甚至程序崩溃。 

                                                     

    (2)stringstream类对象

    • 在程序当中如果想要使用stringstream，必须要包含头文件sstream。在该头文件下，有三个类：
    类对应操作场景
    ostringstream输出操作
    istringstream输入操作
    stringstream输入操作+输出操作

                                     

    ①使用stringstream类，将数值类型数据格式化为字符串 

    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5. int main()
    6. {
    7. 	int a = 10;
    8. 	string sa;
    9. 	stringstream s;
    10. 	s << a; //将int类型的a放入输入流
    11. 	s >> sa; //从s中抽取前面插入的int类型的值，赋值给string类型（方式一）
    12. 	cout << sa << endl;
    13.  
    14. 	s.str(""); //将stringstream底层管理的string对象设置为""。
    15. 	s.clear(); //将上次转换状态清空掉
    16.  
    17. 	//进行下一次转换
    18. 	double b = 3.14;
    19. 	s << b;
    20. 	sa = s.str(); //获取stringstream中管理的string类型（方式二）
    21. 	cout << sa << endl;  // 3.14
    22. 	return 0;
    23. }
    // clear()
    // 注意多次转换时，必须使用 clear 将上次转换状态清空掉
    // stringstreams 在转换结尾时 ( 即最后一个转换后 ), 会将其内部状态设置为 badbit
    // 因此下一次转换是必须调用 clear() 将状态重置为 goodbit 才可以转换
    // 但是 clear() 不会将 stringstreams 底层字符串清空掉
    // s.str("");
    // 将 stringstream 底层管理 string 对象设置成 "",
    // 否则多次转换时，会将结果全部累积在底层 string 对象中

                     

    ②使用stringstream类，字符串拼接 

    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5. int main()
    6. {
    7. 	string rets;
    8.     int ret1;
    9.     char ret2[10];
    10. 	stringstream s;
    11. 	s << "2022" << "8-16"; //将多个字符串放入stringstream中
    12. 	s >> rets; //方式一获取
    13. 	cout << rets << endl;
    14.     
    15.     
    16.     -通过空格分割
    17.     /*
    18.     s.str(""); //将stringstream底层管理的string对象设置为空字符串
    19. 	s.clear(); //将上次转换状态清空掉
    21.     s << "2022" << " " << "8-16";
    22.     s >> ret1 >> ret2;
    23.     cout << ret1 <
    24.     cout << ret2 << endl; -  8-16
    25.     */
    26.  
    27. 	s.str(""); //将stringstream底层管理的string对象设置为空字符串
    28. 	s.clear(); //将上次转换状态清空掉
    29.  
    30. 	s << "Xiao" << " " << "Mi" << " " << "MIUI"; //将多个字符串放入stringstream中
    31. 	rets = s.str(); //方式二获取
    32. 	cout << rets << endl;
    33. 	return 0;
    34. }

                     

    (3)注意事项

    • stringstream实际是在底层维护了一个string类型的对象用来保存结果。
    • stringstream在转换结尾时（即最后一个转换后），会将其内部状态设置为badbit，因此在下一次转换前必须调用clear将状态重置为goodbit才可以转换，但clear不会将stringstream底层的string对象清空。
    • 可以使用s.str("")的方式将stringstream底层的string对象设置为空字符串，否则多次转换时，会将结果全部累积在底层string对象中。
    • 获取stringstream转换后的结果有两个方法，一是使用>>运算符之间从流当中提取，二是使用s.str( )获取stringstream底层的string对象。
    • stringstream使用string类对象代替字符数组，可以避免缓冲区溢出的危险，而且其会对参数类型进行推演，不需要格式化控制，也不会存在格式化失败的风险，因此使用更方便，更安全。
       
  • 相关阅读:
    一年前 LLM & AGI 碎片化思考与回顾系列④ · System2慢思考下的暴力美学
    复旦微开发过程中遇到的问题总结（三）
    机器学习入门案例（2）之使用逻辑回归预测房子是否能被租出去
    企业图档加密系统
    算法训练营day48，动态规划16
    【网络】网络扫盲篇 ——用简单语言和图解带你入门网络
    零基础学Java（11）自定义类
    单片机驱动LCD
    Fooocus框架代码分析
    【英雄哥六月集训】第 24天: 线段树
  • 原文地址：https://blog.csdn.net/m0_52169086/article/details/126357002