C++ fstream的使用方法

c++ fstream 使用(一)

2009-07-14 10:37

（1）基本使用1、包含的头文件

#include

using namespace std;

1)C++中的三个文件流

ofstream ofs("文件名", 打开方式);

ifstream ifs("文件名", 打开方式);

fstream fs("文件名",输入打开方式| 输出打开方式);

三种文件流分别用于写文件、读文件、读写文件

三种文件流都可先定义，再打开文件，以fstream为例

fstream fs;

fs.open("文件名", 输入打开方式| 输出打开方式);

其中“打开方式”可以不给出。

若不给出，对于oftream默认为ios::out，iftream默认为ios::in

2)打开方式

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：文件结尾

这两个函数一般用于二进制文件，因为文本文件会因为系统对字符的解释而可能与预想的值不同。

例：

file1.seekg(1234,ios::cur);//把文件的读指针从当前位置向后移1234个字

节

file2.seekp(1234,ios::beg);//把文件的写指针从文件开头向后移1234个字

节

file1.seekg(-128,ios::end); //把文件的读指针从文件末尾向前移128个字节(注意偏移量用负数。靠，这么特殊的情况，网上一群傻逼都不写。)

c++ fstream 使用(二)

2008-10-01 23:53

(2)使用getline和ifstream读取文件

假设有一个叫data.txt的文件, 它包含以下内容:

Fry: One Jillion dollars.

[Everyone gasps.]

Auctioneer: Sir, that's not a num ber.

数据读取，测试。

以下就是基于data.txt 的数据读取操作:

#include

#include

#include

using namespace std;

//输出空行

void OutPutAnEmptyLine()

{

cout<<"\n";

}

//读取方式: 逐词读取, 词之间用空格区分

//read data from the file, W ord B y W ord

//when used in this manner, we'll get space-delimited bits of text from the file

//but all of the whitespace that separated words (including newlines) was lost.

void ReadDataFromFileWBW()

{

ifstream fin("data.txt");

string s;

while( fin >> s )

{

cout <<"Read from file: " << s << endl;

}

}

//读取方式: 逐行读取, 将行读入字符数组, 行之间用回车换行区分

//If we were interested in preserving whitespace,

//we could read the file in L ine-B y-L ine using the I/O getline() function.

void ReadDataFromFileLBLIntoCharArray()

{

ifstream fin("data.txt");

const int LINE_LENGT H =100;

char str[LINE_LENGT H];

while( fin.getline(str,LINE_LENGTH) )

{

cout <<"Read from file: " << str << endl;

}

}

//读取方式: 逐行读取, 将行读入字符串, 行之间用回车换行区分

//If you want to avoid reading into character arrays,

//you can use the C++ string getline() function to read lines into strings

void ReadDataFromFileLBLIntoString()

{

ifstream fin("data.txt");

string s;

while( getline(fin,s) )

{

cout <<"Read from file: " << s << endl;

}

}

//带错误检测的读取方式

//Simply evaluating an I/O object in a boolean context will return false

//if any errors have occurred

void ReadDataWithErrChecking()

{

string filename ="dataFUNNY.txt";

ifstream fin( filename.c_str());

if( !fin )

{

cout <<"Error opening " << filename <<" for input" << endl;

exit(-1);

}

}

int m ain()

{

ReadDataFromFileWBW(); //逐词读入字符串

OutPutAnEmptyLine(); //输出空行

ReadDataFromFileLBLIntoCharArray(); //逐词读入字符数组

OutPutAnEmptyLine(); //输出空行

ReadDataFromFileLBLIntoString(); //逐词读入字符串

OutPutAnEmptyLine(); //输出空行

ReadDataWithErrChecking(); //带检测的读取

return0;

}

输出结果为:

Read from file: Fry:

Read from file: One

Read from file: Jillion

Read from file: dollars.

Read from file: [Everyone

Read from file: gasps.]

Read from file: Auctioneer:

Read from file: Sir,

Read from file: that's

Read from file: not

Read from file: a

Read from file: number.

Read from file: 数据读取，

Read from file: 测试

Read from file: 。

