原文出自【比特网】，转载请保留原文链接：http://soft.chinabyte.com/database/460/.sh
& & &ofstream是从内存到硬盘，ifstream是从硬盘到内存，其实所谓的流缓冲就是内存空间
& & 在C++中，有一个stream这个类，所有的I/O都以这个&流&类为基础的，包括我们要认识的文件I/O.
& & stream这个类有两个重要的运算符：　　1、插入器(&&)　　向流输出数据。比如说系统有一个默认的标准输出流(cout)，一般情况下就是指的显示器，所以，cout&&"Write Stdout"&&'\n';就表示把字符串"Write Stdout"和换行字符('\n')输出到标准输出流。　　2、析取器(&&)　　从流中输入数据。比如说系统有一个默认的标准输入流(cin)，一般情况下就是指的键盘，所以，cin&&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"
　　　　file1&&i;//从文件输入一个整数值。　　这种方式还有一种简单的格式化能力，比如可以指定输出为16进制等等，具体的格式有以下一些　　操纵符 功能 输入/输出　　dec 格式化为十进制数值数据 输入和输出　　endl 输出一个换行符并刷新此流 输出　　ends 输出一个空字符 输出　　hex 格式化为十六进制数值数据 输入和输出　　oct 格式化为八进制数值数据 输入和输出　　setpxecision(int p) 设置浮点数的精度位数 输出示例:#include &iostream&&#include &fstream&&&
void main( void ){//利用ofstream类的构造函数创建一个文件输出流对象来打开文件&ofstream fout( "d:\\mytest.txt" ); &if ( ! fout){cout && "文件不能打开" &&}else{// 输出到磁盘文件fout && "Learning C++ is very useful."&&&//关闭文件输出流fout.close(); & & & & &&//利用ifstream类的构造函数创建一个文件输入流对象ifstream fin( "d:\\mytest.txt" ); &&if ( ! fin){cout && "文件不能打开" &&}else{char buffer[80]; && & & & & & // 从磁盘文件输入fin && &// 关闭文件输入流 & & &fin.close(); &cout && buffer &&}}ofstream file1;if (!file1){cout && "文件不能打开" &&}else{& & & &&//open函数只有文件名一个参数，则是以读/写普通文件打开file1.open("d:\\mytest.txt");//相当于file1.open("d:\\mytest.txt",ios::out|ios::in,0);//文本文件的写:用插入器(&&)向文件输出.& & & & file1&&"写入文件操作!"&&& & & & & &&file1.close();}ifstream file2("d:\\mytest.txt");if (!file2){cout && "文件不能打开" &&}&else{char ch1[100];//文本文件的读:用析取器(&&)从文件输入.file2&&ch1;cout&&ch1&&file2.close();}}　　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++中输出和输入导屏幕和键盘的类别声明包含再标题文件&iostrream.h&中，而磁盘类文件的 I/O则声明再包含标题文件&fstream.h&内。
输入和输出格式：
输出到磁盘 ofsteam 识别字（&文件名&）
从磁盘读文件 ifsteam 识别字（"文件名&）
ofstream outfile("data.txt"); //写入到磁盘的data.txt中
格式化输入输出：
1 整数数据的输入输出
整数数据存储再磁盘内，每个文字各占一个字节。
#include &fstream.h&
#include &iostream.h&
#inlude &conio.h&
void main()
ofstream outfile("data.txt"); //写入文件
for(int i=0;i&10;i++)
outfile&&i&&" "; //空格是为了避免数值连接在一起加上去的，此文件大小为20字节
cout&&"ok,press a key!";
程序执行后用记事本打开可以看到数据
0 1 2 3 4 5 6 7 8 9
同样读取文件语句为：
ifstream infile("data.txt");
for(int i=0;i&10;i++)
infile&& //读数据的时候因为数据间有一个空格才能完整的读出，
cout&&data&&" "; //输出到屏幕，加上空格是为了分开数字
2 字符数据的输入
字符的输出方式以put(ch)为存入语句，读取语句为get(ch)
char str[]="hello this is a c++ programe!\n"
"i know this difference \n"
"and mocive";
ofstream outfile ("data.txt");
for(int i=0;i&strlen(Str);i++)
outfile.put(str[i]);
ifstream infile("data.txt");
while(infile)
infile.get(ch);
3 字符串数据的输入
数据多的时候读写速度比较快，输入时以整行字符串加上换行符号一次写入。读取的时候以语句getline(buffer,max)，来读取整行数据，直到遇到换行符，每行结尾的\n并不读入，所以在 输出的时候需要加上换行符号，否则数据会连接在一起。
ofstream outfile("strdata.txt");
outfile&&"use your vote\n"；
outfile&&"ouse your weise\n";
const MAX=80;
char buffer[MAX];
ifstream infile("strdata.txt");
while(infile)
infile.getline(buffer,MAX);
cout&&buffer&&
浮点数因为有小数点，在存储数据时与整数相同，只要每个数据加上一个空格就可以区隔相邻的数据
6 二进制文件
上述的格式化文件比较占用硬盘控件，采用二进制存储就可以节约很多控件。它使用write,read()来存储和读取。
ofstream 识别字（&文件名&，ios::binary);
write( 写入地址，写入大小）
ifstream 识别字（&文件名&，ios:binary);
识别字.read(读取地址，读取大小）；
例如：infile.read((char*)buffer,sizeof(数据类型));
识别字.close();
ofstream outfile("data.dat",ios::binary);
for(int i=0;i&100;i++)
outfile.write((Char*)n,sizeof(int)); //还可以用变量和数组为例
// outfile.write((Char*)&i,sizeof(int)); i 为变量
// outfile.write((Char*)n,sizeof(int)); n为数组
outfile.close();
ifstream inifile("data.dat",ios:binary);
for(i=0;i&100;i++)
{ inifile.read((Char*)n,sizeof(int);
cout&&n[0]&&" ";
7 随机存取文件
文件能够随意读出，读出后又可以更新，更新后可以回存到源文件内。
file.open("文件名",存取模式）；
file.open("x.dat",ios::app|ios::in|ios::out|ios::binary);
in 打开文件输入或者读取 ifstream
out 打开文件输出或者写入 ofstream
ate 从文件尾开始写入或者读取
app 加在文件尾
arunc 若文件存在，讲其长度设为0
binary 打开二进制文件
二进制文件中有一个指针，指向当前数据在文件中的位置，这个文件指针和一般的指针变量不一样，它只是一个纯粹的指示器。
seekg(0) 指针移到文件的最前面
seekg(0,ios::cur);把当前的指针当作0
seekg(0,ios::end);将指针移到文件尾，若再配合file.tellg()则可以求出文件的大小为多少bytes
以下两个操作都必须在文件关闭后才可以使用
remove("文件名&）；把这个文件删除
rename("旧文件名","新文件名");
#include &iostream&#include &fstream&int main(){ int n[5] = {1, 2, 3, 4, 5}; ofstream out("test", ios::out | ios::binary); if(!out) { cout && "Cannot open file.\n"; return 1; } out.write((char *) &n, sizeof n); out.close(); for(i = 0; i &5; i++) // clear array n[i] = 0; ifstream in("test", ios::in | ios::binary); if(!in) { cout && "Cannot open file.\n"; return 1; } in.read((char *) &n, sizeof n); for(i = 0; i &5; i++) // show values read from file cout && n[i] && " "; in.close(); return 0;}
阅读(...) 评论()C++ getline函数用法 - 萧飞IDO - 博客园
getline()函数是一个比较常见的函数。根据名字直接望文生义，就知道这个函数是来完成读入一行数据。
下面就对C++ -- getline()函数的用法说明，以及getline()函数作为while条件的问题，总结一下：
在C++中本质上有两种getline函数：
第一种：在头文件&istream&中，是iostream类的成员函数。
第二种：在头文件&string&中，是普通函数。
///////////////////////////////////////////////////////////////////////////////////////////
第一种：&在&istream&中的getline()函数有两种重载形式：
istream& getline (char* s, streamsize n );istream& getline (char* s, streamsize n, char delim );
作用是：&从istream中读取至多n个字符(包含结束标记符)保存在s对应的数组中。即使还没读够n个字符，
如果遇到delim&或 字数达到限制，则读取终止，delim都不会被保存进s对应的数组中。
*例程代码：
#include&"stdafx.h"
#include&&iostream&
//使用标准输入流和标准输出流。
//&std:: &std:: &std::endl
int&main()
char&name[256], wolds[256];
std::cout&&&&"Please input your name: ";
std::cin.getline(name, 256);
std::cout&&&&"Please input your wolds: ";
std::cin.getline(wolds, 256);
std::cout&&&&"The result is: &&"&&&&name&&&&", "&&&&wolds&&&&std::
std::cout&&&&std::
//**输入：
You are wonderful !
Mr. Ling, You are wonderful !
*通过字数限制和设置终止符修改的代码：
int&main()
char&name[6];
std::cout&&&&"Please input your name: ";
std::cin.getline(name, 6,&'#');
std::cout&&&&"The result is: &&"&&&&name&&&&std::
std::cout&&&&std::
//**输入：&//streamsize限定，截断输出
//**输入：&//所设置的结束标识符，截断输出
won#derful
第二种：&在&string&中的getline函数有四种重载形式：
istream& getline (istream& &is, string& str, char delim);istream& getline (istream&& is, string& str, char delim);istream& getline (istream& &is, string& str);
istream& getline (istream&& is, string& str);用法和上第一种类似，但是读取的istream是作为参数is传进函数的。读取的字符串保存在string类型的str中。
函数的变量：
is &&&：表示一个输入流，例如&cin。
str &&：string类型的引用，用来存储输入流中的流信息。
delim&：char类型的变量，所设置的截断字符；在不自定义设置的情况下，遇到’\n’，则终止输入。
*例程代码：
#include&"stdafx.h"
#include&&iostream&
#include&&string&
int&main()
std::string&
std::cout&&&&"Please input your name: ";
std::getline(std::cin, name);
std::cout&&&&"Welcome to here!"&&&&std::ends&&&&name&&&&std::
std::cout&&&&std::
在输入时，直至遇到‘\n’或EOF， 才终止输入操作。
//**输入：
*例程代码：
std::string&
std::cout&&&&"Please input your name: ";
std::getline(std::cin, name,&'#');
std::cout&&&&"Welcome to here!"&&&&std::ends&&&&name&&&&std::
std::cout&&&&std::
//**输入：
wonderful#Mr.Ling
///////////////////////////////////////////////////////////////////////////////////////////
(EOF是C语言中为了区分有效数据和输入结束符的。
EOF的输入由系统锁定。windows下是ctrl+z,linux/unix下是ctrl+d。)
getline不是C库函数，而是C++库函数。它遇到以下情况发生会导致生成的本字符串结束：
(1)到文件结束，(2)遇到函数的定界符，(3)输入达到最大限度。
getline()函数在while中作为条件判断。
#include&"stdafx.h"
#include&&iostream&
#include&&string&
using&namespace&
int&main()
while&(getline(cin, line))
cout&&&&line&&&&
大家会发现运行时一般的输入都不能够跳出循环，可能有时还会出现莫名的错误。但是这到底是什么原因造成的呢！下面就来分析一下：
getline()函数的原型是istream& getline ( istream & is , string & str , char delim );
int&main()
cout&&&&"Please input a line: "&&&&
while&(getline(cin, line,'#'))
cout&&&&line&&&&
然后，那么当我们输入&"You are wonderful!#Mr. Ling"&时，但是，有效的输入是&"You are wonderful！"，#后面的内容并没有存入。程序运行的结果如：
You are wondreful!#LingKing
You are wonderful!
在这里设置‘#’为终止符时，当再输入’\n’时也不会影响。在#之前的内容都会照样输出。例如：
//输入：&//含有’\n’的输入
Hello world!
You are wonderful!
Mr. Ling#wonderful!
//输出：&//照样输出
Hello world!
You are wonderful!
通过getline()函数一个小小的实例，那么把getline()函数作为while的判断语句会怎么样的呢！
就分析一下while(getline(cin,line))
（注意：这里默认回车符停止读入,按Ctrl+Z(Windows)(Ctrl+D(Linux))或键入EOF(参考MSDN)回车即可退出循环。）
这个语句中，while判断语句的真实判断对象是cin的状态，也就是判断当前是否存在有效的输入流。
而输入流是对象，判断的是流返回的状态。所以正常的情况下，你怎么输入都是跳不出它的循环。
在这之中可能会用些同志误以为while判断语句的判断对象是line（也就是line是否为空），想通过回车来跳出循环，却发现不能跳出循环。
而回车和设置的终止符都是终止getline()函数的读取操作的。但是while判断语句判断的是getline()函数的输入流是否有效。所以呢！
随笔 - 149C++里面的getline函数
函数原型：
istream& getline(istream& in, string& line);
从给定输入流中读取一行，并将读到的字符流写到line中，
也就是说直到遇到换行符之前，都会读取字符并保存到Line
中，最后的换行符也读进去了，只是并没有保存到line中。
看下面代码：
int main()
int i = 0;
while(i & n) {
getline(cin, line);
cout && line &&
如果我们在输入n的时候，输入完毕并按下回车，那么第一个字符串就是就会输入进去了，并且为空。
如果在输入n的时候必须换行，那么对于n也调用getline，之后再处理。
没有更多推荐了，一个有用的string IO操作：getline。这个函数接受两个参数：一个输入流对象和一个string对象。getline函数从输入流的下一行读取，并保存读取的内容到 string中，但不包括换行符。和输入操作符不一样的是，getline并不忽略行开头的换行符。只要getline遇到换行符，即便它是输入的第一个 字符，getline也将停止读入并返回。如果第一个字符就是换行符，则string参数将被置为空string。
getline函数将istream参数作为返回值，和输入操作符一样也把它用作判断条件。例如：
int main(){// read line at time until end-of-filewhile (getline(cin, line))cout && line &&return 0;}
由于line不含换行符，若要逐行输出需要自行添加。照常，用endl来输出一个换行符来刷新输出缓冲区。
注解：由于getline函数返回时丢弃换行符，换行符将不会存储在string对象中。
摘自《c++ Primer》
int get();从输入流中读取一个字符，转化成int返回istream& istream::get ( char& c ); 从输入流中读取一个字符，保存到c中istream&
istream::get ( char* s, streamsize n );从输入流中读取n-1个字符或者碰到结束符'/n'或者文件最后，但是'/n'不会从输入流中提取出来，最为下次读取的开始字符。在s最后加上一个'/0'
istream::get ( char* s, streamsize n, char delim );从输入流中读取n-1个字符或者碰到结束符delim 或者文件最后，但是delim 不会从输入流中提取出来，最为下次读取的开始字符.在s最后加上一个'/0'
istream::getline (char* s, streamsize n );istream&
istream::getline (char* s, streamsize n, char delim );与istream&
istream::get ( char* s, streamsize n );
istream::get ( char* s, streamsize n, char delim );的区别是 结束符会从输入流中提取出来，但是不会存到s中。
istream& getline ( istream& is, string& str, char delim );istream& getline ( istream& is, string& str );
函数的作用与
istream::getline (char* s, streamsize n );istream&
istream::getline (char* s, streamsize n, char delim );一样
istream& read ( char* s, streamsize n );
从输入流读取n个字符，或者碰到文件结束符 但是不在s最后加上'/0',所以不是cstring字符串
ostream& write ( char* s, streamsize n );
从输出流写入n个字符，s不需要是cstring字符串 即'/0'结束的字符串
C++ stringstream 的用法以及getline的用法
string::getline()和istream::getline()的区别
C++使用getline读取string
string类中getline函数的应用
std::getline (string) & std::stringstream::str
Cpp中使用getline读取一整行字符串
string模板类下的getline()函数
C++ getline的使用
c++ string getline()函数
C++语法基础--istream，流状态及其影响，get(),getline(),ignore()
没有更多推荐了，1 #include &iostream&
2 #include &cstdio&
4 using namespace
6 int main(){
s = new char[50]; //必须要分配空间
cin.getline(s,5);
int i = 0;
while(s[i] != '\0'){
cout&&s[i];
cout&&endl&&i&&
cin.clear(); //当failbit位为1时需要clear，否则后面的getline读取为空字符串
getline(cin,str);
cout&&str&&
getline(cin,str,'#');
cout&&str&&
getline(cin,str);
cout&&str&&
输入输出：
(input)hel#id
C++中有两个getline函数，一个是在string头文件中，定义的是一个全局的函数，函数声明是istream& getline ( istream& is, string& str, char delim )与istream& getline ( istream& is, string& str );
另一个则是istream的成员函数，函数声明是istream& getline (char* s, streamsize n )与istream& getline (char* s, streamsize n, char delim );注意第二个getline是将读取的字符串存储在char数组中而不可以将该参数声明为string类型，因为C++编译器无法执行此默认转换。
getline函数大致流程：
1、首先判断istream的failbit位是否为1，为1的话意味着输入流的状态有错误，则不进行读操作，getline函数结束执行2、从当前位置开始从输入流中依次读取单个字符并拷贝到缓冲区，直到遇到下列条件满足时，循环结束。(1)遇到文件尾时停止读操作，并设置流对象的结束标记为1(2)读到调用者指定的分隔符时，此时将分隔符之前的字符拷贝到缓冲区中，但分隔符本身不拷贝进去，并且下次读操作将从分隔符后的下一个字符开始。(3)已经读了n-1个字符(n是调用者传入的第二个实参_Count的初值)，此时要把流对象的错误标志位置1
利用getline连续读取直至文末
1 #include &iostream&
2 #include &cstdio&
4 using namespace
6 int main(){
while(getline(cin,s)){
cout&&s&&;
阅读(...) 评论()}