C++文件读写详解(ofstream,ifstream,fstream)及C++ string类
《C++程序设计》学习笔记总结 - 第八章 文件操作

第八章文件操作一、文件基本概念和文件流类文件基本概念和文件流类从不同的角度来看待文件就可以得到不同的文件分类。
C++根据文件数据的编码方式不同分为文本文件和二进制文件。
根据存取方式不同分为顺序存取文件和随机存取文件所谓“文本文件”和“二进制文件”是从文件格式的角度进行分类,是约定俗成的、从计算机用户角度出发进行的分类。
所谓的“顺序存取文件”和“随机存取文件”是根据访问文件中数据的方式来划分的。
顺序存取文件就是按照文件中数据存储次序进行顺序操作,为访问第i 个数据,就首先要访问第i-1个数据,在整个文件操作过程中,将移动位置指针的工作交给系统自动完成。
磁带文件就是一个典型的顺序存取文件。
随机访问文件是根据应用的需要,通过命令移动位置指针直接定位到文件内需要的位置并进行数据操作。
对文件的基本操作分为读文件和写文件。
所谓“读文件”就是将文件中的数据读入内存之中,也称为“输入”。
所谓“写文件”就是将内存中的数据存入文件之中,也称为“输出”。
C++标准类库中有3个流类可以用于文件操作,这3个类统称为文件流类,分别如下:1)ifstream:用于从文件中读取数据。
2)ofstream:用于向文件中写入数据。
3)fstream:既可用于从文件中读取数据,又可用于向文件中写入数据。
使用这3个流类时,程序中需要包含fstream头文件。
类ifstream和类fstream都是从类istream派生而来的,因此类ifstream拥有类istream的全部成员函数。
同样,类ofstream和类fstream也拥有类ostream的全部成员函数。
这3个类中有一些十分熟悉的成员函数可以使用,如operator<<、operator>>、peek( )、ignore( )、getline( )、get( )等。
在程序中,要使用一个文件,必须包含3个基本步骤:打开(open)文件——操作文件——关闭(close)文件。
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 函数,并拥有同样的参数。
CC++关于文件的读写操作以及文件的打开和保存

CC++关于⽂件的读写操作以及⽂件的打开和保存通过近来的学习,总结⼀下关于⽂件的读写操作以及⽂件的打开和保存的⽅法。
⼀、⽂件的读写操作:(1)C语⾔对⽂件的读写操作在C语⾔中,对⽂件的读写操作是⽤FILE结构体和常⽤的对⽂件操作的函数实现的,下⾯总结⼀下C语⾔中对⽂件操作的常⽤函数:fopen() 打开以⽂件名指定的⽂件fwrite() 写⽂件fread() 读⽂件fseek() 移动⽂件的指针到新的位置通过该函数的参数设定的偏移量和初始位置rewind() 移动⽂件的指针到⽂件流的开始位置,在通常情况下可⽤fseek()实现相同的功能,但⼆者有区别ftell() 获得当前⽂件指针的位置,常⽤该函数获得⽂件的⽂件流的长度fflush() 刷新缓冲区中的内容,当⽂件写⼊时直接将⽂件流的内容从缓冲区写⼊磁盘,当读取⽂件时直接将磁盘⽂件写⼊缓冲区,⽽不必等程序运⾏结束或关闭程序。
fclose() 关闭⽂件memset() 在⼀段内存块中填充某个给定的值⽰例代码如下:/*********************************************************** C语⾔实现⽂件写操作 ************************************************************/FILE *pFile=fopen("CLanguage.txt","w");fwrite("CLanguage",1,strlen("CLanguage"),pFile);//fseek(pFile,0,SEEK_SET);//fwrite("实现⽂件写操作",1,strlen("实现⽂件写操作"),pFile);fclose(pFile);/*********************************************************** C语⾔实现⽂件读操作 ************************************************************/FILE *pFile=fopen("CLanguage.txt","r");//char ch[100];//memset(ch,0,100);//fread(ch,1,100,pFile);//MessageBox(ch);char* pBuf;int length;fseek(pFile,0,SEEK_END);length=ftell(pFile);pBuf=new char[length+1];//fseek(pFile,0,SEEK_SET);rewind(pFile);fread(pBuf,1,length,pFile);pBuf[length]=0;MessageBox(pBuf);fclose(pFile);注意:在⽤C语⾔实现⽂件的读操作时,要注意⽂件的指针位置。
C++ofstream和ifstream详细用法