Read from file: Fry: One Jillion dollars.

Read from file: [Everyone gasps.]

Read from file: Auctioneer: Sir, that's not a number.

Read from file: 数据读取，测试。

Read from file: Fry: One Jillion dollars.

Read from file: [Everyone gasps.]

Read from file: Auctioneer: Sir, that's not a number.

Read from file: 数据读取，测试。

Error opening dataFUNNY.txt for input

Press any key to continue

C++中ifstream、ofstream的用法

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就是以只读和隐含属性打开文件。

例如：以二进制输入方式打开文件c:\config.sys

fstream file1;

file1.open("c:\\config.sys",ios::binary|ios::in,0);

如果open函数只有文件名一个参数，则是以读/写普通文件打开，即：

file1.open("c:\\config.sys"); <=>

file1.open("c:\\config.sys",ios::in|ios::out,0);

另外，fstream还有和open()一样的构造函数，对于上例，在定义的时侯就可以打开文件了：

fstream file1("c:\\config.sys");

特别提出的是，fstream有两个子类：ifstream(input file stream)和ofstream(outpu file stream)，ifstream默认以输入方式打开文件，而ofstream 默认以输出方式打开文件。

ifstream file2("c:\\pdos.def");//以输入方式打开文件

ofstream file3("c:\\x.123");//以输出方式打开文件

所以，在实际应用中，根据需要的不同，选择不同的类来定义：如果想以输入方式打开，就用ifstream来定义；如果想以输出方式打开，就用ofstream 来定义；如果想以输入/输出方式来打开，就用fstream来定义。

二、关闭文件

打开的文件使用完成后一定要关闭，fstream提供了成员函数close()来完成此操作，如：file1.close();就把file1相连的文件关闭。

三、读写文件

读写文件分为文本文件和二进制文件的读取，对于文本文件的读取比较简单，用插入器和析取器就可以了；而对于二进制的读取就要复杂些，下要就详细的介绍这两种方式

1、文本文件的读写

文本文件的读写很简单：用插入器(<<)向文件输出；用析取器(>>)从文件输入。假设file1是以输入方式打开，file2以输出打开。示例如下：

file2<<"I Love You";//向文件写入字符串"I Love You"

int i;

file1>>i;//从文件输入一个整数值。

这种方式还有一种简单的格式化能力，比如可以指定输出为16进制等等，具体的格式有以下一些

操纵符功能输入/输出

dec 格式化为十进制数值数据输入和输出

endl 输出一个换行符并刷新此流输出

ends 输出一个空字符输出

hex 格式化为十六进制数值数据输入和输出

oct 格式化为八进制数值数据输入和输出

setpxecision(int p) 设置浮点数的精度位数输出

比如要把123当作十六进制输出：file1<

位精度输出：file1<

2、二进制文件的读写

①put()

put()函数向流写入一个字符，其原型是ofstream &put(char ch)，使用也比较简单，如file1.put('c');就是向流写一个字符'c'。

②get()

get()函数比较灵活，有3种常用的重载形式：

一种就是和put()对应的形式：ifstream &get(char &ch);功能是从流中读取一个字符，结果保存在引用ch中，如果到文件尾，返回空字符。如file2.get(x);表示从文件中读取一个字符，并把读取的字符保存在x中。

另一种重载形式的原型是： int get();这种形式是从流中返回一个字符，如果到达文件尾，返回EOF，如x=file2.get();和上例功能是一样的。

还有一种形式的原型是：ifstream &get(char *buf,int num,char

delim='\n')；这种形式把字符读入由 buf 指向的数组，直到读入了 num 个字符或遇到了由 delim 指定的字符，如果没使用 delim 这个参数，将使用缺省值换行符'\n'。例如：

file2.get(str1,127,'A'); //从文件中读取字符到字符串str1，当遇到字符'A'或读取了127个字符时终止。

③读写数据块

要读写二进制数据块，使用成员函数read()和write()成员函数，它们原型如下：

read(unsigned char *buf,int num);

write(const unsigned char *buf,int num);

