C++中文件流(fstream)的使用方法及示例

合集下载

fstream的用法

fstream的用法fstream是C++标准库中的一个类，用于处理文件输入输出操作。

使用fstream类可以方便地对文件进行读写、复制、删除等操作。

下面介绍fstream的基本用法。

一、声明fstream对象使用fstream类之前，需要先声明一个fstream对象。

对象名通常以文件名开头，后接一个冒号和文件打开模式，如“fstreamfile_name:app”。

1.文件打开模式：fstream提供了多种文件打开模式，包括“in”（只读模式）、“out”（只写模式）、“app”（追加模式）和“binary”（二进制模式）等。

根据需要选择合适的文件打开模式。

2.声明对象：在程序中声明一个fstream对象，例如：```cppfstreamfile_name;```二、打开文件使用fstream对象之前，需要先打开文件。

可以使用open()函数打开文件，例如：```cppfile_name.open("example.txt",ios::app);```上述代码将文件“example.txt”以追加模式打开。

如果文件不存在，则会创建一个新文件。

三、读写文件使用fstream对象可以方便地进行读写操作。

可以使用read()函数从文件中读取数据，使用write()函数向文件中写入数据。

例如：```cppcharbuffer[100];file_name.read(buffer,sizeof(buffer));//从文件中读取数据到buffer中file_name.write("HelloWorld!",11);//向文件中写入数据"HelloWorld!"```四、关闭文件使用完文件后，需要关闭文件以确保资源得到释放。

可以使用close()函数关闭文件，例如：```cppfile_name.close();//关闭文件```五、其他常用操作除了读写操作外，fstream类还提供了其他常用操作，例如：复制文件、移动文件指针等。

c++文本文件打开读写的常用方法

c++文本文件打开读写的常用方法x一、文件打开、读取、关闭（1）文件打开文件打开可以使用内置类fstream（文件流），通过fstream来完成打开文件的操作。

主要的步骤包括：1. 声明一个fstream类对象。

2. 调用open函数（打开一个文件），引入文件名及其打开模式。

（2）文件读取文件读取也是使用fstream类，它有两个成员函数可以实现：1. read()函数：该函数接受一个char指针参数，用于把从文件中读取的字符串复制到该char指针中，返回值是读取多少个字节。

2. getline()函数：用于从文件中读取一行文本，接受一个char 指针参数，用于把读取到的一行文本复制到该char指针中，返回值是读取的字符数。

（3）文件关闭关闭文件也是使用fstream类，它有两个成员函数可以实现：1.good()函数：用于检验文件是否合法，即文件打开没有出错，此函数返回1，否则返回0。

2.close()函数：用于关闭已经打开的文件，不调用此函数，文件就无法关闭。

二、文件写入文件写入也是使用fstream类，它有两个成员函数可以实现：1. write()函数：接受一个char指针参数，用于把要写入的字符串复制到该char指针中，返回值是写入多少个字节。

2.put()函数：用于写入一个字符，接受一个char参数，用于把要写入的字符复制到该char参数中，返回值是被写入字符的ASCII 码值。

（2）文件追加如果要在文件末尾追加信息，可以使用fstream类的seekp()函数，其原型为：seekp(off_type off,ios::seekdir dir)；其中off_type是long类型，可以使用正数表示文件末尾偏移，也可以使用负数表示文件起始处偏移，dir参数用于指定偏移的方向，其可选值有：ios::beg（指定偏移起点为文件起始处）、ios::cur（指定偏移起点为当前位置）、ios::end（指定偏移起点为文件末尾）。

C++文件操作详解(ifstream、ofstream、fstream)

C++文件操作详解〔ifstream、ofstream、fstream〕C++ 通过以下几个类支持文件的输入输出：•ofstream: 写操作〔输出〕的文件类(由ostream引申而来)•ifstream: 读操作〔输入〕的文件类(由istream引申而来)•fstream: 可同时读写操作的文件类(由iostream引申而来)翻开文件(Open a file)对这些类的一个对象所做的第一个操作通常就是将它和一个真正的文件联系起来，也就是说翻开一个文件。

被翻开的文件在程序中由一个流对象(stream object)来表示(这些类的一个实例) ，而对这个流对象所做的任何输入输出操作实际就是对该文件所做的操作。

要通过一个流对象翻开一个文件，我们使用它的成员函数open()：void open (const char * filename, openmode mode);这里filename 是一个字符串，代表要翻开的文件名，mode 是以下标志符的一个组合：这些标识符可以被组合使用，中间以〞或〞操作符(|)间隔。

例如，如果我们想要以二进制方式翻开文件"example.bin" 来写入一些数据，我们可以通过以下方式调用成员函数open〔〕来实现：ofstream file;file.open ("example.bin", ios::out | ios::app | ios::binary);ofstream, ifstream 和fstream所有这些类的成员函数open 都包含了一个默认翻开文件的方式，这三个类的默认方式各不一样：只有当函数被调用时没有声明方式参数的情况下，默认值才会被采用。

如果函数被调用时声明了任何参数，默认值将被完全改写，而不会与调用参数组合。

由于对类ofstream, ifstream 和fstream 的对象所进展的第一个操作通常都是翻开文件，这些类都有一个构造函数可以直接调用open 函数，并拥有同样的参数。

fstream用法 read

fstream是C++标准库中用来进行文件输入输出的类，它提供了丰富的成员函数和操作符重载，能够很方便地进行文件的读写操作。

1. fstream类的定义和声明在使用fstream类之前，需要包含<fstream>头文件。

然后可以使用fstream类的对象来进行文件的打开、读写等操作。