C++ofstream和ifstream详细⽤法⽬录⼀、stream类的两个重要的运算符1、插⼊器(<<)2、析取器(>>)⼆、常见的⽂件操作1、打开⽂件2、关闭⽂件3、读写⽂件三、检测EOF四、⽂件定位五、输⼊和输出格式1、整数数据的输⼊输出2、字符数据的输⼊3、字符串数据的输⼊4、浮点数六、⼆进制⽂件七、随机存取⽂件在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。
⼆、常见的⽂件操作1、打开⽂件在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:以⼆进制⽅式打开⽂件,缺省的⽅式是⽂本⽅式。
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++。
ifstream ofstream读写原理

ifstream ofstream读写原理引言概述:ifstream和ofstream是C++中用于读取和写入文件的输入输出流类。
它们提供了一种便捷的方式来读取和写入文件,使得操作文件变得简单和高效。
本文将介绍ifstream和ofstream的读写原理,并详细阐述其六个大部分。
正文内容:1. 输入输出流类的概述1.1 输入输出流类的定义和作用1.2 文件的读写操作过程2. ifstream类的读取原理2.1 打开文件并关联流2.2 判断文件是否成功打开2.3 读取文件内容3. ifstream类的常用读取方法3.1 逐行读取文件3.2 读取特定数据类型3.3 移动文件指针4. ofstream类的写入原理4.1 打开文件并关联流4.2 判断文件是否成功打开4.3 写入文件内容5. ofstream类的常用写入方法5.1 写入字符串5.2 写入特定数据类型5.3 移动文件指针6. ifstream和ofstream类的关闭操作6.1 关闭文件流6.2 检查文件流是否关闭6.3 避免资源泄露总结:1. ifstream和ofstream是C++中用于读取和写入文件的输入输出流类。
2. 通过打开文件并关联流,可以进行文件的读取和写入操作。
3. ifstream类适用于读取文件,常用方法包括逐行读取和读取特定数据类型。
4. ofstream类适用于写入文件,常用方法包括写入字符串和写入特定数据类型。
5. 在使用完ifstream和ofstream类后,应及时关闭文件流,以避免资源泄露和文件损坏。
C++文件读写详解(ofstream,ifstream,fstream)