read()从文件中读取 num 个字符到 buf 指向的缓存中，如果在还未读入num 个字符时就到了文件尾，可以用成员函数 int gcount();来取得实际读取的字符数；而 write() 从buf 指向的缓存写 num 个字符到文件中，值得注意的是缓存的类型是 unsigned char *，有时可能需要类型转换。

例：

unsigned char str1[]="I Love You";

int n[5];

ifstream in("xxx.xxx");

ofstream out("yyy.yyy");

out.write(str1,strlen(str1));//把字符串str1全部写到yyy.yyy中

in.read((unsigned char*)n,sizeof(n));//从xxx.xxx中读取指定个整数，注意类型转换

in.close();out.close();

四、检测EOF

成员函数eof()用来检测是否到达文件尾，如果到达文件尾返回非0值，否则返回0。原型是int eof();

例： if(in.eof()) ShowMessage("已经到达文件尾！");

五、文件定位

和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：文件结尾

这两个函数一般用于二进制文件，因为文本文件会因为系统对字符的解释而可能与预想的值不同。例：

file1.seekg(1234,ios::cur); //把文件的读指针从当前位置向后移1234个字节

file2.seekp(1234,ios::beg); //把文件的写指针从文件开头向后移1234个字节

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

C++文件操作详解（ifstream 、ofstream 、fstream ） C++通过以下几个类支持文件的输入输岀: ofstream: 写操作（输岀）的文件类 ifstream: 读操作（输入）的文件类 fstream: 可同时读写操作的文件类 打开 文件（Open a file ） 对这些类的一个对象所做的第一个操作通常就是将它和一个真正的文件联系起来， 也就是说打开 一个文件。被打开的文件在程序中由一个流对象 （stream object ）来表示（这些类的一个实例）， 而对这个流对象所做的任何输入输岀操作实际就是对该文件所做的操作。 要通过一个流对象打开一个文件，我们使用它的成员函数 open （）: void ope n （const char * file name, ope nm ode mode ）; 这里file name 是一个字符串，代表要打开的文件名， mode 是以下标志符的一个组合： ios::i n 为输入（读）而打开文件 ios::out 为输岀（写）而打开文件 ios::ate 初始位置：文件尾 ios::app 所有输岀附加在文件末尾 ios::tru nc 如果文件已存在则先删除该文件 ios::b inary 二进制方式 这些标识符可以被组合使用，中间以 ”或”操作符（|）间隔。例如，如果我们想要以二进制方式打 开文件"example.bin" 来写入一些数据，我们可以通过以下方式调用成员函数 open （）来实现: ofstream file; file.ope n （"example.b in ”，ios::out | ios::app | ios::b in ary ）; ofstream, ifstream 和fstream 所有这些类的成员函数 ope n 都包含了一个默认打开文件的方 式，这三个类的默认方式各不相同： 类 参数的默认方式 ofstream i os::out | ios::trunc ifstream i os::in fstream ios::i n | ios::out 只有当函数被调用时没有声明方式参数的情况下， 默认值才会被采用。 如果函数被调用时声明了 任何参数，默认值将被完全改写，而不会与调用参数组合。 由于对类ofstream, ifstream 和fstream 的对象所进行的第一个操作通常都是打开文件，这 些类都有一个构造函数可以直接调用 open 函数，并拥有同样的参数。这样，我们就可以通过以 下方式进行与上面同样的定义对象和打开文件的操作： （由ostream 引申而来） （由istream 引申而来） （由iostream 引申而来）

C FSTREAM文件操作详细说明

fstream文件操作详细说明 目录 一、打开文件 (2) 二、关闭文件 (3) 三、读写文件 (3) 1、文本文件的读写 (3) 2、二进制文件的读写 (4) 四、检测EOF (5) 五、文件定位 (5)

fstream文件操作详细说明 在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：系统文件 可以用“或”或者“+”把以上属性连接起来，如：1|2就是以只读和隐含属性打开文件。 例如：以二进制输入方式打开文件c:\config.sys

fstream_h