2. 文件的打开和关闭可以使用fstream对象的open成员函数来打开文件，语法如下：```cppvoid open (const char* filename, ios::openmode mode);```filename为文件名，mode为打开文件的模式，包括in，out，ate，app等。

使用完文件后应当使用close()函数关闭文件。

3. 文件的读取使用ifstream类对象可以进行文件的读取操作。

可以使用`>>`操作符来逐个读取文件中的数据：```cppint num;ifstream inFile;inFile.open("data.txt");inFile >> num;```这里的data.txt是需要读取的文件名，num是用来存储读取到的数据的变量。

也可以使用getline函数来逐行读取文件中的内容：```cppstring line;ifstream inFile;inFile.open("data.txt");while (getline(inFile, line)){// 处理line}inFile.close();```4. 文件的写入使用ofstream类对象可以进行文件的写入操作。

可以使用`<<`操作符来向文件中逐个写入数据：```cppint num = 10;ofstream outFile;outFile.open("output.txt");outFile << num;```这里的output.txt是需要写入的文件名，num是需要写入文件中的数据。

c++读取数据文件到数组的实例

c++读取数据文件到数组的实例摘要：1.介绍C++读取数据文件到数组的方法2.详细步骤说明3.代码实例及解析4.总结与拓展正文：C++作为一种广泛应用于计算机编程的语言，掌握如何读取数据文件到数组的方法对于编程初学者来说尤为重要。

本文将详细介绍C++读取数据文件到数组的方法，并通过一个简单的实例进行讲解。

一、介绍C++读取数据文件到数组的方法在C++中，我们可以使用文件流（fstream）来读取文件数据到数组。

文件流分为输入文件流（ifstream）和输出文件流（ofstream），在这里我们使用输入文件流来读取数据文件。

二、详细步骤说明1.包含头文件：首先，我们需要包含必要的头文件，如下所示：```cpp#include <iostream>#include <fstream>```2.声明变量：声明一个数组以及文件指针，如下所示：```cppint arr[100];ifstream file;```3.打开文件：使用文件流对象的open()函数打开文件，如下所示：```cppfile.open("data.txt", ios::in);```4.检查文件是否打开：使用文件流对象的is_open()函数检查文件是否成功打开，如下所示：```cppif (!file.is_open()) {std::cout << "文件打开失败！" << std::endl;return 1;}```5.读取文件数据到数组：使用文件流对象的read()函数读取文件数据到数组，如下所示：```cppfile.read(reinterpret_cast<char*>(arr), sizeof(arr));```6.关闭文件：在读取文件数据后，使用文件流对象的close()函数关闭文件，如下所示：```cppfile.close();```7.输出数组内容：使用循环输出数组中的内容，如下所示：```cppfor (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {std::cout << arr[i] << " ";}```三、代码实例及解析以下是一个完整的C++代码实例，用于读取数据文件到数组：```cpp#include <iostream>#include <fstream>int main() {int arr[100];std::ifstream file("data.txt", std::ios::in);if (!file.is_open()) {std::cout << "文件打开失败！" << std::endl;return 1;}file.read(reinterpret_cast<char*>(arr), sizeof(arr));file.close();for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {std::cout << arr[i] << " ";}return 0;}```四、总结与拓展本文详细介绍了C++读取数据文件到数组的方法，并通过一个简单的实例进行讲解。

ifstream读取二进制文件用法

ifstream读取二进制文件用法二进制文件是以二进制形式存储数据的文件，相比于文本文件，二进制文件能够更高效地存储和读取大量的数据。

在C++中，我们可以使用ifstream来读取二进制文件，并对其中的数据进行操作和处理。

本文将介绍如何使用ifstream来读取二进制文件，并提供一些常见的用法和技巧。

一、打开文件在使用ifstream读取二进制文件之前，首先需要打开要读取的文件。

可以使用open()函数来打开文件，语法如下：```cppifstream file;file.open("filename", ios::binary);```其中，"filename"表示要打开的文件名，可以是相对路径或绝对路径，ios::binary表示以二进制形式打开文件。

打开文件时，需要检查文件是否成功打开，可以使用is_open()函数来判断：```cppif (file.is_open()) {// 文件打开成功，进行读取操作} else {// 文件打开失败，处理错误}```二、读取数据打开文件之后，就可以使用ifstream对象的read()函数来读取数据了。

read()函数的语法如下：```cppchar* buffer = new char[size];file.read(buffer, size);```其中，buffer是用来存储读取数据的缓冲区，size是要读取的字节数。

需要注意的是，buffer的大小应该足够大，以容纳要读取的数据。

读取数据后，可以进行相应的操作和处理。

三、读取指定数据类型除了使用read()函数读取指定字节数的数据外，我们还可以使用ifstream对象的重载运算符来读取指定数据类型的数据。

下面是一些常用的重载运算符：1. 读取char类型数据：```cppchar ch;file >> ch;```2. 读取整数类型数据：```cppint num;file >> num;```3. 读取浮点数类型数据：```cppfloat num;file >> num;```四、读取整个文件有时候，我们希望一次性读取整个二进制文件的内容，可以使用ifstream对象的seekg()函数、tellg()函数和read()函数来实现。

fstream头文件用法

fstream头文件用法fstream头文件是C++标准库中的一个头文件，用于处理文件输入输出操作。

它提供了三个类，ifstream（用于从文件中读取数据）、ofstream（用于向文件中写入数据）和 fstream（同时具有读写功能的文件操作类）。

要使用 fstream 头文件，首先需要包含它：C++。