C++⽂件读写详解(ofstream,ifstream,fstream)相关的头⽂件:#include <fstream>需要相关的类fstream提供三种类,实现C++对⽂件的操作ofstream:写操作,由ostream引申⽽来ifstream:读操作,由istream引申⽽来fstream :同时读写操作,由iostream引申⽽来⽂件的类型:⽂本⽂件和⼆进制⽂件⽂件读写的步骤:1、包含的头⽂件:#include <fstream>2、创建流3、打开⽂件(⽂件和流关联)4、读写 (写操作:<<,put( ), write( ) 读操作: >> , get( ),getline( ), read( ))5、关闭⽂件:把缓冲区数据完整地写⼊⽂件,添加⽂件结束标志,切断流对象和外部⽂件的连接⽂件的读写:1、⽂本⽂件的读写:⽅法:⼀次性读写若⼲字符1)使⽤运算符<< 和 >>进⾏读写功能:<< 能实现以⾏为单位写⼊⽂件>> 不能⼀⾏为单位读⼊内存,总是以空格、Tab、回车结束,⽽是以单词为单位代码:函数功能:使⽤<< ,写⼊⽂件⼀⾏字符#include <fstream>#include <iostream>using namespace std;void main(){ ofstream OpenFile("file.txt"); if (OpenFile.fail()) { cout<<"打开⽂件错误!"<<endl; exit(0); } OpenFile<<"abc def ghi"; OpenFile.close(); system("pause");}运⾏结果:⽂件中写⼊内容:abc def ghi函数功能:使⽤>>,从⽂件读⼊⼀个单词#include <fstream>#include <iostream>using namespace std;void main(){ const int len=20; char str[len];ifstream OpenFile("file.txt"); if (OpenFile.fail()){cout<<"打开⽂件错误!"<<endl;exit(0);}OpenFile>>str;cout<<str<<endl;OpenFile.close();system("pause");}运⾏结果:str的内容为abc,⽽不是abc def ghi(见空格停⽌)2)使⽤运算符<<(写)和getline()进⾏读写功能:<<:以⾏为单位输⼊⽂件getline():以⾏为单位读⼊内存,能⼀次读⼊⼀⾏函数原型:istream &getline( char *buffer, streamsize num );功能:getline( )函数⽤于从⽂件读取num-1个字符到buffer(内存)中,直到下列情况发⽣时,读取结束:1):num - 1个字符已经读⼊2):碰到⼀个换⾏标志3):碰到⼀个EOF代码:#include <fstream>#include <iostream>using namespace std;void main(){ const int len=20; char str[len];ifstream OpenFile("file.txt"); if (OpenFile.fail()){cout<<"打开⽂件错误!"<<endl;exit(0);}OpenFile.getline(str,20);cout<<str<<endl;OpenFile.close();system("pause");}运⾏结果:str的内容为abc def ghi (⼀直把⼀⾏读完)⼀次读写⼀个字符:使⽤get( )和put( )函数函数声明:istream& get(char &c);函数功能:使⽤ get( )函数把字符1输⼊到⽂件#include <fstream>#include <iostream>using namespace std;void main(){ char ch='1';ofstream OpenFile("file.txt"); if (OpenFile.fail()){cout<<"打开⽂件错误!"<<endl;exit(0);}OpenFile.put(ch);OpenFile.close();system("pause");}运⾏结果:把字符1写⼊⽂件函数功能:使⽤ put( )函数把⽂件中第⼀个字符输⼊内存#include <fstream>#include <iostream>using namespace std;void main(){ char ch;ifstream OpenFile("file.txt"); if (OpenFile.fail()){cout<<"打开⽂件错误!"<<endl;exit(0);}OpenFile.get(ch);cout<<ch;OpenFile.close();system("pause");}运⾏结果:把字符1从⽂件中读到ch(内存)中2、⼆进制⽂件的读写:1)使⽤运算符get( ) 和 put( )读写⼀个字节功能:get( ) :在⽂件中读取⼀个字节到内存函数原型:ifstream &get(char ch)put( ) :在内存中写⼊⼀个字节到⽂件函数原型:ofstream &put(char ch)代码:功能:把26个字符写⼊⽂件中#include <fstream>#include <iostream>using namespace std;void main(){ char ch='a';ofstream OpenFile("file.txt",ios::binary); if (OpenFile.fail()){cout<<"打开⽂件错误!"<<endl;exit(0);} for (int i=0;i<26;i++){OpenFile.put(ch);ch++;}OpenFile.close();system("pause");}运⾏结果:⽂件内容为abcdefghijklmnopqlst...z 功能:把⽂件中的26个字母读⼊内存#include <fstream>#include <iostream>using namespace std;void main(){ char ch;ifstream OpenFile("file.txt",ios::binary); if (OpenFile.fail()){cout<<"打开⽂件错误!"<<endl;exit(0);} while (OpenFile.get(ch))cout<<ch;OpenFile.close();system("pause");}运⾏结果:ch依次为abc...z2)使⽤read()和write()进⾏读写 read( ):功能:从⽂件中提取 n 个字节数据,写⼊buf指向的地⽅中函数声明:istream & read ( char * buf , int n ) ;代码:函数功能:使⽤write( )函数,⼀次从内存向⽂件写⼊⼀⾏数据#include <fstream>#include <iostream>using namespace std;void main(){ char ch[12]="12 3 456 78";ofstream OpenFile("file.txt"); if (OpenFile.fail()){cout<<"打开⽂件错误!"<<endl;exit(0);}OpenFile.write(ch,12);OpenFile.close();system("pause");}运⾏结果:⽂件内容12 3 456 78write( ):功能:把buf指向的内容取n个字节写⼊⽂件函数声明:ostream & ostream :: write ( char * buf , int n ) ;参数说明:buf表⽰要写⼊内存的地址,传参时要取地址。
如何在C++中进行文件读写操作

如何在C++中进行文件读写操作在C++中进行文件读写操作是实现文件输入和输出的一种重要方式,通过文件读写操作可以将数据保存到文件中或者从文件中读取数据。
下面将详细介绍在C++中进行文件读写操作的基本方法和常用函数。
文件的读写操作主要围绕以下几个步骤展开:1.打开文件:进行文件读写操作之前,首先要打开文件。
C++提供了fstream库,可以通过它的对象来打开文件。
其中,fstream类是一个文件流类,可以用于读写文件。
在打开文件时,需要指定文件名以及打开模式(如只读、只写、读写等)。
打开模式有以下几种常用的类型:- ios::in:打开文件用于读取。
- ios::out:打开文件用于写入。
- ios::app:在文件末尾追加写入内容。
- ios::trunc:如果文件存在,删除文件内容。
- ios::ate:打开文件并将文件指针移至文件末尾。
可以使用filestream类的open()函数打开文件,示例代码如下:```cpp#include <iostream>#include <fstream>using namespace std;int main() {ofstream fout;fout.open("example.txt", ios::out);if (!fout) {cout << "文件打开失败!" << endl;return 1;}//文件打开成功,进行读写操作// ...fout.close(); //关闭文件return 0;}```上述代码中,打开example.txt文件,如果文件存在则打开,如果不存在则创建新的文件。
打开方式为输出模式。
2.文件读操作:打开文件成功后,可以使用文件流对象的<<运算符从文件中读取数据。
语法如下:```cppifstream fin;fin.open("example.txt", ios::in);if (!fin) {cout << "文件打开失败!" << endl;return 1;}int data;fin >> data; //读取文件中的数据// ...fin.close(); //关闭文件```上述代码中,读取example.txt文件中的整数数据。
c++读取整个文件内容的最简洁高效写法