fstream.h #if _MSC_VER > 1000 #pragma once #endif #ifdef __cplusplus #ifndef _INC_FSTREAM #define _INC_FSTREAM #if !defined(_WIN32) && !defined(_MAC) #error ERROR: Only Mac or Win32 targets supported! #endif #ifdef _MSC_VER // Currently, all MS C compilers for Win32 platforms default to 8 byte alignment. #pragma pack(push,8) #include #endif // _MSC_VER /* Define _CRTIMP */ #ifndef _CRTIMP #ifdef _DLL #define _CRTIMP __declspec(dllimport) #else /* ndef _DLL */ #define _CRTIMP #endif /* _DLL */ #endif /* _CRTIMP */ #include #ifdef _MSC_VER // C4514: "unreferenced inline function has been removed" #pragma warning(disable:4514) // disable C4514 warning // #pragma warning(default:4514) // use this to reenable, if desired #endif // _MSC_VER typedef int filedesc; class _CRTIMP filebuf : public streambuf { public: static const int openprot; // default share/prot mode for open // optional share values for 3rd argument (prot) of open or constructor static const int sh_none; // exclusive mode no sharing static const int sh_read; // allow read sharing static const int sh_write; // allow write sharing // use (sh_read | sh_write) to allow both read and write sharing options for setmode member function static const int binary; static const int text; filebuf(); filebuf(filedesc);

fstream用法

ofstream/ifstream 文本/二进制方式读入/写出数据方法 文件I/O 在C++中比烤蛋糕简单多了。在这篇文章里，我会详细解释ASCII和二进制文件的输入输出的每个细节，值得注意的是，所有这些都是用C++完成的。 一、ASCII 输出 为了使用下面的方法, 你必须包含头文件(译者注：在标准C++中，已经使用取代< fstream.h>，所有的C++标准头文件都是无后缀的。)。这是的一个扩展集, 提供有缓冲的文件输入输出操作. 事实上, 已经被包含了, 所以你不必包含所有这两个文件, 如果你想显式包含他们，那随便你。我们从文件操作类的设计开始, 我会讲解如何进行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"; 现在保存文件，你必须关闭文件，或者回写文件缓冲. 文件关闭之后就不能再操作了, 所以只有在你不再操作这个文件的时候才调用它，它会自动保存文件。回写缓冲区会在保持文件打开的情况下保存文件, 所以只要有必要就使用它。回写看起来像另一次输出, 然后调用方法关闭。像这样：

ofstream的使用方法

ofstream的使用方法 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就是以只读和隐含属性打开文件。 例如：以二进制输入方式打开文件c:\config.sys fstream file1; file1.open("c:\\config.sys",ios::binary|ios::in,0); 如果open函数只有文件名一个参数，则是以读/写普通文件打开，即： file1.open("c:\\config.sys"); <=> file1.open("c:\\config.sys",ios::in|ios::out,0); 另外，fstream还有和open()一样的构造函数，对于上例，在定义的时侯就可以打开文件了：

ofstream和ifstream详细用法

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就是以只读和隐含属性打开文件。 例如：以二进制输入方式打开文件c:\config.sys fstream file1? file1.open("c:\\config.sys",ios::binary|ios::in,0)?

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

【转载】C++中文件流(fstream)的使用方法及示例 (2011-08-22 16:00:14)转载▼ 分类：编程拾萃 标签：杂 谈 C++文件流： fstream // 文件流 ifstream // 输入文件流 ofstream // 输出文件流 头文件： #include //创建一个文本文件并写入信息 //同向屏幕上输出信息一样将信息输出至文件 #include #include 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

C文件操作详解ifstreamofstreamfstream