#include <fstream>。

接下来，你可以使用这个头文件中定义的类来进行文件的读写操作。

首先，你需要创建一个文件流对象，并打开一个文件。

例如，如果你想要从文件中读取数据，你可以使用 ifstream 类：C++。

std::ifstream infile;infile.open("input.txt");这将打开一个名为 "input.txt" 的文件，使得你可以从中读取数据。

如果你想要向文件中写入数据，你可以使用 ofstream 类：C++。

std::ofstream outfile;outfile.open("output.txt");这将创建一个名为 "output.txt" 的文件，使得你可以向其中写入数据。

如果你需要同时进行读写操作，你可以使用 fstream 类： C++。

std::fstream file;file.open("data.txt");这将打开一个名为 "data.txt" 的文件，使得你可以进行读写操作。

一旦你打开了文件，你就可以使用流操作符（<< 和 >>）来进行数据的读写操作，就像你操作标准输入输出流一样。

例如，你可以用 << 操作符将数据写入文件，用 >> 操作符从文件中读取数据。

完成文件操作后，你应该关闭文件，以释放资源。

你可以使用close() 方法来关闭文件流：C++。

C++fstream二进制读写文件（一个文件备份的例子）

C++fstream⼆进制读写⽂件（⼀个⽂件备份的例⼦）直接上代码：#include <iostream>#include <string>#include <vector>#include <fstream>bool ReadFile(std::string& strFile, std::vector<char>& buffer){std::ifstream infile(strFile.c_str(), std::ifstream::binary);if (!infile.is_open()){printf("Read File:%s Error ... \n", strFile.c_str());return false;}// 获取⽂件⼤⼩infile.seekg(0, std::ifstream::end);long size = infile.tellg();infile.seekg(0);buffer.resize(size);printf("⽂件:[%s] 共有:%ld(字节) ..... \n", strFile.c_str(), size);// read content of infileinfile.read(&buffer[0], size);infile.close();return true;}bool WriteFile(std::string& strFile, std::vector<char>& buffer){std::ofstream outfile(strFile.c_str(), std::ifstream::binary);if (!outfile.is_open()){printf("Write File:%s Error ... \n", strFile.c_str());return false;}outfile.write(&buffer[0], buffer.size());outfile.close();return true;}void test1126_222(){std::string oldFile = "test.txt";std::vector<char> buffer;if (ReadFile(oldFile, buffer)){std::string newFile("test_new.txt");if (WriteFile(newFile, buffer)){printf("备份⽂件 %s --> %s 成功 ... \n", oldFile.c_str(), newFile.c_str());}}}int main(){test1126_222();return0;}。

fstream eof函数

fstream eof函数在C++中，fstream是一个用于文件输入输出的类。

其中的eof()函数是用于判断文件是否已经到达末尾的函数。

在文件读取过程中，可以使用eof()函数来判断是否已经读取到文件的末尾。

eof()函数是一个成员函数，其返回值为bool类型。

当文件指针已经到达文件末尾时，eof()函数返回true，否则返回false。

使用eof()函数进行文件读取时，通常会结合循环来进行判断和读取。

具体的使用方法如下：```cppifstream file("example.txt"); // 打开文件if(file.is_open()) { // 判断文件是否成功打开string line;while(!file.eof()) { // 循环读取文件内容getline(file, line); // 读取一行内容cout << line << endl; // 输出该行内容}file.close(); // 关闭文件}```在上述示例代码中，首先使用ifstream类打开了一个名为example.txt的文件。

然后通过判断文件是否成功打开，来确定是否可以进行文件读取操作。

接着使用while循环和eof()函数来循环读取文件的每一行内容，并输出到屏幕上。

最后使用close()函数关闭文件。

需要注意的是，eof()函数的工作原理是通过判断文件指针是否已经到达文件末尾来确定文件是否已经读取完毕。

因此，在使用eof()函数进行文件读取时，需要结合其他判断条件来确保文件读取的正确性。

例如，在上述示例代码中，使用了getline()函数来读取文件的每一行内容，同时通过判断文件是否读取完毕来终止循环。

需要注意的是，在使用eof()函数进行文件读取时，要确保文件已经成功打开，并且在读取完毕后要及时关闭文件。

这样可以避免文件读取错误或资源浪费的问题。

总结一下，fstream类中的eof()函数是用于判断文件是否已经到达末尾的函数。

几分钟搞懂c#之FileStream对象读写大文件（推荐）

⼏分钟搞懂c#之FileStream对象读写⼤⽂件（推荐）还是⼀样，我先上代码，但是为了你们测试结果和我⼀样，必须先有准备⼯作，否则会找不到⽬录或者⽂件就没有效果；既然是读取⼤⽂件，那么这个⽂本必须存在现在来看⽬标⽬录其实这⾥的⽂本⽂件可以删除，因为我们写⼊⽂本数据的时候的模式是当没有找到⽂件就创建新的。