题目:C++读取整个文件内容的最简洁高效写法在C++编程中,读取整个文件的内容是一个常见的需求。
有时候我们需要对文件进行处理或者分析,而需要先将文件内容读取到内存中。
在这篇文章中,我们将探讨C++中读取整个文件内容的最简洁高效写法,帮助大家更好地理解和应用这一技巧。
1. 使用STL库中的ifstream和string在C++中,我们可以使用STL(标准模板库)中的ifstream和string来实现快速读取文件内容的操作。
下面是一个简单的示例代码:```cpp#include <iostream>#include <fstream>#include <string>std::string readEntireFile(const std::string& filename) {std::ifstream file(filename);if (file) {return std::string((std::istreambuf_iterator<char>(file)), (std::istreambuf_iterator<char>()));}return "";}int main() {std::string content = readEntireFile("example.txt");std::cout << content << std::endl;return 0;}```在这段代码中,我们首先包含了iostream、fstream和string这三个头文件。
然后定义了一个读取整个文件内容的函数readEntireFile,以及在main函数中调用该函数并输出文件内容的示例。
这段代码的关键点是使用了std::ifstream来打开文件,然后利用std::istreambuf_iterator<char>构造了一个string对象,从而将文件内容读取到了内存中。
C++文件读写详解(ofstream,ifstream,fstream)

在看C++编程思想中,每个练习基本都是使用ofstream,ifstream,fstream ,以前粗略知道其用法和含义,在看了几位大牛的博文后,进行整理和总结:这里主要是讨论fstream 的内容:[java] view plain copy print ?01. #i n c l u d e <f s t r e a m >02. o f s t r e a m //文件写操作 内存写入存储设备03. i f s t r e a m //文件读操作,存储设备读区到内存中04. f s t r e a m //读写操作,对打开的文件可进行读写操作1.打开文件在fstream 类中,成员函数open ()实现打开文件的操作,从而将数据流和文件进行关联,通过ofstream,ifstream,fstream 对象进行对文件的读写操作函数:open ()[cpp] view plain copy print ?01. <s p a n s t y l e ="f o n t f a m i l y :T i m e s N e w R o m a n ;f o n t s i z e :16p x ;">02. p u b l i c m e m b e r f u n c t i o n03.04. v o i d o p e n ( c o n s t c h a r * f i l e n a m e ,05. i o s _b a s e ::o p e n m o d e m o d e = i o s _b a s e ::i n | i o s _b a s e ::o u t );06.07. v o i d o p e n (c o n s t w c h a r _t *_F i l e n a m e ,08. i o s _b a s e ::o p e n m o d e m o d e = i o s _b a s e ::i n | i o s _b a s e ::o u t ,09. i n t p r o t = i o s _b a s e ::_O p e n p r o t );10.11. </s p a n > 参数: filename 操作文件名mode 打开文件的方式prot 打开文件的属性 //基本很少用到,在查看资料时,发现有两种方式打开文件的方式在ios 类(所以流式I/O 的基类)中定义,有如下几种方式:ios::in 为输入(读)而打开文件无法加载插件。
c++中文件操作的基本步骤

在C++中,文件操作的基本步骤通常包括以下步骤:1. 包含头文件:在C++程序中,需要包含头文件`<fstream>`来使用文件操作相关的函数和类。
```cpp#include <fstream>```2. 创建文件流对象:使用`ifstream`、`ofstream`或`fstream`类来创建文件流对象。
这些类分别用于读取文件、写入文件和读写文件。
```cppstd::ifstream inputFile; // 用于读取文件的文件流对象std::ofstream outputFile; // 用于写入文件的文件流对象std::fstream generalFile; // 用于读写文件的文件流对象```3. 打开文件:使用文件流对象的`open()`函数来打开一个文件。
需要提供文件名和打开模式(只读、只写、读写等)。
```cppinputFile.open("example.txt", std::ios::in); // 以只读模式打开文件outputFile.open("example.txt", std::ios::out); // 以只写模式打开文件generalFile.open("example.txt", std::ios::in | std::ios::out); // 以读写模式打开文件```4. 读写文件:使用文件流对象的输入/输出运算符(`>>`、`<<`)或其他函数来读写文件。
```cppinputFile >> num; // 从文件中读取一个整数outputFile << "Hello"; // 向文件中写入字符串generalFile.seekg(0, std::ios::end); // 将文件指针移动到文件末尾generalFile << "World"; // 向文件中写入字符串```5. 关闭文件:使用文件流对象的`close()`函数来关闭一个文件。
ofstreamifstream文本二进制方式读入写出数据方法