C++文件操作详解（ifstream、ofstream、fstream） C++ 通过以下几个类支持文件的输入输出： ?ofstream: 写操作（输出）的文件类(由ostream引申而来) ?ifstream: 读操作（输入）的文件类(由istream引申而来) ?fstream: 可同时读写操作的文件类(由iostream引申而来) 打开文件(Open a file) 对这些类的一个对象所做的第一个操作通常就是将它和一个真正的文件联系起来，也就是说打开一个文件。被打开的文件在程序中由一个流对象(stream object)来表示(这些类的一个实例) ，而对这个流对象所做的任何输入输出操作实际就是对该文件所做的操作。 要通过一个流对象打开一个文件，我们使用它的成员函数open()： void open (const char * , openmode mode); 这里是一个字符串，代表要打开的文件名，mode 是以下标志符的一个组合： 这些标识符可以被组合使用，中间以”或”操作符(|)间隔。例如，如果我们想要以二进制方式打开文件"example.bin" 来写入一些数据，我们可以通过以下方式调用成员函数open（）来实现： ofstream file; ("example.bin", ios::out | ios::app | ios::binary); ofstream, ifstream 和fstream所有这些类的成员函数open 都包含了一个默认打开文件的方式，这三个类的默认方式各不相同： 只有当函数被调用时没有声明方式参数的情况下，默认值才会被采用。如果函数被调用时声明了任何参数，默认值将被完全改写，而不会与调用参数组合。 由于对类ofstream, ifstream 和fstream 的对象所进行的第一个操作通常都是打开文件，这些类都有一个构造函数可以直接调用open 函数，并拥有同样的参数。这样，我们就可以通过以下方式进行与上面同样的定义对象和打开文件的操作：

sstream库函数用法详解

C++的sstream标准库介绍 C++风格的串流控制，C++引入了ostringstream、istringstream、stringstream这三个类，要使用他们创建对象就必须包含sstream头文件。 istringstream类用于执行C++风格的串流的输入操作。 ostringstream类用于执行C风格的串流的输出操作。 stringstream类同时可以支持C风格的串流的输入输出操作。 istringstream类是从istream（输入流类）和stringstreambase（c++字符串流基类）派生而来， ostringstream是从ostream（输出流类）和stringstreambase（c++字符串流基类）派生而来， stringstream则是从iostream(输入输出流类)和和stringstreambase （c++字符串流基类）派生而来。 istringstream是由一个string对象构造而来，istringstream类从一个string对象读取字符。 istringstream的构造函数原形如下： istringstream::istringstream(string str); //程序作者:管宁 //站点:https://www.doczj.com/doc/b95329692.html, //所有稿件均有版权,如要转载,请务必著名出处和作者 #include #include using namespace std; int main() { istringstream istr; istr.str("1 56.7",); //上述两个过程可以简单写成 istringstream istr("1 56.7"); cout << istr.str()<>a; cout<>b; cout<

stream的用法总结大全

stream的用法总结大全 想知道stream的用法吗?今天给大家带来了stream的用法，希望能够帮助到大家，下面就和大家分享，来欣赏一下吧。 stream的用法总结大全 stream的意思 n. 河流，小河，川，溪,潮流，趋势，倾向,(事件等的)连续，(财富等的)滚滚而来,流出，流注，一连串 vt. vi. 流，流动 vi. 飘扬,招展,鱼贯而行,一个接一个地移动 vt. 按能力分班(或分组),按能力分班(或分组) 变形：过去式: streamed; 现在分词：streaming; 过去分词：streamed; stream用法 stream可以用作动词 stream的基本意思是“流动”,指受限制的流动,如通过一定的路线或出口。也可指大量不断地流动。引申可指“飘动”。

stream既可用作及物动词,也可用作不及物动词。用作及物动词时,可接名词或代词作宾语。 stream接介词with表示“被…覆盖”。 stream用作动词的用法例句 Cars stream along the highway.汽车在公路上流水般地行驶。 They streamed out of the cinema.他们涌出电影院。 Her hair streamed(out) in the wind.她的头发迎风飘动着. stream用法例句 1、The tidal stream or current gradually decreases in the shallows. 浅滩上的潮水逐渐退去。 2、When someone has hayfever, the eyes and nose will stream and itch. 花粉热临床表现为流泪、流涕，眼睛、鼻子发痒。 3、Businessmen stream into one of Tokyos 商人不断涌进东京的一个主要火车站。 stream是什么意思及用法

fstream和ifstream详细用法

