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类还提供了其他常用操作，例如：复制文件、移动文件指针等。
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是需要写入文件中的数据。
fstream函数
fstream函数fstream函数是C++标准库中用于文件输入和输出的函数。
它是以面向对象的形式实现的，能够方便地读取和写入文本、二进制格式的文件。
下面我将为大家细分讲解fstream函数的使用。
一、头文件在使用fstream函数之前，我们需要引入头文件“fstream”，例如：#include <fstream>二、打开文件在进行文件读写操作之前，我们需要先打开文件。
可以使用fstream对象的“open”方法打开文件，方法中的参数包括文件名、打开模式等。
例如：ofstream outfile;outfile.open("file.txt", ios::out);以上代码即创建了一个ofstream对象outfile，并打开了名为“file.txt”的文件，模式为“ios::out”。
常用模式包括：• ios::in：打开文件用于读取；• ios::out：打开文件用于写入；• ios::trunc：打开文件并情况其中的内容；• ios::app：打开文件并将写入的内容追加到文件末尾。
三、文件读取读取文件时，我们需要使用ifstream对象的“getline”方法读取整行或“get”方法读取字符。
例如：ifstream infile;infile.open("file.txt", ios::in);string line;while (getline(infile, line)) {cout << line << endl;}infile.close();以上代码即创建了一个ifstream对象infile并打开了名为“file.txt”的文件，模式为“ios::in”。
随后使用while循环逐行读取文本数据，直到读到文件结束。
其中，getline方法会将文本行读取到一个string类型的变量line中，我们可以通过cout语句输出line的值来展现文件读取的过程。
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,ifstream,ostream）
c中文件流基本用法（fstream,ifstream,ostream）c++文件流基本用法(fstream,ifstream,ostream)前言：c++的文件流处理其实很简单，前提是你能够理解它。
文件流本质是利用了一个buffer中间层。
有点类似标准输出和标准输入一样。
c++IO的设计保证IO效率，同时又兼顾封装性和易用性。
本文将会讲述c++文件流的用法。
有错误和疏漏的地方，欢迎批评指证。
需要包含的头文件：名字空间:std也可以试用fstream提供了三个类，用来实现c++对文件的操作。
（文件的创建，读写）。
ifstream--从已有的文件读ofstream--向文件写内容fstream-打开文件供读写支持的文件类型实际上，文件类型可以分为两种：文本文件和二进制文件.文本文件保存的是可读的字符，而二进制文件保存的只是二进制数据。
利用二进制模式，你可以操作图像等文件。
用文本模式，你只能读写文本文件。
否则会报错。
例一:写文件声明一个ostream变量1.调用open方法,使其与一个文件关联2.写文件3.调用close方法.1.#include2.3.void main4.{5.ofstream file;6.7.file.open("file.txt");8.9.file<<"Hello file/n"<<75;10.11.file.close();12.}可以像试用cout一样试用操作符<<向文件写内容. Usages:1.2.file<<"string/n";3.file.put('c');例二:读文件1.声明一个ifstream变量.2.打开文件.3.从文件读数据4.关闭文件.1.#include2.3.void main4.{5.ifstream file;6.char output[100];7.int x;8.9.file.open("file.txt");10.11.file>>output;12.cout<<output;< p="">13.file>>x;14.cout<<x;< p="">15.16.file.close();17.}同样的，你也可以像cin一样使用>>来操作文件。
fstream流常用方法
fstream流常用方法fstream流是一种用于读写文件的流模板类，它支持多种文件操作方法。
在C++中，我们可以通过fstream头文件来使用fstream类。
下面是fstream流常用的方法：1. 打开文件：使用open()方法可以打开指定的文件。
例如，我们可以使用以下代码来打开一个名为“example.txt”的文件：fstream file;file.open('example.txt', ios::out | ios::in);其中，ios::out表示文件以写入模式打开，ios::in表示文件以读取模式打开。
2. 写入文件：使用<<运算符或write()方法可以向文件中写入数据。
例如，我们可以使用以下代码向文件中写入一个字符串：file << 'Hello world!';或者使用write()方法：char data[] = 'Hello world!';file.write(data, sizeof(data));3. 读取文件：使用>>运算符或read()方法可以从文件中读取数据。
例如，我们可以使用以下代码从文件中读取一个字符串：string str;file >> str;或者使用read()方法：char data[100];file.read(data, sizeof(data));4. 关闭文件：使用close()方法可以关闭打开的文件。
例如，我们可以使用以下代码关闭文件：file.close();以上就是fstream流常用的方法。
通过这些方法，我们可以很方便地读写文件。
C++中文件流(fstream)的使用方法及示例
【转载】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对象不可用。
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"的操作很像。
qt中的fstream用法
qt中的fstream用法全文共四篇示例，供读者参考第一篇示例：Qt中的fstream是用于文件输入输出操作的类。
它可以实现对文件的读写操作，包括读取文件内容、写入文件内容、以及在文件中进行定位等功能。
在Qt中，fstream类提供了一种方便、灵活且高效的文件处理机制，使得我们可以轻松地实现对文件的操作。
在Qt中，我们可以通过fstream类来打开一个文件，并对其进行读写操作。
要使用fstream类，我们首先需要包含<fstream>头文件，然后就可以使用fstream类的实例来操作文件。
下面是一个简单的示例代码：```cpp#include <QFile>#include <QTextStream>QTextStream in(&file);while (!in.atEnd()) {QString line = in.readLine();qDebug() << line;}file.close();return 0;}```在这个示例中，我们首先创建了一个QFile对象，然后通过open()方法以只读文本模式打开了一个名为test.txt的文件。
接着我们创建了一个QTextStream对象in，它用来读取文件的内容。
通过while循环遍历文件的每一行，并使用readLine()方法读取每一行的内容并输出到控制台上。
最后通过close()方法关闭文件。
除了只读模式，我们还可以使用QIODevice::WriteOnly模式来以只写模式打开文件，并通过write()方法写入文件内容。
QIODevice类还提供了seek()方法用于在文件中进行定位，可以实现随机读写文件的功能。
Qt中的fstream类为文件操作提供了方便、高效和易用的接口，可以帮助我们轻松地实现对文件的读写操作。
通过熟练掌握fstream 类的用法，我们可以更加灵活地处理文件，提高程序的效率和性能。
fstream头文件3类的各功能
1.ios::app ----写入的数据将被追加在文件的末尾，此方式使用ios::out2.ios::ate ----写入的数据将被追加在文件的末尾，此方式不使用ios::out但是我看不懂最后一句，什么叫使用和不使用“ios::out”呢？？ios::out本身不是就是打开一个可写文件吗？既然都能追加写入了，还能不让写？1.1.ios::app ----写入的数据将被追加在文件的末尾，此方式使用ios::out2.ios::ate ----写入的数据将被追加在文件的末尾，此方式不使用ios::outios::app 多个线程或者进程对一个文件写的时候,假如文件原来的内容是abc，第一个线程(进程)往里面写了个d,第二个线程(进程)写了个e的话，结果是abcdeios:ate的话，后面写的回覆盖前面一个写的，还是上面那个例子的话(第二个后写)结果为abce 2.ofstream流，以ios::app打开（或者“ios::app|ios::out”）,如果没有文件，那么生成空文件；如果有文件，那么在文件尾追加。
以ios::app|ios::in打开，不管有没有文件，都是失败。
以ios::ate打开（或者”ios::ate|ios::out”），如果没有文件，那么生成空文件；如果有文件，那么清空该文件以ios::ate|ios::in打开，如果没有文件，那么打开失败；如果有文件，那么定位到文件尾，并可以写文件，但是不能读文件ifstream流，以ios::app打开（“ios::app|ios::out”）,不管有没有文件，打开都是失败。
以ios::ate打开（“ios::ate|ios::out”）,如果没有文件，打开失败如果有文件，打开成功，并定位到文件尾，但是不能写文件fstream流，默认是ios::in，所以如果没有文件，ios::app和ios::ate都是失败，以ios::app|ios::out,如果没有文件则创建文件，如果有文件，则在文件尾追加以ios::ate|ios::out打开，如果没有文件则创建文件，如果有，则清空文件。
fstream使用方法介绍
fstream使用方法介绍fstream是C++标准库中的一个输入/输出流类，用于文件的读写操作。
它是fstream类的派生类，继承了fstream类的所有操作。
fstream类封装了对文件的操作，提供了很多方便的方法，使得文件的读写变得简单和高效。
```cppclass fstream : public iostreampublic:explicit fstream(const char* filename, ios_base::openmode mode = ios_base::in ， ios_base::out);explicit fstream(const std::string& filename,ios_base::openmode mode = ios_base::in ， ios_base::out);void open(const char* filename, ios_base::openmode mode =ios_base::in ， ios_base::out);void open(const std::string& filename, ios_base::openmode mode = ios_base::in ， ios_base::out);void close(;bool is_open( const;};```- ios_base::in：以读模式打开文件。
- ios_base::out：以写模式打开文件。
- ios_base::binary：以二进制模式打开文件。
- ios_base::ate：打开文件后立即将文件指针定位到文件末尾。
- ios_base::app：打开文件后将文件指针定位到文件末尾。
- ios_base::trunc：如果文件已存在，则删除文件内容。
- ios_base::in ， ios_base::out：以读写模式打开文件。
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++流操作之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则是解除⼆者的关联。
fstream get用法
fstream get用法fstream是C++中用于文件输入输出的类，可以用于从文件中读取内容和向文件中写入内容。
对于读取文件内容，可以使用以下步骤：1. 包含<fstream>头文件。
2. 创建一个fstream对象，指定文件名和打开模式。
打开模式可以是ios::in（只读模式）、ios::out（只写模式）、ios::app （追加模式）等等。
3. 使用对象的成员函数来读取文件内容，常用的函数有get()、getline()、read()等等。
4. 关闭文件，可以使用成员函数close()。
以下是一个示例代码：```cpp#include <iostream>#include <fstream>int main() {std::ifstream file("example.txt"); // 打开example.txt文件用于读取char ch;while(file.get(ch)) {std::cout << ch;}file.close(); // 关闭文件return 0;}```此代码中，我们使用ifstream对象打开了一个名为example.txt的文件用于读取。
然后，使用get()函数读取文件中的每个字符，并将字符打印到屏幕上。
最后，使用close()函数关闭文件。
需要注意的是，ifstream类用于读取文本文件。
如果需要读取二进制文件，可以使用fstream类（在第2步创建对象时指定打开模式为ios::binary）。
对于写入文件内容，可以使用以下步骤：1. 包含<fstream>头文件。
2. 创建一个fstream对象，指定文件名和打开模式。
打开模式可以是ios::out（只写模式）、ios::app（追加模式）等等。
3. 使用对象的成员函数来写入文件内容，常用的函数有put()、write()等等。
fstream的使用方法
fstream的使用方法ofstream是从内存到硬盘，ifstream是从硬盘到内存，其实所谓的流缓冲就是内存空间;在C++中，有一个stream这个类，所有的I/O都以这个“流”类为基础的，包括我们要认识的文件I/O，stream这个类有两个重要的运算符：1、插入器(<<)向流输出数据。
比如说系统有一个默认的标准输出流(cout)，一般情况下就是指的显示器，所以，cout<<"Write Stdout"<<’\n’;就表示把字符串"Write Stdout"和换行字符(’\n’)输出到标准输出流。
2、析取器(>>)从流中输入数据。
比如说系统有一个默认的标准输入流(cin)，一般情况下就是指的键盘，所以，cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。
在C++中，对文件的操作是通过stream的子类fstream(file stream)来实现的，所以，要用这种方式操作文件，就必须加入头文件fstream.h。
下面就把此类的文件操作过程一一道来。
一、打开文件在fstream类中，有一个成员函数open()，就是用来打开文件的，其原型是：void open(const char* filename,int mode,int access);参数：filename：要打开的文件名mode：要打开文件的方式access：打开文件的属性打开文件的方式在类ios(是所有流式I/O类的基类)中定义，常用的值如下：ios::app： //以追加的方式打开文件ios::ate：//文件打开后定位到文件尾，ios:app就包含有此属性ios::binary：//以二进制方式打开文件，缺省的方式是文本方式。
两种方式的区别见前文ios::in：//文件以输入方式打开（文件数据输入到内存）ios::out：//文件以输出方式打开（内存数据输出到文件）ios::nocreate：//不建立文件，所以文件不存在时打开失败ios::noreplace：//不覆盖文件，所以打开文件时如果文件存在失败ios::trunc：//如果文件存在，把文件长度设为0可以用“或”把以上属性连接起来，如ios::out|ios::binary打开文件的属性取值是：0：普通文件，打开访问1：只读文件2：隐含文件4：系统文件可以用“或”或者“+”把以上属性连接起来，如3或1|2就是以只读和隐含属性打开文件。
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来定义。
qt中的fstream用法
qt中的fstream用法在Qt中，fstream 并不是Qt特有的类，而是C++标准库中的一个类，用于文件流操作。
fstream 是 std::fstream 的简称，用于在C++程序中读写文件。
Qt作为一个跨平台的C++应用程序框架，可以无缝地使用C++标准库中的功能，包括fstream。
下面是一个简单的例子，展示了如何在Qt中使用fstream来打开一个文件，写入一些数据，然后关闭文件。
cpp#include <fstream>#include <iostream>int main() {// 创建一个输出文件流对象std::ofstream outfile("example.txt");// 检查文件是否成功打开if (!outfile.is_open()) {std::cerr << "无法打开文件" << std::endl;return 1;}// 向文件写入数据outfile << "Hello, World!" << std::endl;// 关闭文件outfile.close();// 创建一个输入文件流对象std::ifstream infile("example.txt");// 检查文件是否成功打开if (!infile.is_open()) {std::cerr << "无法打开文件" << std::endl;return 1;}// 从文件读取数据std::string line;while (std::getline(infile, line)) {std::cout << line << std::endl;}// 关闭文件infile.close();return 0;}在这个例子中，我们首先创建了一个std::ofstream对象来写入一个名为example.txt 的文件。
C++ fstream的使用方法
c++ fstream 使用(一)2009-07-14 10:37（1）基本使用1、包含的头文件#include <fstream>using namespace std;1)C++中的三个文件流ofstream ofs("文件名", 打开方式);ifstream ifs("文件名", 打开方式);fstream fs("文件名",输入打开方式| 输出打开方式);三种文件流分别用于写文件、读文件、读写文件三种文件流都可先定义，再打开文件，以fstream为例fstream fs;fs.open("文件名", 输入打开方式| 输出打开方式);其中“打开方式”可以不给出。
若不给出，对于oftream默认为ios::out，iftream默认为ios::in2)打开方式ios::out 输出数据覆盖现有文件ios::app 输出数据填加之现有文件末尾ios::ate 打开文件并移动文件指针至末尾ios::in 打开文件以输入ios::trunc 输出文件中现有内容（ios::out的默认操作）ios::binary 二进制打开供读写2、文件指针和C的文件操作方式不同的是，C++ I/O系统管理两个与一个文件相联系的指针。
一个是读指针，它说明输入操作在文件中的位置；另一个是写指针，它下次写操作的位置。
每次执行输入或输出时，相应的指针自动变化。
所以，C++的文件定位分为读位置和写位置的定位，对应的成员函数是 seekg()和 seekp()，seekg()是设置读位置，seekp是设置写位置。
它们最通用的形式如下：istream &seekg(streamoff offset,seek_dir origin);ostream &seekp(streamoff offset,seek_dir origin);streamoff定义于 iostream.h 中，定义有偏移量 offset 所能取得的最大值，seek_dir 表示移动的基准位置，是一个有以下值的枚举：ios::beg：文件开头ios::cur：文件当前位置ios::end：文件结尾这两个函数一般用于二进制文件，因为文本文件会因为系统对字符的解释而可能与预想的值不同。
c++中fstream对txt文件的读写操作
c++中fstream对txt⽂件的读写操作c语⾔中，对⽂件的操作⼀般通过⽂件指针FILE*来进⾏。
然⽽，c++有着更为便捷的操作——⽂件流。
好吧，其实我也不是很熟悉“流”的具体概念，等以后深⼊学习后，⼀定会把这个坑填上。
在此简单记录⼀下⽂件流fstream的⽤法；可以简单得把它看成⼀个类，包含在头⽂件<fstream>中。
当我们写上#include<fstream>后，就可以使⽤ifstream，ofstream，fstream三个类来定义对象了。
例如：ifstream infile（）；成功定义了⼀个名叫infile的对象，可以调⽤ifstream中的函数；但是，此时infile只是⼀个对象，并没有和我们需要读取的⽂件产⽣关联。
⽬前，我发现共有两种⽅式1、通过ifstream的函数 .open(),这个函数有⼏种重载的⽅式1. ⾸先，关于路径，⼀共有5种⽅式：1. 相对路径，当你所要操作的⽂件与你的.cpp⽂件在同⼀个⽬录下，就可以使⽤相对路径，相对路径必须将⽂件格式写清楚，例如：infile.open("ans.txt");2. 绝对路径，可以搜索到电脑中所有的⽂件，但路径必须正确，例如：infile.open("D:\Codeblock\test\formulations.txt");3. 可以填⼊⼀个是指向字符串⽂件名的指针，例如：const char* str=”ans.txt"; infile.open(str);4. 可以填写⼀个内容等于⽂件名字的string常量，例如：const string str = “ans.txt"; infile.open(str);5. 如果不是const string ，⽽是string，那必须使⽤infile(str.c_str()); 此处.c_str()是string的⼀个成员函数,⽬标是将string变成conststring .关于string和const string 之间的区别嘛,emmmmmm,有空⼀定填上2. ios::app //在⽂件末尾补⼊ios::ate //定位到⽂件末尾,app包含此项属性ios::binary //以⼆进制的⽅式读取⽂件ios::in//读⽂件ios::out//输⼊⽂件ios::nocreate //不创造,如果⽂件不存在,则失败ios::noreplace//不覆盖,如果⽂件存在,则失败ios::trunc //如果⽂件存在,则将⽂件内容清空 3.多种⽂件的打开⽅式能使⽤或运算("|") ,例如:infile("ans.txt",ios::app | ios::out);4.打开⽂件的属性,prot.好像不常⽤,等哪天⽤到了,再来写2. 第⼆种打开⽅式则更为简单,利⽤初始化的⽅法,例如 ifstream infile("ans.txt");当然,初始化的时候,也可以加上mode,例如 ifstream infile("ans.txt",ios::app);.is_open() 的⽤法#include <fstream>using namespace std;int mian(){ifstream infile ;infile.open("ans.txt");if(!infile.is_open()){cout<<"Wrong"<<endl;return0;}.......................return0;}。
fstream、ifstream、ofsream使用
写程序时，有一段代码使用了fstream来创建、读写隐藏文件，但是却发现了一些奇怪的问题：该创建时不创建，存在时却无法读取、修改，下面对这三类对象做了测试和总结，记录如下：1 测试文件不存在时创建文件=========================================================fstream fs("aaa.txt", ios_base::in) 不创建fstream fs("aaa.txt", ios_base::out) 创建fstream fs("aaa.txt", ios_base::trunc) 不创建fstream fs("aaa.txt"); //等同于下行fstream fs("aaa.txt", ios_base::in | ios_base::out) 不创建fstream fs("aaa.txt", ios_base::in | ios_base::trunc); 不创建fstream fs("aaa.txt", ios_base::out | ios_base::trunc); 创建fstream fs("aaa.txt", ios_base::in | ios_base::out | ios_base::trunc); 创建以上总结：fstream 在文件不存在时创建要么单独使用ios_base::out要么同时使用ios_base::out | ios_base::trunc=========================================================ofstream与fstream并没有太大不同，只是在你打开时，不管有没加ios_base::out，反正都会或一次（“_Mode | ios_base::out”）由前文结论可推断，以下三种情况会创建文件，其余都不创建：ofstream ofs("aaa.txt")ofstream ofs("aaa.txt", ios_base::trunc)ofstream ofs("aaa.txt", ios_base::in | ios_base::trunc)2 测试读取隐藏文件=========================================================fstream fs("aaa.txt", ios_base::in) 能fstream fs("aaa.txt", ios_base::out) 不能fstream fs("aaa.txt", ios_base::trunc) 不能fstream fs("aaa.txt"); //等同于下行fstream fs("aaa.txt", ios_base::in | ios_base::out) 能fstream fs("aaa.txt", ios_base::in | ios_base::trunc); 不能fstream fs("aaa.txt", ios_base::out | ios_base::trunc); 不能fstream fs("aaa.txt", ios_base::in | ios_base::out | ios_base::trunc); 不能以上总结：fstream打开隐藏文件要么单独使用ios_base::in要么不能有ios_base::trunc=========================================================ifstream与fstream也没有太大不同，只是在你打开时，不管有没加ios_base::in，反正都会或一次（“_Mode | ios_base::in”）由前文结论可推断，以下两种情况能打开文件，其余都不能：ifstream ifs("aaa.txt")ifstream ofs("aaa.txt", ios_base::out)3 测试读取普通文件=========================================================fstream fs("aaa.txt", ios_base::in) 能fstream fs("aaa.txt", ios_base::out) 能fstream fs("aaa.txt", ios_base::trunc) 不能fstream fs("aaa.txt"); //等同于下行fstream fs("aaa.txt", ios_base::in | ios_base::out) 能fstream fs("aaa.txt", ios_base::in | ios_base::trunc); 不能fstream fs("aaa.txt", ios_base::out | ios_base::trunc); 能fstream fs("aaa.txt", ios_base::in | ios_base::out | ios_base::trunc); 能以上总结：fstream打开普通文件用ios_base::trunc时必须同时有ios_base::out=========================================================ifstream与fstream也没有太大不同，只是在你打开时，不管有没加ios_base::in，反正都会或一次（“_Mode | ios_base::in”）由前文结论可推断，以下一种情况不能打开文件，其余都能：ifstream ofs("aaa.txt", ios_base::trunc)。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
ofstream/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"的操作很像。
对不了解控制台输出"cout"的人, 这里有个例子。
int num = 150;char name[] = "John Doe";fout << "Here is a number: " << num << "\n";fout << "Now here is a string: " << name << "\n";现在保存文件，你必须关闭文件，或者回写文件缓冲. 文件关闭之后就不能再操作了, 所以只有在你不再操作这个文件的时候才调用它，它会自动保存文件。
回写缓冲区会在保持文件打开的情况下保存文件, 所以只要有必要就使用它。
回写看起来像另一次输出, 然后调用方法关闭。
像这样：fout << flush; fout.close();现在你用文本编辑器打开文件，内容看起来是这样：Here is a number: 150 Now here is a string: John Doe很简单吧! 现在继续文件输入, 需要一点技巧, 所以先确认你已经明白了流操作，对"<<" 和">>" 比较熟悉了, 因为你接下来还要用到他们。
继续…二、ASCII 输入输入和"cin" 流很像. 和刚刚讨论的输出流很像, 但你要考虑几件事情。
在我们开始复杂的内容之前, 先看一个文本：12 GameDev 15.45 L This is really awesome!为了打开这个文件，你必须创建一个in-stream对象,?像这样。
ifstream fin("input.txt");现在读入前四行. 你还记得怎么用"<<" 操作符往流里插入变量和符号吧？好,?在"<<" (插入)?操作符之后，是">>" (提取) 操作符. 使用方法是一样的. 看这个代码片段.int number;float real;char letter, word[8];fin >> number; fin >> word; fin >> real; fin >> letter;也可以把这四行读取文件的代码写为更简单的一行。
fin >> number >> word >> real >> letter;它是如何运作的呢? 文件的每个空白之后, ">>" 操作符会停止读取内容, 直到遇到另一个>>操作符. 因为我们读取的每一行都被换行符分割开(是空白字符), ">>" 操作符只把这一行的内容读入变量。
这就是这个代码也能正常工作的原因。
但是，可别忘了文件的最后一行。
This is really awesome!如果你想把整行读入一个char数组, 我们没办法用">>"?操作符，因为每个单词之间的空格（空白字符）会中止文件的读取。
为了验证：char sentence[101]; fin >> sentence;我们想包含整个句子, "This is really awesome!" 但是因为空白, 现在它只包含了"This". 很明显, 肯定有读取整行的方法, 它就是getline()。
这就是我们要做的。
fin.getline(sentence, 100);这是函数参数. 第一个参数显然是用来接受的char数组. 第二个参数是在遇到换行符之前，数组允许接受的最大元素数量. 现在我们得到了想要的结果：“This is really awesome!”。
你应该已经知道如何读取和写入ASCII文件了。
但我们还不能罢休，因为二进制文件还在等着我们。
三、二进制输入输出二进制文件会复杂一点, 但还是很简单的。
首先你要注意我们不再使用插入和提取操作符(译者注：<< 和>> 操作符). 你可以这么做，但它不会用二进制方式读写。
你必须使用read() 和write() 方法读取和写入二进制文件. 创建一个二进制文件, 看下一行。
ofstream fout("file.dat", ios::binary);这会以二进制方式打开文件, 而不是默认的ASCII模式。
首先从写入文件开始。
函数write() 有两个参数。
第一个是指向对象的char类型的指针, 第二个是对象的大小（译者注：字节数）。
为了说明，看例子。
int number = 30; fout.write((char *)(&number), sizeof(number));第一个参数写做"(char *)(&number)". 这是把一个整型变量转为char *指针。
如果你不理解，可以立刻翻阅C++的书籍，如果有必要的话。
第二个参数写作"sizeof(number)". sizeof() 返回对象大小的字节数. 就是这样!二进制文件最好的地方是可以在一行把一个结构写入文件。
如果说，你的结构有12个不同的成员。
用ASCII?文件，你不得不每次一条的写入所有成员。
但二进制文件替你做好了。
看这个。
struct OBJECT { int number; char letter; } obj;obj.number = 15;obj.letter = ‘M’;fout.write((char *)(&obj), sizeof(obj));这样就写入了整个结构! 接下来是输入. 输入也很简单，因为read()?函数的参数和write()是完全一样的, 使用方法也相同。
ifstream fin("file.dat", ios::binary); fin.read((char *)(&obj), sizeof(obj));我不多解释用法, 因为它和write()是完全相同的。
二进制文件比ASCII文件简单, 但有个缺点是无法用文本编辑器编辑。
接着, 我解释一下ifstream 和ofstream 对象的其他一些方法作为结束.四、更多方法我已经解释了ASCII文件和二进制文件, 这里是一些没有提及的底层方法。
检查文件你已经学会了open() 和close() 方法, 不过这里还有其它你可能用到的方法。
方法good() 返回一个布尔值，表示文件打开是否正确。
类似的，bad() 返回一个布尔值表示文件打开是否错误。
如果出错，就不要继续进一步的操作了。
最后一个检查的方法是fail(), 和bad()有点相似, 但没那么严重。
读文件方法get() 每次返回一个字符。
方法ignore(int,char) 跳过一定数量的某个字符, 但你必须传给它两个参数。
第一个是需要跳过的字符数。
第二个是一个字符, 当遇到的时候就会停止。
例子,fin.ignore(100, ‘\n’);会跳过100个字符，或者不足100的时候，跳过所有之前的字符，包括‘\n’。
方法peek() 返回文件中的下一个字符, 但并不实际读取它。
所以如果你用peek() 查看下一个字符,用get() 在peek()之后读取，会得到同一个字符, 然后移动文件计数器。
方法putback(char) 输入字符, 一次一个, 到流中。
我没有见到过它的使用，但这个函数确实存在。
写文件只有一个你可能会关注的方法.?那就是put(char), 它每次向输出流中写入一个字符。
打开文件当我们用这样的语法打开二进制文件:ofstream fout("file.dat", ios::binary);"ios::binary"是你提供的打开选项的额外标志. 默认的, 文件以ASCII方式打开, 不存在则创建, 存在就覆盖. 这里有些额外的标志用来改变选项。
ios::app 添加到文件尾ios::ate 把文件标志放在末尾而非起始。
ios::trunc 默认. 截断并覆写文件。
ios::nocreate 文件不存在也不创建。
ios::noreplace 文件存在则失败。
文件状态我用过的唯一一个状态函数是eof(), 它返回是否标志已经到了文件末尾。