ofstreamifstream⽂本⼆进制⽅式读⼊写出数据⽅法⽂件 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"的操作很像。
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++文件输入输出流

C++文件输入输出流文件操作在操作系统的底层中十分复杂。
然而,C++已经为我们做了文件操作的绝大部分工作。
程序员只要以流的概念来实施文件操作即可。
文件有两种,一种是文本文件,其内容总是与字符码表(如ASCII码)对应。
另一种是二进制文件,可以将内容看成0/1串。
本次课我们只讨论C++中文本文件的读写。
一、文件输入流类ifstreamI ifstream是文件输入流类的类名。
定义一个该类的对象,即可将该对象和一个文件建立联系。
例如,ifstream fin(“a.txt”)表示定义一个文件输入流类的对象fin,并将该对象与当前目录下的a.txt文件建立联系,以后可以用该对象从a.txt中读取数据。
【例1 按行读取一个文本文件的所有内容,并输出到屏幕。
】#include <iostream>#include <fstream> //使用ifstream类需要包含头文件fstream#include <string> //使用string类需要包含头文件stringusing namespace std;int main(){ifstream fin("in.txt"); //默认打开文本文件string str;while (getline(fin, str)){cout<<str<<endl;}return 0;}getline(fin, str)表示从输入文件流中读入一行数据,放入string类型的变量str 中。
由于整行整行地读入,读入到str中时,文件中的每个换行符都被丢掉了。
为了照文件原样输出,在cout流上输出str的同时,还要再补上一个回车符。
许多输入/输出语句都能返回操作状态(true或false),例如if (cin>>a)cout<<a; //若读入失败,则跳过cout<<a;if (getline(in, str)cout<<str; //若读入失败,则跳过cout<<str;if (cin)cin>>a; //若文件流状态正常,则输入所以在循环读入数据时,常常将读入操作放在循环的条件判断上,这样既省事,又明白。
用ifstream 和ofstream 读写中文的总结

用ifstream 和ofstream 读写中文的总结:首先读写中文应为wifstream 和ofstream。
下面的我也不知道为什么?但是可以正常使用、#include<iostream>#include<iomanip>#include<fstream>using namespace std;int main(){setlocale(LC_ALL,"chs");//设置wcout,能正常显示中文wchar_t ch ,str[]={ L"一二三四五六七八"};wofstream outfile("letter.txt");outfile.imbue(std::locale("chs")); //可以正常写入if (!outfile){cout << "不能建立文件!"<<endl;exit(1);}outfile.write(str,wcslen(str));outfile.flush();outfile.close();locale loc("chs");wifstream infile;infile.imbue(loc);//可以正常读出infile.open("letter.txt");if (!infile){cout << "不能打开文件!"<<endl;exit(1);}infile.seekg(0,ios::beg);infile.read(&ch,1);wcout << L"第一个字符是:" << ch <<endl;infile.close();}另外还有一些东西:char ch2;wchar_t ch;cout << sizeof(ch2) <<endl; // 1cout << sizeof(ch)<<endl; //2cout << sizeof(L'中')<<endl; //2cout << sizeof(L"中")<<endl;//4cout << sizeof('中')<<endl; //4最奇怪的一个cout << sizeof("中国人")<<endl; //5cout << wcslen(L"中") <<endl; //1有意思!。
C++,java读写二进制文件方法介绍

今天终于弄明白怎样使用C++读写二进制文件了。
要读取文件必须包含<fstream>头文件,这里包含了C++读写文件的方法。
可以使用fstream类,这个类可以对文件进行读写操作。
1、打开文件。
打开文件可以有两种方式,第一种可以使用fstream类的构造函数。
fstream file("test.dat",ios_base::in|ios_base::out|ios_base::app); 另外一种方法就是使用open函数。
fstream file;file.open("test.dat",ios_base::in|ios_base::out|ios_base::app);这样就可以打开一个可读写的文件了。
如果文件不存在的话,就会创建一个新文件并且以读写方式打开。
这里需要说明一点,如果文件不存在的话,open函数中第二个参数必须包含ios_base::out|ios_base::app,否则就不能正确创建文件。
2、写文件。
先进性写文件的操作否则读一个空文件是没有意义的。
既然是写二进制文件可以向文件中写入一个整形值。
写二进制字符只能使用write函数。
但是write函数的原形是write(const char * ch, int size)。
第一个参数是char *类型,所以需要把将要写入文件的int类型转换成char *类型。
这里的转换困扰了我好几天,不过终于弄明白了。
代码如下。
int temp;file.write((char *)(&temp),sizeof(temp));3、读文件。
可以写文件了,读文件就好办多了。
读文件需要用到read函数。
其参数和write大致相同,read(const char * ch, int size)。
要把内容读到int类型变量中同样涉及到一个类型转换的问题。
和写文件一样。
int readInt;file.read((char *)(&readInt),sizeof(readInt));这样文件中的int值就读入到int型变量readInt中了。
c++ ifstream ofstream copy file