文件 I/O 在C++中比烤蛋糕简单多了。在这篇文章里，我会详细解释ASCII和二进制文件的输入输出的每个细节，值得注意的是，所有这些都是用C++完成的。 一、ASCII 输出 为了使用下面的方法, 你必须包含头文件(译者注：在标准C++中，已经使用取代< fstream.h>，所有的C++标准头文件都是无后缀的。)。这是 的一个扩展集, 提供有缓冲的文件输入输出操作. 事实上, 已经被包含了, 所以你不必包含所有这两个文件, 如果你想显式包含他们，那随便你。我们从文件操作类的设计开始, 我会讲解如何进行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 很简单吧! 现在继续文件输入, 需要一点技巧, 所以先确认你已经明白了流操作，对 "<<" 和">>" 比较熟悉了, 因为你接下来还要用到他们。继续…

fstream头文件3类的各功能

1.ios::app ----写入的数据将被追加在文件的末尾，此方式使用ios::out 2.ios::ate ----写入的数据将被追加在文件的末尾，此方式不使用ios::out 但是我看不懂最后一句，什么叫使用和不使用“ios::out”呢？？ ios::out本身不是就是打开一个可写文件吗？ 既然都能追加写入了，还能不让写？ 1. 1.ios::app ----写入的数据将被追加在文件的末尾，此方式使用ios::out 2.ios::ate ----写入的数据将被追加在文件的末尾，此方式不使用ios::out ios::app 多个线程或者进程对一个文件写的时候,假如文件原来的内容是abc，第一个线程(进程)往里面写了个d,第二个线程(进程)写了个e的话，结果是abcde ios: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打开，如果没有文件则创建文件，如果有，则清空文件。 以ios::ate|ios::out|ios::in打开，如果没有文件，则打开失败，有文件则定位到文件尾 可见：ios::app不能用来打开输入流，即不能和ios::in相配合 而ios::ate可以和ios::in配合，此时定位到文件尾；如果没有ios::in相配合而只是同ios::out 配合，那么将清空原文件 类名读写不支持 ofstream 如要读，需要加 ★>> ios::in << ifstream ★如要读，需要加 ios::out fstream ★ios::in ★ios::out 在一个流里不能 同时读写

C++文件读写详解(ofstream,ifstream,fstream)及C++ string类

在看C++编程思想中，每个练习基本都是使用ofstream,ifstream,fstream，以前粗略知道其用法和含义，在看了几位大牛的博文后，进行整理和总结： 这里主要是讨论fstream的内容： [java]view plaincopyprint? 1.#include 2.ofstream //文件写操作内存写入存储设备 3.ifstream //文件读操作，存储设备读区到内存中 4.fstream //读写操作，对打开的文件可进行读写操作 1.打开文件 在fstream类中，成员函数open（）实现打开文件的操作，从而将数据流和文件进行关联，通过ofstream,ifstream,fstream对象进行对文件的读写操作 函数：open（） [cpp]view plaincopyprint? 1. 2.public member function 3. 4.void open ( const char * filename, 5. ios_base::openmode mode = ios_base::in | ios_base::out ); 6. 7.void open(const wchar_t *_Filename, 8. ios_base::openmode mode= ios_base::in | ios_base::out, 9.int prot = ios_base::_Openprot)； 10. 11.

fstream的IO处理

如何使用 类进行文件的I/O 处理 作者：Danny Kalev 编译：MTT 工作室 下载源代码 原文出处：How to Use Classes for File I/O 摘要：传统的文件I/O 库如Un ix的 和 ，由于其程 序接口的原因，在很大程度上强制程序员进行某些处理，缺乏类型安全和 国际化支持。C++ 的 库则在文件的I/O 方面提供了一个增 强的、面向对象的、具有国际化意识的库。本文将介绍如何使用这个库进 行文件的I/O 处理并利用它来编写易于跨平台的代码。 大多数C++ 程序员都熟悉不止一个文件I/O 库。首先是传统的Un ix风格的库，它由一些低级函数如r ead() 和open()组成。其次是ANS I C 的 库，它包含fopen() 和fr ead()等函数。其它的还有一些具备所有权的库或框架，比如MFC，它有很多自己的文件处理类。 这些库一般都很难跨平台使用。更糟的是，上述提到的 C 库由于其程序接口的原因，在很大程度上强制程序员进行某些处理，而且缺乏类型安全支持。 标准C++ 提供提供了一个增强的、面向对象的、具有国际化意识的 库。这个库包含一系列派生于标准ios_bas e 和ios 类的类模板。因此， 提供了高级的自动控制机制和健壮性。本文下面将示范如何使用 类实现文件的输入/输出处理： 第一步：创建文件流 输入文件流（ifstream）支持重载的>> 操作符，同样，输出文件流（ofstream）支持重载的<< 操作符。结合了输入和输出的文件流被称为fstream。下面的程序创建了一个ifstream 对象：d ict，并将该对象中的每一个单字显示到屏幕上： #inc lude #inc lude #inc lude #inc lude using namespace std; int main() { string s; cout<<"enter dict ionary file: "; cin>>s;