下⾯上的上代码“`using System;using System.Collections.Generic;using System.IO;using System.Reflection;using System.Text;namespace IO⽬录管理{class Program{private string _StrSourcePath = @”E:\TestDir\Test\1.txt”; //源⽂件⽬录private string _StrTagrgetPath = @”F:\TestDir\Test\1.txt”; //⽬标⽂件⽬录public void Test(){//路径合法性判断if(File.Exists(_StrSourcePath)){//构造读取⽂件流对象using (FileStream fsRead = new FileStream(_StrSourcePath, FileMode.Open)) //打开⽂件，不能创建新的{//构建写⽂件流对象using (FileStream fsWrite = new FileStream(_StrTagrgetPath,FileMode.Create)) //没有找到就创建{//开辟临时缓存内存byte[] byteArrayRead = new byte[1024 * 1024]; // 1字节*1024 = 1k 1k*1024 = 1M内存//通过死缓存去读⽂本中的内容while(true){//readCount 这个是保存真正读取到的字节数int readCount = fsRead.Read(byteArrayRead, 0, byteArrayRead.Length);//开始写⼊读取到缓存内存中的数据到⽬标⽂本⽂件中fsWrite.Write(byteArrayRead, 0, readCount);//既然是死循环那么什么时候我们停⽌读取⽂本内容我们知道⽂本最后⼀⾏的⼤⼩肯定是⼩于缓存内存⼤⼩的if(readCount < byteArrayRead.Length){break; //结束循环}}}}}else{Console.WriteLine("源路径或者⽬标路径不存在。

fstream和ifstream详细用法

文件 I/O 在C++中比烤蛋糕简单多了。

在这篇文章里，我会详细解释ASCII和二进制文件的输入输出的每个细节，值得注意的是，所有这些都是用C++完成的。

一、ASCII 输出为了使用下面的方法, 你必须包含头文件<fstream.h>(译者注：在标准C++中，已经使用<fstream>取代< fstream.h>，所有的C++标准头文件都是无后缀的。

)。

这是 <iostream.h>的一个扩展集, 提供有缓冲的文件输入输出操作. 事实上, <iostream.h> 已经被<fstream.h>包含了, 所以你不必包含所有这两个文件, 如果你想显式包含他们，那随便你。

我们从文件操作类的设计开始, 我会讲解如何进行ASCII I/O操作。

如果你猜是"fstream," 恭喜你答对了！但这篇文章介绍的方法,我们分别使用"ifstream"?和 "ofstream" 来作输入输出。

如果你用过标准控制台流"cin"?和 "cout," 那现在的事情对你来说很简单。

我们现在开始讲输出部分，首先声明一个类对象。

ofstream fout; 这就可以了，不过你要打开一个文件的话, 必须像这样调用ofstream::open()。

fout.open("output.txt"); 你也可以把文件名作为构造参数来打开一个文件.ofstream fout("output.txt"); 这是我们使用的方法, 因为这样创建和打开一个文件看起来更简单. 顺便说一句, 如果你要打开的文件不存在，它会为你创建一个, 所以不用担心文件创建的问题. 现在就输出到文件，看起来和"cout"的操作很像。

.net core filestream用法

.net core filestream用法在.NET Core中，FileStream类提供了一种方便的方法来处理文件流。

它允许您以二进制流的形式读取和写入文件，这对于处理大型文件或需要高效数据传输的情况非常有用。

在.NET Core中，FileStream类是System.IO命名空间的一部分，因此您可以使用它来操作本地文件系统中的文件。

一、创建FileStream对象要使用FileStream对象，您需要先创建一个FileStream对象，并指定要打开的文件路径和访问模式。

访问模式指定了您对文件的操作方式，例如读取、写入或追加等。

以下是一个简单的示例代码，演示如何创建一个FileStream对象：```csharpusing (var stream = new FileStream("path/to/file.txt", FileMode.Open)){// 在此处进行文件操作}```在上面的代码中，`path/to/file.txt`是要打开的文件的路径，`FileMode.Open`指定打开文件的模式为读取模式。

在创建FileStream 对象后，您可以在该对象上进行各种文件操作，例如读取、写入或读取并写入等。

二、读取文件使用FileStream对象可以方便地读取文件内容。

您可以使用Read方法从文件中读取数据，并将其存储在缓冲区中。

以下是一个简单的示例代码，演示如何使用FileStream对象读取文件内容：```csharpusing (var stream = new FileStream("path/to/file.txt", FileMode.Open)){byte[] buffer = new byte[1024];int bytesRead;while ((bytesRead = stream.Read(buffer, 0,buffer.Length)) > 0){// 处理读取到的数据}}```在上面的代码中，我们使用了一个循环来不断从文件中读取数据，并将其存储在缓冲区中。

读取二进制文件的方法

读取二进制文件的方法随着计算机技术的日益发展，我们越来越离不开二进制文件。

二进制文件是计算机中以二进制代码表示的文件，不同于文本文件，二进制文件需要通过特定工具才能够读取。

那么如何读取二进制文件呢？本文将介绍几种常见的读取二进制文件的方法。

一、使用文件流读取二进制文件文件流是C++中常用的读取二进制文件的方法，通过文件流可以打开并读取二进制文件中的每一个字节。

文件流的使用方法如下：```C++#include <iostream>#include <fstream>int main(){// 打开二进制文件std::ifstream fin("test.bin", std::ios::binary);// 检测文件是否打开成功if (!fin.is_open()){std::cerr << "Open test.bin failed!" << std::endl;return -1;}// 读取二进制文件内容char c;while (fin.get(c)){std::cout << c;}// 关闭二进制文件fin.close();return 0;}```其中，`std::ios::binary`表示以二进制模式打开文件，`fin.get(c)`用于逐个读取文件中的每一个字节。

二、使用内存映射文件读取二进制文件内存映射文件是一种将文件映射到内存中的技术，可以通过指针直接访问二进制文件中的数据。

使用内存映射文件读取二进制文件的方法如下：```C++#include <iostream>#include <fstream>#include <sys/mman.h>#include <unistd.h>#include <fcntl.h>int main(){// 打开二进制文件int fd = open("test.bin", O_RDONLY);if (fd < 0){std::cerr << "Open test.bin failed!" << std::endl;return -1;}// 获取文件大小off_t file_size = lseek(fd, 0, SEEK_END);// 将文件映射到内存中char* data = (char*)mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, fd, 0);if (data == MAP_FAILED){std::cerr << "mmap failed!" << std::endl;close(fd);return -1;}// 读取二进制文件内容for (off_t i = 0; i < file_size; i++){std::cout << data[i];}// 关闭内存映射munmap(data, file_size);// 关闭文件close(fd);return 0;}```其中，`open()`函数用于打开文件，`lseek()`函数用于获取文件大小，`mmap()`函数用于将文件映射到内存中，`munmap()`函数用于关闭内存映射。

c++ ofstream用法

c++ ofstream用法C++中的ofstream是一个输出流，可以用于将数据写入到文件中。

在这篇文章中，我们将会详细介绍如何使用ofstream。

1. ofstream基本用法先来看一下ofstream的初始化以及写入的基本用法：```c++#include <fstream>{std::ofstream ofs("demo.txt");ofs << "Hello, World!\n";return 0;}```这个例子中，我们首先创建了一个ofstream对象和要写入的文件名（"demo.txt"）。

然后，我们使用“<<”运算符向文件中写入一些文本。

当程序执行结束时，自动关闭文件。

2. 文件模式ofstream流可以打开文件的多种模式，这些模式对于不同的文件使用情况可以选择不同的打开方式。

以下是一些常用模式：- ios::out：打开文件用于写入，如果文件不存在则创建文件。

- ios::app：打开文件用于追加写入，如果文件不存在则创建文件。

- ios::binary：以二进制方式打开文件。

- ios::trunc：如果文件已经存在，则在打开文件之前清空文件内容。

对于以上模式，我们可以将它们组合使用，比如：```c++ofs.open("demo.txt", std::ios::out | std::ios::trunc); // 打开文件并清空内容```3. 写入各种基本类型数据除了写入文本外，我们还可以通过ofstream流将各种基本类型数据打印输出到文件中。

以下是一些常见的例子：```c++#include <iostream>#include <fstream>{// 打开文件std::ofstream ofs("demo.txt");// 数值类型int i = 123;ofs << i << std::endl;float f = 3.14f;ofs << f << std::endl;double d = 3.1415926;ofs << d << std::endl;long long ll = 123456789;ofs << ll << std::endl;// 字符类型char c = 'A';ofs << c << std::endl;std::string str = "Hello,World!";ofs << str << std::endl;// 关闭文件ofs.close();return 0;}```在这个例子中，我们首先打开了文件。

c++二进制读写中文

c++二进制读写中文在C++中进行二进制读写中文，你可以使用文件流（fstream）来实现。

下面我会从多个角度来回答这个问题。

首先，要进行二进制读写，你需要使用二进制模式打开文件。

可以使用`std::ios::binary`标志来指定二进制模式。

例如，如果你要读取一个二进制文件，可以使用`std::ifstream`类来打开文件，并指定二进制模式：cpp.std::ifstream file("filename.bin", std::ios::binary);如果你要写入一个二进制文件，可以使用`std::ofstream`类来打开文件，并指定二进制模式：cpp.std::ofstream file("filename.bin", std::ios::binary);接下来，你可以使用文件流的`read`和`write`函数来进行读写操作。

对于中文字符，每个字符通常占用多个字节，所以你需要确保正确地读取和写入字符的字节数。

读取中文字符时，你可以先读取字符的字节数，然后再读取对应数量的字节，并将其转换为字符串。

下面是一个示例：cpp.std::string chinese;int size;file.read(reinterpret_cast<char>(&size), sizeof(int));char buffer = new char[size];file.read(buffer, size);chinese.assign(buffer, size);delete[] buffer;写入中文字符时，你可以先将字符转换为字节数组，然后再写入字节数组的长度和内容。

下面是一个示例：cpp.std::string chinese = "中文";int size = chinese.size();file.write(reinterpret_cast<const char>(&size), sizeof(int));file.write(chinese.c_str(), size);需要注意的是，读取和写入的字节数必须一致，否则可能导致数据错误。

C++流操作之fstream用法介绍

C++流操作之fstream⽤法介绍在Windows平台对⽂件进⾏存取操作可选的⽅案有很多，如果采⽤纯C，则需要⽤到File*等，当然也可以直接调⽤Windows API来做；如果采⽤C++，⾸先想到的就是⽂件流fstream。

虽然在COM层⾯上，我们还可以使⽤IStream来实现⽂件的读写，其效率也⾮常⾼。

不过本⽂仅对C++流操作做简单的探讨，相⽐于Windows API或IStream，C++的流操作通⽤性更好⼀些，因为你能轻松将代码移植到其它平台上。

fstream有两个派⽣类，即ifstream和ofstream，分别对应输⼊⽂件流、输出⽂件流。

在使⽤它们之前，必须将它们的头⽂件包含到你的cpp⽂件中。

创建⼀个⽂件流的⽅法很简单：ifstream fin;fin.open("C:\filename.txt");这样就创建了⼀个输⼊⽂件流fin，它对应的⽂件是C盘根⽬录下的filename.txt。

实际上，open⽅法还包含⼀个参数mode，⽤以指定其打开⽅式。

ios::in 以读取⽅式打开⽂件ios::out 以写⼊⽅式打开⽂件ios::ate 存取指针在⽂件末尾ios::app 写⼊时采⽤追加⽅式ios::trunc 写⼊时抹去旧数据ios::binary 以⼆进制⽅式存取上⾯的代码并未指定任何打开⽅式，则采⽤默认参数：输⼊⽂件流即ios::in，输出⽂件流即ios::out。

⼀般在需要组合特殊的mode才显式指定，⽐如：ios::in | ios::binary; //以⼆进制⽅式读取⽂件除此之外，还可以在构造时指定相应的⽂件路径和名称，让创建过程⼀步到位。

上述代码可改写为：ifstream fin("C:\filename.txt");与open⽅法相反的是close⽅法，它的作⽤与open正好相反。

open是将⽂件流对象与外设中的⽂件关联起来，close则是解除⼆者的关联。

C++文件流fstream相关操作

C++⽂件流fstream相关操作⼀、理解Open函数利⽤fstream，使⽤open/close打开或创建，完成后关闭，对⽂件读⼊读出使⽤插⼊器(<<) 或析取器(>>)完成。

参考。

1. 函数void open（...）参数选项在fstream类中，有⼀个成员函数open()，就是⽤来打开⽂件的，其原型是：void open(const char* filename, int mode, int access);打开⽂件的⽅式mode在类ios(是所有流式I/O类的基类)中定义，可以⽤“或”把以上属性连接起来，如 ios::out | ios::binary 常⽤的值如下：ios::app：以追加的⽅式打开⽂件ios::ate：⽂件打开后定位到⽂件尾，ios:app就包含有此属性ios::binary：　以⼆进制⽅式打开⽂件，缺省的⽅式是⽂本⽅式。

两种⽅式的区别见前⽂ios::in：⽂件以输⼊⽅式打开（⽂件数据输⼊到内存）ios::out：⽂件以输出⽅式打开（内存数据输出到⽂件）ios::nocreate：不建⽴⽂件，所以⽂件不存在时打开失败ios::noreplace：不覆盖⽂件，所以打开⽂件时如果⽂件存在失败ios::trunc：如果⽂件存在，把⽂件长度设为0打开⽂件的属性access取值如下，可以⽤“或”或者“+”把以上属性连接起来，如3 或 1|2就是以只读和隐含属性打开⽂件。

0：普通⽂件，打开访问1：只读⽂件2：隐含⽂件4：系统⽂件2. 功能及应⽤场景如果open函数只有⽂件名⼀个参数，则是以读/写普通⽂件打开，即：file1.open("c:\\config.sys"); <=> file1.open("c:\\config.sys", ios::in | ios::out, 0); 只读模式（fstream::out）可以创建新⽂件 1）⽂件新建并写⼊如果该⽂件不存在则新建并写⼊，如果该⽂件存在则清除所有内容并从头开始写⼊；选择使⽤的参数：ios::trunc | ios::out | ios::in。

C++文件流读写操作详解

C++⽂件流读写操作详解⽬录1.打开⽂件1.1 fstream类型1.2 open()的函数原型1.3 打开⽅式1.4 打开⽂件的属性1.5 ⽰例代码2.⽂本⽂件的读写2.1 写⽂件⽰例2.2 读⽂件⽰例2.3 逐字符读取和逐⾏读取2.4 统计⽂本⾏数及读取某⼀⾏内容2.5 读取数据到数组当中3.状态标志符的验证(Verification of state flags)4.获得和设置流指针(get and put stream pointers)5.⼆进制⽂件6.缓存和同步(Buffers and Synchronization)1.打开⽂件1.1 fstream类型#include <fstream>ofstream //⽂件写操作内存写⼊存储设备ifstream //⽂件读操作，存储设备读区到内存中fstream //读写操作，对打开的⽂件可进⾏读写操作1.2 open()的函数原型void open ( const char * filename,ios_base::openmode mode = ios_base::in | ios_base::out );void open(const wchar_t *_Filename,ios_base::openmode mode= ios_base::in | ios_base::out,int prot = ios_base::_Openprot)；参数含义filename操作⽂件名mode打开⽂件的⽅式prot打开⽂件的属性1.3 打开⽅式打开⽂件的⽅式在ios类(所以流式I/O的基类)中定义，有如下⼏种常⽤⽅式：参数含义ios::in为输⼊(读)⽽打开⽂件ios::out为输出(写)⽽打开⽂件ios::ate初始位置：⽂件尾ios::app所有输出附加在⽂件末尾ios::trunc如果⽂件已存在则先删除该⽂件再重新创建ios::binary⼆进制⽅式1.4 打开⽂件的属性打开⽂件的属性同样在ios类中也有定义参数含义0普通⽂件，打开操作参数含义1只读⽂件2隐含⽂件4系统⽂件1.5 ⽰例代码#include <iostream>#include <fstream>#include <iomanip>using namespace std;int main(){ofstream inFile;/*ios::trunc表⽰在打开⽂件前将⽂件清空,由于是写⼊,⽂件不存在则创建*/ inFile.open("inFile.txt",ios::trunc);int i;char a='a';for(i=1;i<=26;i++)//将26个数字及英⽂字母写⼊⽂件{inFile<<setw(2)<<i<<"\t"<<a<<"\n";a++;}inFile.close();//关闭⽂件}2.⽂本⽂件的读写2.1 写⽂件⽰例// writing on a text file#include <fstream.h>int main (){ofstream out(”out.txt”);if (out.is_open()){out << ”This is a line.\n”;out << ”This is another line.\n”;out.close();}return 0;}//结果: 在out.txt中写⼊：This is a line.This is another line2.2 读⽂件⽰例// reading a text file#include <iostream.h>#include <fstream.h>#include <stdlib.h>int main (){char buffer[256];ifstream in(”test.txt”);if (! in.is_open()){cout << ”Error opening file”;exit (1);}while (!in.eof() ) //eof到⽂件末尾返回true{in.getline (buffer,100);cout << buffer << endl;}return 0;}//结果在屏幕上输出This is a line.This is another line2.3 逐字符读取和逐⾏读取⾸先说说getline函数，需要头⽂件#include<string>函数原型：istream& getline ( istream &is , string &str , char delim );其中，istream &is 表⽰⼀个输⼊流，譬如cin；string&str表⽰把从输⼊流读⼊的字符串存放在这个字符串中（可以⾃⼰随便命名，str什么的都可以）；char delim表⽰遇到这个字符停⽌读⼊，在不设置的情况下系统默认该字符为'\n'，也就是回车换⾏符#include <iostream>#include <fstream>using namespace std;void testByChar(){fstream testByCharFile;char c;testByCharFile.open("inFile.txt",ios::in);while(!testByCharFile.eof()){testByCharFile>>c;cout<<c;}testByCharFile.close();}void testByLine(){char buffer[256];fstream outFile;outFile.open("inFile.txt",ios::in);cout<<"inFile.txt"<<"--- all file is as follows:---"<<endl;while(!outFile.eof()){outFile.getline(buffer,256,'\n');//getline(char *,int,char) 表现该⾏字符达到256个或碰到换⾏就结束cout<<buffer<<endl;}outFile.close();}int main(){cout<<endl<<"逐个字符的读取⽂件：testByChar() "<<endl<<endl;testByChar();cout<<endl<<"将⽂件每⾏内容存储到字符串中，再输出字符串：testByLine()"<<endl<<endl;testByLine();}2.4 统计⽂本⾏数及读取某⼀⾏内容//如何统计⽂本的⾏数及如何读取⽂件某⼀⾏内容：#include <iostream>#include <fstream>#include <string>using namespace std;int CountLines(char *filename){ifstream in;int n=0;string tmp;in.open(filename,ios::in);//ios::in 表⽰以只读的⽅式读取⽂件if(in.fail())//⽂件打开失败:返回0{return 0;}else//⽂件存在{while(getline(in,tmp,'\n')){n++;}in.close();return n;}}string ReadLine(char *filename,int line){int lines,i=0;string temp;fstream file;file.open(filename,ios::in);lines=CountLines(filename);if(line<=0)return "Error 1: ⾏数错误，不能为0或负数。

fstream

2、析取器(>>)
从流中输入数据。比如说系统有一个默认的标准输入流(cin)，一般情况下就是指的键盘，所以，cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。
在C++中，对文件的操作是通过stream的子类fstream(file stream)来实现的，所以，要用这种方式操作文件，就必须加入头文件fstream.h。下面就把此类的文件操作过程一一道来。
ios::beg：文件开头
ios::cur：文件当前位置
ios::end：文件结尾
这两个函数一般用于二进制文件，因为文本文件会因为系统对字符的解释而可能与预想的值不同。
例：
file1.seekg(1234,ios::cur);//把文件的读指针从当前位置向后移1234个字节
write(const unsigned char *buf,int num);
read()从文件中读取 num 个字符到 buf 指向的缓存中，如果在还未读入 num 个字符时就到了文件尾，可以用成员函数 int gcount();来取得实际读取的字符数；而 write() 从buf 指向的缓存写 num 个字符到文件中，值得注意的是缓存的类型是 unsigned char *，有时可能需要类型转换。
ifstream file2("c:\pdos.def");//以输入方式打开文件
ofstream file3("c:\x.123");//以输出方式打开文件
所以，在实际应用中，根据需要的不同，选择不同的类来定义：如果想以输入方式打开，就用ifstream来定义；如果想以输出方式打开，就用ofstream来定义；如果想以输入/输出方式来打开，就用fstream来定义。

c语言stream用法

在C语言中，stream通常是指文件流（file stream），用于处理文件的输入输出操作。

C语言中的文件流可以通过标准库中的文件操作函数进行使用。

以下是一些常用的文件流操作函数：1. fopen()函数：用于打开一个文件，并返回一个指向该文件的指针。

语法为：FILE *fopen(const char *filename, const char *mode);2. fclose()函数：用于关闭一个打开的文件。

语法为：int fclose(FILE *stream);3. fgetc()函数：用于从文件中读取一个字符。

语法为：int fgetc(FILE *stream);4. fgets()函数：用于从文件中读取一行数据。

语法为：char *fgets(char *str, int n, FILE *stream);5. fputc()函数：用于将一个字符写入文件中。

语法为：int fputc(int c, FILE *stream);6. fputs()函数：用于将一行数据写入文件中。

语法为：int fputs(const char *str, FILE *stream);7. fread()函数：用于从文件中读取指定数量的数据块。

语法为：size_t fread(void *ptr, size_t size, size_t count, FILE *stream);8. fwrite()函数：用于将指定数量的数据块写入文件中。

语法为：size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);在使用文件流时，需要注意以下几点：1. 打开文件时需要指定正确的文件路径和打开模式（例如：r表示只读，w表示写入，a表示追加等）。