c++ ifstream ofstream copy filec++的ifstream和ofstream是用于文件输入和输出的两个类。
它们可以用来打开文件,读取文件内容或将数据写入文件。
首先,我们需要包含<fstream>头文件来使用这两个类。
```cpp#include <fstream>```要从一个文件中读取内容,我们可以使用ifstream类的对象。
假设我们有一个名为"source.txt"的文本文件,我们可以使用ifstream对象打开它并读取文件内容。
```cpp#include <iostream>#include <fstream>int main() {std::ifstream inputFile("source.txt"); // 打开输入文件if (inputFile) { // 检查文件是否成功打开std::string line;while (std::getline(inputFile, line)) { // 逐行读取文件内容std::cout << line << std::endl; // 输出每一行内容 }inputFile.close(); // 关闭文件} else {std::cerr << "无法打开输入文件!" << std::endl;}return 0;}```上述代码将打开名为"source.txt"的文件,并逐行读取其中的内容并输出到控制台。
如果我们想将文件内容复制到另一个文件中,我们可以使用ofstream类的对象。
假设我们有一个名为"destination.txt"的目标文件,我们可以使用ofstream对象打开它并将数据写入文件。
```cpp#include <iostream>#include <fstream>int main() {std::ifstream inputFile("source.txt"); // 打开输入文件std::ofstream outputFile("destination.txt"); // 打开输出文件if (inputFile && outputFile) { // 检查文件是否成功打开std::string line;while (std::getline(inputFile, line)) { // 逐行读取输入文件内容outputFile << line << std::endl; // 将读取到的数据写入输出文件}inputFile.close(); // 关闭输入文件outputFile.close(); // 关闭输出文件} else {std::cerr << "无法打开输入/输出文件!" << std::endl; }return 0;}```上述代码将打开名为"source.txt"的输入文件和名为"destination.txt"的输出文件,并逐行将输入文件的内容写入输出文件。
如何在C++中实现文件的读取和写入

如何在C++中实现文件的读取和写入在C++中实现文件的读取和写入是非常常见的操作。
文件的读取和写入操作在实际开发中被广泛应用,无论是处理文本文件、配置文件、日志文件或者其他数据存储,都会涉及到文件的读取和写入操作。
在本文中,我们将学习如何在C++中实现文件的读取和写入操作,同时探讨一些常见的技巧和注意事项。
1.文件读取操作在C++中,可以使用fstream类来实现文件的读取操作。
fstream类是C++标准库中用于文件操作的一个重要类,它包含在头文件<fstream>中。
在使用文件读取操作之前,需要先打开文件,然后可以通过流操作符(<<)将文件内容读取到变量中。
下面是一个简单的文件读取示例:```cpp#include <iostream>#include <fstream>using namespace std;int main() {//打开文件ifstream file("example.txt"); //定义一个变量用于存储文件内容string content;//读取文件file >> content;//输出文件内容cout << content << endl;//关闭文件file.close();return 0;}```在上面的示例中,首先我们使用ifstream类打开了一个名为example.txt的文件。
然后使用流操作符(>>)将文件内容读取到一个名为content的变量中,最后输出了文件内容。
除了使用流操作符(>>)来读取文件内容之外,还可以使用getline()方法来逐行读取文件内容。
下面是一个使用getline()方法的示例:```cpp#include <iostream>#include <fstream>using namespace std;int main() {//打开文件ifstream file("example.txt");//定义一个变量用于存储文件内容string line;//逐行读取文件while (getline(file, line)) {//输出每一行文件内容cout << line << endl;}//关闭文件file.close();return 0;}```在上面的示例中,我们首先使用ifstream类打开了一个名为example.txt的文件。
C++基础系列——文件操作