fstreamifstreamofstream 详解与用法

fstream,istream,ofstream 三个类之间的继承关系 fstream ：(fstream继承自istream和ofstream) 1.typedef basic_fstream > fstream;// 可以看出fstream就是basic_fstream 2.template class basic_fstream: public basic_iostream<_Elem, _Traits> 3.templateclass basic_iostream: public basic_istream<_Elem, _Traits>,public basic_ostream<_Elem, _Traits> istream： 1.typedef basic_ifstream > ifstream;// basic_ifstream就是istream 2.templateclass basic_ifstream : public basic_istream<_Elem, _Traits> // basic_istream 其实就是istream 3.templateclass basic_istream : virtual public basic_ios<_Elem, _Traits> 4.templateclass basic_ios : public ios_base 5.class _CRTIMP2_PURE ios_base : public _Iosb// 最终父类ofstream： 1.typedef basic_ofstream > ofstream; 2.templateclass basic_ofstream : public basic_ostream<_Elem, _Traits> // basic_ostream 其实就是ostream 3.templateclass basic_ostream: virtual public basic_ios<_Elem, _Traits> 4.templateclass basic_ios : public ios_base 5.class _CRTIMP2_PURE ios_base : public _Iosb// 最终父类 这里顺道也把STL中其他几个iostreams 提一句 iostream： 1.typedef basic_iostream > iostream; 2.templateclass basic_iostream: public basic_istream<_Elem, _Traits>,public basic_ostream<_Elem, _Traits> 3.basic_ostream/basic_istream 都继承自basic_ios 4.templateclass basic_ios : public ios_base 5.class _CRTIMP2_PURE ios_base : public _Iosb// 最终父类

C++ fstream的使用方法

c++ fstream 使用(一) 2009-07-14 10:37 （1）基本使用1、包含的头文件 #include using namespace std; 1)C++中的三个文件流 ofstream ofs("文件名", 打开方式); ifstream ifs("文件名", 打开方式); fstream fs("文件名",输入打开方式| 输出打开方式); 三种文件流分别用于写文件、读文件、读写文件 三种文件流都可先定义，再打开文件，以fstream为例 fstream fs; fs.open("文件名", 输入打开方式| 输出打开方式); 其中“打开方式”可以不给出。 若不给出，对于oftream默认为ios::out，iftream默认为ios::in 2)打开方式 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：文件结尾 这两个函数一般用于二进制文件，因为文本文件会因为系统对字符的解释而可能与预想的值不同。 例： file1.seekg(1234,ios::cur);//把文件的读指针从当前位置向后移1234个字 节 file2.seekp(1234,ios::beg);//把文件的写指针从文件开头向后移1234个字 节 file1.seekg(-128,ios::end); //把文件的读指针从文件末尾向前移128个字节(注意偏移量用负数。靠，这么特殊的情况，网上一群傻逼都不写。) c++ fstream 使用(二) 2008-10-01 23:53 (2)使用getline和ifstream读取文件 假设有一个叫data.txt的文件, 它包含以下内容: Fry: One Jillion dollars. [Everyone gasps.] Auctioneer: Sir, that's not a num ber. 数据读取，测试。 以下就是基于data.txt 的数据读取操作: #include #include

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就是以只读和隐含属性打开文件。 例如：以二进制输入方式打开文件c:\config.sys