2. 在使用文件流时，需要确保文件已经被正确关闭，以避免资源泄漏和文件损坏的问题。

3. 在读取或写入文件时，需要注意数据类型的大小和顺序等问题，以避免出现读写错误或数据损坏的情况。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

【转载】C++中文件流(fstream)的使用方法及示例(2011-08-22 16:00:14)转载▼分类：编程拾萃标签：杂谈C++文件流：fstream // 文件流ifstream // 输入文件流ofstream // 输出文件流头文件：#include <fstream>//创建一个文本文件并写入信息//同向屏幕上输出信息一样将信息输出至文件#include<iomanip.h>#include<fstream>void main(){ofstream ofs("C:\\example.txt"); //打开文件用于写，若文件不存在就创建它if (!ofs) return; //打开文件失败则结束运行f1 << setw(20) << "Name: " << "Beethoven" << endl; //使用插入运算符写文件内容f1 << setw(20) << "song: " << "Moonlight Sonata" << endl; f1.close(); //关闭文件}文件操作：打开文件文件名注意路径名中的斜杠要双写，如："D:\\MyFiles\\ReadMe.txt"文件打开方式选项：ios::in = 0x01, //供读，文件不存在则创建(ifstream默认的打开方式)ios::out = 0x02, //供写，文件不存在则创建，若文件已存在则清空原内容(ofstream默认的打开方式)ios::ate = 0x04, //文件打开时，指针在文件最后。