C++基础系列——⽂件操作⼀、C++⽂件类及⽤法C++ 标准库提供了 3 个类⽤于实现⽂件操作,它们统称为⽂件流类,这 3 个类分别为:ifstream:专⽤于从⽂件读取数据ofstream:专⽤于向⽂件写⼊数据fstream:可读可写这三个⽂件流类都位于 fstream 头⽂件中fstream 类拥有 istream、ostream 类的全部成员⽅法。
fstream 头⽂件中并没有定义可直接使⽤的 fstream、ifstream 和 ofstream 类对象fstream 类常⽤成员⽅法成员⽅法名适⽤类对象功能open()fstream打开指定⽂件,使其与⽂件流对象关联is_open()ifstream检查指定⽂件是否已打开。
close()ofstream关闭⽂件,切断和⽂件流对象的关联。
swap()ofstream交换 2 个⽂件流对象。
operator>>(i)fstream重载 >> 运算符,⽤于从指定⽂件中读取数据。
gcount()(i)fstream返回上次从⽂件流提取出的字符个数。
该函数常和 get()、getline()、ignore()、 peek()、read()、readsome()、putback() 和 unget() 联⽤。
get()(i)fstream从⽂件流中读取⼀个字符,同时该字符会从输⼊流中消失。
getline(str,n,ch)(i)fstream从⽂件流中接收 n-1 个字符给 str 变量,当遇到指定 ch 字符时会停⽌读取,默认情况下 ch 为 '\0'。
ignore(n,ch)(i)fstream从⽂件流中逐个提取字符,但提取出的字符被忽略,不被使⽤,直⾄提取出 n 个字符,或者当前读取的字符为 ch。
peek()(i)fstream返回⽂件流中的第⼀个字符,但并不是提取该字符。
putback(c)(i)fstream将字符 c 置⼊⽂件流(缓冲区)。
ofstream ifstream 文件操作

