C++怎么实现将内容写入文件

其他教程   发布日期:2025年04月02日   浏览次数:199

这篇文章主要介绍“C++怎么实现将内容写入文件”,在日常操作中,相信很多人在C++怎么实现将内容写入文件问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”C++怎么实现将内容写入文件”的疑惑有所帮助!接下来,请跟着小编一起来学习吧!

一、C语言输出内容到文件

使用 C 的文件 I/O 函数,例如 fopen(),fprintf(),fputs() 和 fwrite() 等。这些函数由 C 语言中的标准库 stdio.h 提供。

  1. #include <stdio.h>
  2. int main()
  3. {
  4. // 以写入模式打开文件
  5. FILE *fp = fopen("myfile.txt", "w");
  6. if (fp == NULL)
  7. {
  8. // 打开文件失败
  9. printf("Error opening file!
  10. ");
  11. return 1;
  12. }
  13. // 使用 fprintf() 写入字符串
  14. fprintf(fp, "Hello, world!
  15. ");
  16. // 使用 fputs() 写入字符串
  17. fputs("This is another string.
  18. ", fp);
  19. // 使用 fwrite() 写入二进制数据
  20. int num = 42;
  21. fwrite(&num, sizeof(int), 1, fp);
  22. // 关闭文件
  23. fclose(fp);
  24. return 0;
  25. }

在这个代码示例中,我们首先使用 fopen() 函数以写入模式打开了一个文件,然后使用 fprintf(),fputs() 和 fwrite() 向文件写入了字符串和二进制数据,最后使用 fclose() 函数关闭了文件。请注意,在使用 fwrite() 函数写入二进制数据时,我们需要提供要写入的数据的指针,以及每个数据单元的大小和要写入的数据单元数。

二、C++文件输入/输出流

此种是C++标准的输入输出,一般不会带来字符种类不同引发的问题,比如宽字节和窄字节之间的区别,肯能我们打开文件内容都一样,但是涉及加密、编码等操作宽窄字符是有区别的,这个是有教训的,牢记。

下面是使用 C++ 中的文件输入/输出流的代码示例:

  1. #include <fstream>
  2. #include <iostream>
  3. int main()
  4. {
  5. // 以写入模式打开文件
  6. std::ofstream out("myfile.txt");
  7. if (!out)
  8. {
  9. // 打开文件失败
  10. std::cerr << "Error opening file!" << std::endl;
  11. return 1;
  12. }
  13. // 使用流操作符 << 写入字符串
  14. out << "Hello, world!" << std::endl;
  15. out << "This is another string." << std::endl;
  16. // 使用 write() 写入二进制数据
  17. int num = 42;
  18. out.write(reinterpret_cast<char*>(&num), sizeof(int));
  19. // 关闭文件
  20. out.close();
  21. // 以读取模式打开文件
  22. std::ifstream in("myfile.txt");
  23. if (!in)
  24. {
  25. // 打开文件失败
  26. std::cerr << "Error opening file!" << std::endl;
  27. return 1;
  28. }
  29. // 使用流操作符 >> 读取字符串
  30. std::string s;
  31. in >> s;
  32. std::cout << s << std::endl;
  33. // 使用 read() 读取二进制数据
  34. in.read(reinterpret_cast<char*>(&num), sizeof(int));
  35. std::cout << num << std::endl;
  36. // 关闭文件
  37. in.close();
  38. return 0;
  39. }

在这个代码示例中,我们首先使用 ofstream 对象以写入模式打开了一个文件,然后使用流操作符 << 向文件写入了字符串,使用 write() 写入了二进制数据,最后使用 close() 关闭了文件。然后,我们使用 ifstream 对象以读取模式打开了同一个文件,使用流操作符 >> 读取了字符串,使用 read()读取了二进制数据,最后使用 close() 关闭了文件。

请注意,当使用 write() 写入二进制数据时,我们需要将要写入的数据的指针转换为 char* 类型,并提供每个数据单元的大小和要写入的数据单元数。当使用 read() 读取二进制数据时,我们也需要将要读取的数据的指针转换为 char* 类型,并提供每个数据单元的大小和要读取的数据单元数。

另一个 C++ 标准库中的文件输入/输出流类型叫做 filebuf,它可以通过标准输入/输出流来读写文件。例如,下面是使用 filebuf 的代码示例:

  1. #include <fstream>
  2. #include <iostream>
  3. int main()
  4. {
  5. // 以写入模式打开文件
  6. std::filebuf fb;
  7. fb.open("myfile.txt", std::ios::out);
  8. if (!fb.is_open())
  9. {
  10. // 打开文件失败
  11. std::cerr << "Error opening file!" << std::endl;
  12. return 1;
  13. }
  14. // 将文件缓冲区关联到标准输出流
  15. std::ostream out(&fb);
  16. // 使用标准输出流写入字符串
  17. out << "Hello, world!" << std::endl;
  18. out << "This is another string." << std::endl;
  19. // 使用 sputn() 写入二进制数据
  20. int num = 42;
  21. fb.sputn(reinterpret_cast<char*>(&num), sizeof(int));
  22. // 关闭文件
  23. fb.close();
  24. // 以读取模式打开文件
  25. fb.open("myfile.txt", std::ios::in);
  26. if (!fb.is_open())
  27. {
  28. // 打开文件失败
  29. std::cerr << "Error opening file!" << std::endl;
  30. return 1;
  31. }
  32. // 将文件缓冲区关联到标准输入流
  33. std::istream in(&fb);
  34. // 使用标准输入流读取字符串
  35. std::string s;
  36. in >> s;
  37. std::cout << s << std::endl;
  38. // 使用 sgetn() 读取二进制数据
  39. fb.sgetn(reinterpret_cast<char*>(&num), sizeof(int));
  40. std::cout << num << std::endl;
  41. // 关闭文件
  42. fb.close();
  43. return 0;
  44. }

在这个代码示例中,我们首先使用 filebuf 对象以写入模式打开了一个文件,然后将文件缓冲区关联到标准输出流,使用标准输出流写入字符串,使用 sputn() 写入了二进制数据,最后使用 close() 关闭了文件。然后,我们使用 filebuf 对象以读取模式打开了同一个文件,将文件缓冲区关联到标准输入流,使用标准输入流读取字符串,使用 sgetn() 读取了二进制数据,最后使用 close() 关闭了文件。 请注意,当使用 sputn() 写入二进制数据时,我们需要将要写入的数据的指针转换为 char* 类型,并提供每个数据单元的大小和要写入的数据单元数。当使用 sgetn() 读取二进制数据时,我们也需要将要读取的数据的指针转换为 char* 类型,并提供每个数据单元的大小和要读取的数据单元数。希望这些代码示例能帮助您理解 C++ 中的文件输入/输出流的使用方法。

三、文件输入/输出流迭代器

你是不是曾经有这样的烦恼,想将数组或者一堆类型一样的数据写入文件,for循环太麻烦。其实,要想简单有个前提,就是你的数据支持迭代器,例如vector这种类型,C++内部对其实现了迭代功能(iterator),那么将数据一个一个写入非常方便。

在使用文件输入/输出流迭代器之前,你需要先包含下面的头文件:

  1. #include <fstream>
  2. #include <iterator>

然后,你可以使用下面的代码来写入数据到文件,这段代码会将 data 中的数据写入到文件 "output.txt" 中,并在每个数据之间添加一个空格:

  1. std::ofstream out_file("output.txt");
  2. std::ostream_iterator<int> out_iter(out_file, " ");
  3. std::vector<int> data = {1, 2, 3, 4, 5};
  4. std::copy(data.begin(), data.end(), out_iter);
  5. out_file.close();

读取文件中的数据也很简单,可以使用下面的代码,这段代码会从文件 "input.txt" 中读取数据,并将数据存储在 vector 中。文件输入/输出流迭代器很方便,因为它们可以像使用普通迭代器一样使用,可以很容易地编写模板代码。

四、C++ 中的文件输入/输出流缓冲区

首先,你需要包含下面的头文件:

  1. #include <fstream>
  2. #include <iostream>

接下来,你可以使用下面的代码来写入数据到文件:

  1. std::ofstream out_file("output.txt");
  2. std::streambuf* buf = out_file.rdbuf();
  3. int data = 123;
  4. buf->sputn((char*)&data, sizeof(int));
  5. out_file.close();

上面这段代码会将数据 123 写入到文件 "output.txt" 中。

读取文件中的数据也很简单,可以使用下面的代码:

  1. std::ifstream in_file("input.txt");
  2. std::streambuf* buf = in_file.rdbuf();
  3. int data;
  4. buf->sgetn((char*)&data, sizeof(int));
  5. in_file.close();

上面这段代码会从文件 "input.txt" 中读取一个整数,并将它存储在变量 data 中。

使用文件输入/输出流缓冲区可以直接操纵底层文件描述符,这使得你可以实现更底层的文件操作。但是,这也意味着你需要自己处理底层细节,比如字节序转换等等小问题。

五、C++ 中的文件输入/输出流预定义的操纵符

头文件:

  1. #include <fstream>
  2. #include <iostream>

接下来,你可以使用下面的代码来写入数据到文件,这段代码会将数据 123 写入到文件 "output.txt" 中,并在末尾添加一个换行符。

  1. std::ofstream out_file("output.txt");
  2. int data = 123;
  3. out_file << data << std::endl;
  4. out_file.close();

你也可以使用 std::flush 操纵符来立即刷新文件输出缓冲区,例如:

  1. std::ofstream out_file("output.txt");
  2. int data = 123;
  3. out_file << data << std::flush;
  4. out_file.close();

这段代码会将数据 123 写入到文件 "output.txt" 中,并立即刷新文件输出缓冲区。

以上就是C++怎么实现将内容写入文件的详细内容,更多关于C++怎么实现将内容写入文件的资料请关注九品源码其它相关文章!