可改变指针的位置，常和in、out联合使用ios::app = 0x08, //供写，文件不存在则创建，若文件已存在则在原文件内容后写入新的内容，指针位置总在最后ios::trunc = 0x10, // 在读写前先将文件长度截断为0（默认）ios::nocreate = 0x20, //文件不存在时产生错误，常和in或app联合使用ios::noreplace = 0x40, //文件存在时产生错误，常和out联合使用ios::binary = 0x80 //二进制格式文件文件保护方式选择项：filebuf::openprot; //默认的兼容共享方式filebuf::sh_none; //独占，不共享filebuf::sh_read; //读共享filebuf::sh_write; //写共享打开文件的方法调用构造函数时指定文件名和打开模式ifstream f("d:\\12.txt", ios::nocreate); //默认以 ios::in 的方式打开文件，文件不存在时操作失败ofstream f("d:\\12.txt"); //默认以 ios::out的方式打开文件fstream f("d:\\12.dat", ios::in|ios::out|ios::binary); //以读写方式打开二进制文件使用Open成员函数fstream f;f.open("d:\\12.txt",ios::out); //利用同一对象对多个文件进行操作时要用到open函数检查是否成功打开成功：if (f) {...} //对ifstream、ofstream对象可用，fstream对象不可用。

mysqlif (f.good()) {...}失败：if (!f) {...} // !运算符已经重载if (f.fail()) {...}读写操作使用<<，>>运算符只能进行文本文件的读写操作，用于二进制文件可能会产生错误。