ofstream ifstream 文件操作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!";gerch();}程序执行后用记事本打开可以看到数据0 1 2 3 4 5 6 7 8 9同样读取文件语句为:int data;ifstream infile("data.txt");for(int i=0;i<10;i++){infile>>data ; //读数据的时候因为数据间有一个空格才能完整的读出,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]);读取:char ch;ifstream infile("data.txt");while(infile){infile.get(ch);cout<<ch;}getch();}3 字符串数据的输入数据多的时候读写速度比较快,输入时以整行字符串加上换行符号一次写入。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
在看C++编程思想中,每个练习基本都是使用ofstream,ifstream,fstream,以前粗略知道其用法和含义,在看了几位大牛的博文后,进行整理和总结:这里主要是讨论fstream的内容:[java]view plaincopyprint?1.#include <fstream>2.ofstream //文件写操作内存写入存储设备3.ifstream //文件读操作,存储设备读区到内存中4.fstream //读写操作,对打开的文件可进行读写操作1.打开文件在fstream类中,成员函数open()实现打开文件的操作,从而将数据流和文件进行关联,通过ofstream,ifstream,fstream对象进行对文件的读写操作函数:open()[cpp]view plaincopyprint?1.<span style="font-family: Times New Roman; font-size: 16px;">2.public member function3.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.</span>1.ofstream out;2.out.open("Hello.txt", ios::in|ios::out|ios::binary) //根据自己需要进行适当的选取1.<span style="font-family: Times New Roman; font-size: 16px;">2.ofstream out("...", ios::out);3.ifstream in("...", ios::in);4.fstream foi("...", ios::in|ios::out);5.6.</span>当使用默认方式进行对文件的操作时,你可以使用成员函数is_open()对文件是否打开进行验证2.关闭文件当文件读写操作完成之后,我们必须将文件关闭以使文件重新变为可访问的。
成员函数close(),它负责将缓存中的数据排放出来并关闭文件。
这个函数一旦被调用,原先的流对象就可以被用来打开其它的文件了,这个文件也就可以重新被其它的进程所访问了。
为防止流对象被销毁时还联系着打开的文件,析构函数将会自动调用关闭函数close。
3.文本文件的读写类ofstream, ifstream 和fstream 是分别从ostream, istream 和iostream 中引申而来的。
这就是为什么fstream 的对象可以使用其父类的成员来访问数据。
一般来说,我们将使用这些类与同控制台(console)交互同样的成员函数(cin 和cout)来进行输入输出。
如下面的例题所示,我们使用重载的插入操作符<<:[cpp]view plaincopyprint?1. // writing on a text file2. #include <fiostream.h>3.int main () {4. ofstream out("out.txt");5. if (out.is_open())6. {7. out << "This is a line.\n";8. out << "This is another line.\n";9. out.close();10. }11. return 0;12. }13.//结果: 在out.txt中写入:14.This is a line.15.This is another line从文件中读入数据也可以用与cin>>的使用同样的方法:[cpp]view plaincopyprint?1.// reading a text file2. #include <iostream.h>3. #include <fstream.h>4. #include <stdlib.h>5.6.int main () {7.char buffer[256];8. ifstream in("test.txt");9. if (! in.is_open())10. { cout << "Error opening file"; exit (1); }11. while (!in.eof() )12. {13. in.getline (buffer,100);14. cout << buffer << endl;15. }16. return 0;17. }18. //结果在屏幕上输出19. This is a line.20. This is another line上面的例子读入一个文本文件的内容,然后将它打印到屏幕上。
注意我们使用了一个新的成员函数叫做eof ,它是ifstream 从类ios 中继承过来的,当到达文件末尾时返回true 。
状态标志符的验证(Verification of state flags)除了eof()以外,还有一些验证流的状态的成员函数(所有都返回bool型返回值):∙bad()如果在读写过程中出错,返回true 。
例如:当我们要对一个不是打开为写状态的文件进行写入时,或者我们要写入的设备没有剩余空间的时候。
∙fail()除了与bad() 同样的情况下会返回true 以外,加上格式错误时也返回true ,例如当想要读入一个整数,而获得了一个字母的时候。
∙eof()如果读文件到达文件末尾,返回true。
∙good()这是最通用的:如果调用以上任何一个函数返回true 的话,此函数返回false 。
要想重置以上成员函数所检查的状态标志,你可以使用成员函数clear(),没有参数。
获得和设置流指针(get and put stream pointers)所有输入/输出流对象(i/o streams objects)都有至少一个流指针:∙ifstream,类似istream, 有一个被称为get pointer的指针,指向下一个将被读取的元素。
∙ofstream, 类似ostream, 有一个指针put pointer ,指向写入下一个元素的位置。
∙fstream, 类似iostream, 同时继承了get 和put我们可以通过使用以下成员函数来读出或配置这些指向流中读写位置的流指针:∙tellg() 和tellp()这两个成员函数不用传入参数,返回pos_type 类型的值(根据ANSI-C++ 标准) ,就是一个整数,代表当前get 流指针的位置(用tellg) 或put 流指针的位置(用tellp).∙seekg() 和seekp()这对函数分别用来改变流指针get 和put的位置。
两个函数都被重载为两种不同的原型:seekg ( pos_type position );seekp ( pos_type position );使用这个原型,流指针被改变为指向从文件开始计算的一个绝对位置。
要求传入的参数类型与函数tellg 和tellp 的返回值类型相同。
seekg ( off_type offset, seekdir direction );seekp ( off_type offset, seekdir direction );使用这个原型可以指定由参数direction决定的一个具体的指针开始计算的一个位移(offset)。
它可以是:1.// obtaining file size2. #include <iostream.h>3. #include <fstream.h>4.5. const char * filename = "test.txt";6.7.int main () {8.long l,m;9. ifstream in(filename, ios::in|ios::binary);10. l = in.tellg();11. in.seekg (0, ios::end);12. m = in.tellg();13. in.close();14. cout << "size of " << filename;15. cout << " is " << (m-l) << " bytes.\n";16. return 0;17. }18.19. //结果:20. size of example.txt is 40 bytes.4.二进制文件在二进制文件中,使用<< 和>>,以及函数(如getline)来操作符输入和输出数据,没有什么实际意义,虽然它们是符合语法的。
文件流包括两个为顺序读写数据特殊设计的成员函数:write 和read。
第一个函数(write) 是ostream 的一个成员函数,都是被ofstream所继承。
而read 是istream 的一个成员函数,被ifstream 所继承。
类fstream 的对象同时拥有这两个函数。
它们的原型是:write ( char * buffer, streamsize size );read ( char * buffer, streamsize size );这里buffer 是一块内存的地址,用来存储或读出数据。
参数size 是一个整数值,表示要从缓存(buffer)中读出或写入的字符数。
[cpp]view plaincopyprint?1.// reading binary file2. #include <iostream>3. #include <fstream.h>4.5. const char * filename = "test.txt";6.7.int main () {8.char * buffer;9.long size;10. ifstream in (filename, ios::in|ios::binary|ios::ate);11. size = in.tellg();12. in.seekg (0, ios::beg);13. buffer = new char [size];14. in.read (buffer, size);15. in.close();16.17. cout << "the complete file is in a buffer";18.19. delete[] buffer;20. return 0;21. }22. //运行结果:23. The complete file is in a buffer5.缓存和同步(Buffers and Synchronization)当我们对文件流进行操作的时候,它们与一个streambuf 类型的缓存(buffer)联系在一起。