使用函数成员 get、put、read、write等经常和read配合使用的函数是 gcount()，用来获得实际读取的字节数。

读写二进制文件注意事项打开方式中必须指定ios::binary，否则读写会出错用read\write进行读写操作，而不能使用插入、提取运算符进行操作，否则会出错。

使用eof()函数检测文件是否读结束，使用gcount()获得实际读取的字节数关闭文件使用成员函数close，如： oraclef.close();利用析构函数对象生命期结束时会检查文件是否关闭，对没有关闭的文件进行关闭操作。

随机读写文件通过移动文件读写指针，可在文件指定位置进行读写。

seekg(绝对位置); //绝对移动，//输入流操作seekg(相对位置,参照位置); //相对操作tellg(); //返回当前指针位置seekp(绝对位置); //绝对移动，//输出流操作seekp(相对位置,参照位置); //相对操作tellp(); //返回当前指针位置参照位置： mysqlios::beg = 0 //相对于文件头ios::cur = 1 //相对于当前位置ios::end = 2 //相对于文件尾读写文本文件的示例//为能够正确读出写入文件的各数据，各数据间最好要有分隔#include<fstream>void main(){fstream f("d:\\try.txt", ios::out);f << 1234 << ' ' << 3.14 << 'A' << "How are you"; //写入数据f.close();f.open("d:\\try.txt", ios::in);int i;double d;char c;char s[20];f >> i >> d >> c; //读取数据f.getline(s,20);cout << i << endl; //显示各数据cout <<d << endl;cout << c << endl;cout << s << endl;f.close();}运行结果：12343.14AHow are youPress any key to continue显示文本文件的内容//使用get()一次读一个字符--------------------------------方案一#include<fstream>void main(){ifstream fin("d:\\简介.txt", ios::nocreate);if (!fin) {cout << "File open error!\n";return;}char c;while ((c=fin.get()) != EOF) cout << c; //注意结束条件的判断fin.close();}//使用get(char *,int n,char delim='\n')一次读多个字符----方案二//巧妙利用文本文件中不会有字符'\0'的特点进行读取#include<fstream>void main(){ifstream fin("d:\\简介.txt",ios::nocreate);if(!fin){cout<<"File open error!\n";return;}char c[80];while(fin.get(c,80,'\0')!=NULL)cout<<c; //注意结束条件的判断fin.close();}//使用read(char *,int n)读文件---------------------------方案三#include<fstream.h>void main(){ifstream fin("d:\\简介.txt",ios::nocreate);if(!fin){cout<<"File open error!\n";return;}char c[80];while(!fin.eof()) //判断文件是否读结束{fin.read(c,80);cout.write(c,fin.gcount());}fin.close();}拷贝文件//二进制文件操作示例 ssh#include<fstream>void main(){ifstream fin("C:\\1.exe", ios::nocreate|ios::binary); if (!fin) {cout << "File open error!\n";return;}ofstream fout("C:\\2.exe", ios::binary);char c[1024];while (!fin.eof()){fin.read(c, 1024);fout.write(c, fin.gcount()); }fin.close();fout.close();cout << "Copy over!\n";}。