Stdout"和换行字符(' ')必威:输出到标准输出流,

1. 流

  • 流:数据从贰个目的到另二个指标的传输。
  • 效果:典型输入输出+文件管理
分类 含义
文本流 一串ASCII字符
二进制流 一串二进制

转自:

1、流的垄断(monopoly)

必威 1

    iomanip          在使用格式化I/O时应蕴涵此头文件。
    stdiostream   用来混合使用C和C + +的I/O机制时,举个例子想将C程序转换为C++程序

之后职业会用到。

C++ 通过以下多少个类帮助文件的输入输出:

2. 流类型

规范库定义了三大类流类型:标准I/O流、文件流、字符串流

  • 标准I/O流
    • ios是抽象类
    • ostreamcoutclogcerr的类
    • istreamcin的类
  • 文件流类型
    • ifstream从文件读取数据
    • ofstream向文件写入数据
    • iofstream文本读写多少
  • 字符串流类型
    • istringstreamstring读取数据
    • ostringstreamstring写入数据
    • iostringstream读写string数据

C++ 通过以下多少个类援助文件的输入输出:

2、类承继关系

必威 2
ios是空虚基类,由它派生出istream类和ostream类, iostream类支持输入输出操作,iostream类是从istream类和ostream类通过多种承接而派生的类

类ifstream传承了类istream,类ofstream承继了类ostream,类fstream承袭了 类iostream
iostream头文件中4种流对象

对象

含义

对应设备

对应的类

c语言中相应的标准文件

cin

标准输入流

键盘

istream_withassign

stdin

cout

标准输出流

屏幕

ostream_withassign

stdout

cerr

标准错误流

屏幕

ostream_withassign

stderr

clog

标准错误流

屏幕

ostream_withassign

stderr

cout补充
1、用“cout<<”输出骨干类型的多寡时,能够不用挂念数据是哪些项目,系统会推断数据的等级次序

      并基于其连串采纳调用与之相称的运算符重载函数。这一个进度都以机关的,顾客无需干预。

        假若在C语言中用prinf函数输出差异品类的数码,必需分别内定相应的输出格式符,十一分劳动,何况便于出错

2、cout流在内存中对应开垦了二个缓冲区,用来贮存在流中的数码,当向cout流插 人二个endl时,

     不论缓冲区是还是不是已满,都及时输出流中全数数据,然后插入二个换行符, 并刷新流(清空缓冲区)。

        注意假如插人三个换行符”n“(如cout<<a<<"n"),则只输出和换行,而不刷新cout 流(但并非有着编写翻译系统都呈现出这一分别)。

3、在iostream中只对"<<"和">>"运算符用于职业项目数据的输入输出举行了重载,但未对顾客注脚的体系数据的输入输出 进行重载。

    即使客商评释了新的项目,并希望用"<<"和">>"运算符对其进展输入输出,依据重运算符重载来做。

cout 流日常是传递到显示屏输出,但也足以被重定向 输出到磁盘文件,而cerr流中的消息只好在显示屏输出

cerr是不通过缓冲区,直接向显示屏上输出有关新闻,而clog中的新闻寄放在缓冲区中,缓冲区满后或遇endl时向显示屏输出

在C++中,有叁个stream那几个类,全部的I/O都以这几个“流”类为根基的,富含我们要认知的公文I/O,stream这么些类有三个相当重要的 运算符:

ofstream: 写操作(输出)的公文类 (由ostream引申而来) 
ifstream: 读操作(输入)的文本类(由istream引申而来) 
fstream: 可同有时间读写操作的文书类 (由iostream引申而来)

3. 流对象

常见规范I/O流对象是全局对象不供给定义,而文件流对象和字符串流对象急需顾客定义。

标准I/O流对象有以下三个:

No. 全局流对象 名称 缓存
1 cout 标准输出流 带缓存
2 cin 标准输入流 带缓存
3 clog 标准日志流 带缓存
4 cerr 标准错误流 无缓存

专一:流对象经常都不可能复制。

  • ofstream: 写操作(输出)的文书类 (由ostream引申而来)
  • ifstream: 读操作(输入)的文件类(由istream引申而来)
  • fstream: 可同期读写操作的公文类 (由iostream引申而来)

3、规范输入流 cin

    重视明白的函数
    cin.get()                 //读入叁个字符并重返它的值
    cin.get(三个参数)  //读入叁个字符并把它存款和储蓄在ch 
    cin.get(四个参数)  //能够读取字符串
    cin.get(多个参数)  //能够读字符串        
    cin.getline()
    cin.ignore()           //读取字符并忽略内定字符
    cin.peek()            //检查下三个输入的字符,不会把字符从流中移除
    cin.putback()       //重回三个字符给多个流

重要
1、使用cin,从流中读出的字符,流中就从不那字符了,再一次读取时不得不读取剩下的
2、缓冲去唯有在遇到EOF、手动敲回车、流(缓存区)满时,才将流中的字符全部读出(即清空缓存区)

练习
1、从流中取贰个字符,然后在放进去;
2、剖断流中的率先个字符是否放进去的百般字符;
3、从流中读取11个字符;
4、从流中忽略5个字符,再读取十个字符;
5、最终读取剩下的字符,最终输出读到的装有字符

#include <iostream>
using namespace std;

int main()
{
    char ch1;
    int look;
    char str1[11] = {0};
    char str2[11] = {0};
    char str3[100] = {0};

    //从流中取一个字符,然后在放进去
    ch1 = cin.get();
    cin.putback(ch1);

    //判断流中的第一个字符是不是放进去的那个字符
    look = cin.peek();
    if(look == (int)ch1)
    {
        cout<<"cin.peek()放进去的字符在第一个位置"<<endl;
    }
    else
    {
        cout<<"cin.peek()放进去的字符不是在第一个位置"<<endl;
    }

    //从流中读取10个字符
    cin.get(str1,11);

    //从流中忽略5个字符,再读取10个字符
    cin.ignore(5);
    cin.get(str2,11,EOF);

    //最后读取剩下的字符,最后输出读到的所有字符
    cin.getline(str3,100);

    //输出读到的数据
    cout<<"第一个字符"<<ch1<<endl;
    cout<<"第一组 字符串:"<<str1<<endl;
    cout<<"第二组 字符串:"<<str2<<endl;
    cout<<"剩下的字符串:"<<str3<<endl;

    system("pause");
    return 0;
}

输出:

0123456789abcde9876543210zzzzzzzzzzxxxxxxxxxxxxxyyyyyyyyyyyy
cin.peek()放进去的字符在第一个位置
第一个字符0
第一组 字符串:0123456789
第二组 字符串:9876543210
剩下的字符串:zzzzzzzzzzxxxxxxxxxxxxxyyyyyyyyyyyy

1、插入器(<<)
  向流输出多少。比方说系统有多个暗中认可的正儿八经输出流(cout),平日意况下正是指的显示器,所 以,cout<<"Write Stdout"<<' ';就象征把字符串"Write Stdout"和换行字符(' ')输出到标准输出流。

开采文件(Open a file)
对那个类的八个对象所做的首先个操作平时正是将它和三个的确的文件联系起来,也正是说展开二个文书。被展开的文书在前后相继中由三个流对象(stream object)来表示 (那几个类的三个实例) ,而对这些流对象所做的别的输入输出操作实际便是对该文件所做的操作。

4. 流目的情形

流对象处境在某一个整天必定处于以下三个意况之一。

No. 状态 含义
1 good() 前一个流操作成功
2 eof() 到输入尾/文件尾
3 fail() 发生意外事情
4 bad() 发生意外严重事情

 

4、标准输出流 cout

2、析取器(>>)
  从流中输入数据。比方说系统有二个默许的标准输入流(cin),常常情状下就是指的键盘,所 以,cin>>x;就意味着从行业内部输入流中读取三个点名项目(即变量x的类别)的数据。

要透过一个流对象打开八个文书,大家应用它的分子函数open():void open (const char * filename, openmode mode);

5. I/O操作

I/O操作重要有如下二种:

  • 输入操作:in >> x或者getline
  • 出口操作:out << x
  • 操作符
  • 流状态
  • 格式化
  • 出口流暗许设置
类型 进制 宽度 对齐 填充 精度
整数 十进制 0 右对齐 空格 1
实数 十进制 0 右对齐 空格 6位数
字符串 - 0 右对齐 空格 字符串实际长度
  • 格式调控
  • 格式调整成员函数
流对象.格式控制函数
  • 预订义格式调节函数
预定义格式控制函数
  • 流的出口调节格式
作用 格式控制成员函数 预定义格式控制函数 预定义格式控制符/操作子 效果持续
进制 flags() setf() unsetf() setiosflags() dec oct hex showbase 能持续
宽度 width setw - 不能持续
对齐 flags() setf() unsetf() setiosflags() right left internal 能持续
填充 fill setfill - 能持续
精度 precision setprecision - 能持续
  • 流的出口调整格式:dec oct hex
  • 数码输入成员函数字符输入成员函数:get()字符串输入成员函数:getline()
  • 多少输出成员函数:put()

开发文件(Open a file)

  流成员函数

必威 3

  cout.flush()      //清空缓冲区
  cout.put()        //把字符写入流中
  cout.write()      //将字符串写入当前出口流中

必威 4

  eg : cout.setf( ios::dec );

         cout.setf(ios::hex,ios::base田野先生);【提议使用这种】

  需注意:1、fmtflags setf( fmtflags flags ); 使用这种,应当要先打消当前基【cout.unself()】,之后才得以设置新的基

 2、fmtflags setf( fmtflags flags, fmtflags needed ); 使用这种,第二个参数设为当前的基,或然当不领会当前基时,设为ios_base::base田野清除当前的有着也许的基    

  在C++中,对文件的操作是通过stream的子类fstream(file stream)来贯彻的,所以,要用这种艺术操作文件,就不能够不步入头文件fstream.h。上边就把该类的公文操作进度一 一道来。

这里filename 是一个字符串,代表要开拓的文件名,mode 是以下标记符的三个重组: ios::in 为输入(读)而展开文件 
ios::out 为出口(写)而张开文件 
ios::ate 初步地方:文件尾 
ios::app 全体出口附加在文件末尾 
ios::trunc 若是文件已存在则先删除该公文 
ios::binary 二进制情势

1. 对齐情势

flag manipulator 作用
ios::left left 居左
ios::right right 居右
ios::internal internal 输出符号或进制后填充
  • 成员函数格局
#include <iostream>using namespace std;int main(){ int n = -11; cout.width; cout.flags(ios::right); cout << n << endl; cout.width; cout.flags(ios::left); cout << n << endl; cout.width; cout.flags(ios::internal); cout << n << endl;}
  • 操作子形式
#include <iostream>#include <iomanip>using namespace std;int main(){ int n = -11; cout << setw << right << n << endl; cout << setw << left << n << endl; cout << setw << internal << n << endl;}
  • 错落形式
#include <iostream>using namespace std;int main(){int n = -11; cout.width; cout << left << n << endl; cout.width; cout << right << n << endl; cout.width; cout << internal << n << endl;}

对这几个类的贰个对象所做的第叁个操作日常便是将它和贰个当真的公文学美术师联合会系起来,也正是说展开一个文书。被展开的文件在前后相继中由八个流对象(stream object)来代表 (这几个类的一个实例) ,而对这一个流对象所做的别的输入输出操作实际就是对该文件所做的操作。

  控制符,头文件<iomanip>

必威 5
 eg:  cout<<setw(5);

一、展开文件
  在fstream类中,有三个成员函数open(),就是用来开垦文件的,其原型是:

这一个标志符能够被重组使用,中间以”或”操作符(|)间隔。比方,假诺大家想要以二进制格局张开文件"example.bin" 来写入一些多少,大家能够透过以下格局调用成员函数open()来落到实处:ofstream file;
file.open ("example.bin", ios::out | ios::app | ios::binary);

2. 整数输出格式

flag manipulator 作用 是否默认
ios::dec dec 十进制
ios::oct oct 八进制
ios::hex hex 十六进制
ios::uppercase uppercase 使用大写输出十六进制
ios::showbase showbase 输出带有进制的字符
  • 成员函数方式
#include <iostream>using namespace std;int main(){ int n = 11; cout.flags; cout << n << endl; cout.flags; cout << n << endl; cout.flags; cout << n << endl; cout.flags(ios::showbase|ios::dec); cout << n << endl; cout.flags(ios::showbase|ios::oct); cout << n << endl; cout.flags(ios::showbase|ios::hex); cout << n << endl; cout.flags(ios::showbase|ios::uppercase|ios::dec); cout << n << endl; cout.flags(ios::showbase|ios::uppercase|ios::oct); cout << n << endl; cout.flags(ios::showbase|ios::uppercase|ios::hex); cout << n << endl;}
  • 操作子格局
#include <iostream>using namespace std;int main(){ int n = 11; cout << dec << n << endl; cout << hex << n << endl; cout << oct << n << endl; cout << showbase << dec << n << endl; cout << oct << n << endl; cout << hex << n << endl; cout << uppercase << dec << n << endl; cout << oct << n << endl; cout << hex << n << endl;}

要由此一个流对象展开二个文本,咱们利用它的积极分子函数open():

5、文件I/O

是因为文件设备并不像显示屏显示器与键盘这样是正统私下认可设备,不能够像cout那样优先定义的大局对象,所以我们必得协调定义叁个此类的指标。

ifstream类,它是从istream类派生的,用来帮助从磁盘文件的输入。

ofstream类,它是从ostream类派生的,用来支撑向磁盘文件的输出。

fstream类,它是从iostream类派生的,用来支撑对磁盘文件的输入输出。

void open(const char* filename,int mode,int access);

ofstream, ifstream 和 fstream全数那一个类的成员函数open 都含有了一个暗中认可展开文件的艺术,这多个类的暗中同意方式各分歧: 类 参数的默许形式 
ofstream ios::out | ios::trunc 
ifstream ios::in 
fstream ios::in | ios::out

3. 浮点数输出格式

flag 作用 是否默认 精度
ios::defaultfloat 默认浮点数格式 最多保留多少位数字
ios::scientific 科学计数法输出浮点数 小数点后最多保留多少位数字
ios::fixed 定点数方式输出实数 小数点后最多保留多少位数字

设若浮点数未有小数时私下认可不显得小时点,使用ios::showpoint能够强制输出浮点数时,必得带小数点。

定点数形式比浮点数格局勘误确取浮点数精确度时,设置ios::fixed

  • 成员函数格局
#include <iostream> // cout, std::fixed, std::scientificusing namespace std;int main () { double a = 3.1415926534; double b = 2006.0; double c = 1.0e-10; cout.precision; cout << "default:n"; cout << a << endl << b << endl << c << endl; cout << "fixed:n"; cout.flags(ios::fixed); cout << a << endl << b << endl << c << endl; cout << "scientific:n"; cout.flags(ios::scientific); cout << a << endl << b << endl << c << endl; return 0;}
  • 操作子情势
#include <iostream> // std::cout, std::fixed, std::scientific#include <iomanip>using namespace std;int main () { double a = 3.1415926534; double b = 2006.0; double c = 1.0e-10; cout << setprecision << "default:n" << a << endl << b << endl << c << endl; cout << "fixed:n" << fixed << a << endl << b << endl << c << endl; cout << "scientific:n" << scientific << a << endl << b << endl << c << endl; return 0;}
  • 错落格局
#include <iostream> // std::cout, std::fixed, std::scientificint main () { double a = 3.1415926534; double b = 2006.0; double c = 1.0e-10; std::cout.precision; std::cout << "default:n"; std::cout << a << 'n' << b << 'n' << c << 'nn' std::cout << "fixed:n" << std::fixed; std::cout << a << 'n' << b << 'n' << c << 'nn' std::cout << "scientific:n" << std::scientific; std::cout << a << 'n' << b << 'n' << c << 'nn'; return 0;}

void open (const char * filename, openmode mode);

文本原理

    文件展开都有贰个文件指针,该指针的开头地点由I/O格局内定,每趟读写都从文件指针的近来岗位上马。每读入一个字节,指针就后移三个字节。当文件指针移到结尾,就能够蒙受文本甘休EOF(文件结束符也占贰个字节,其值为-1),此时代洋气对象的分子函数eof的值为非0值(常常设为1),表示文件停止了

    文件关闭,实际上是解除该磁盘文件与文件流的关系,原本设置的做事措施也失效,那样,就不能够再通过文件流对该文件进行输入或输出

    文件类型:1、ASCII文件:文件的每多少个字节中均以ASCII代码格局存放数据,即四个字节贮存贰个字符,那么些文件就是ASCII文件(或称字符文件)。

     2、二进制文件:文件中的消息不是字符数据,而是字节中的二进制格局的音信,因而它又称作字节文件

参数:

唯有当函数被调用时不曾评释方式参数的意况下,暗中同意值才会被运用。假设函数被调用时声称了其余参数,默许值将被统统改写,而不会与调用参数组合。

4.布尔类型输出格式

flag manipulator 作用
ios::boolalpha boolalpha bool值以字符串true/false输出

那边filename 是三个字符串,代表要张开的公文名,mode 是以下标记符的一个结合:

常用函数

filename:  要开发的文件名
mode:    要开垦文件的法子
access:   展开文件的习性
开发文 件的章程在类ios(是具备流式I/O类的基类)中定义,常用的值如下:

由 于对类ofstream, ifstream 和 fstream 的目的所开展的率先个操作平常都以展开文件,这一个类都有二个构造函数可以直接调用open 函数,并负有一样的参数。那样,大家就能够透过以下格局张开与地方同样的概念对象和开垦文件的操作:ofstream file ("example.bin", ios::out | ios::app | ios::binary);

5. 其它

flag manipulator 作用 默认
ios::showpos showpos 输出十进制0或者正数时,带+号
  • 成员函数格局
#include <iostream> // std::cout, std::showpos, std::noshowposusing namespace std;int main () { int p = 1; int z = 0; int n = -1; cout.setf(ios::showpos); cout << p << 't' << z << 't' << n << endl; cout.unsetf(ios::showpos); cout << p << 't' << z << 't' << n << endl; return 0;}
  • 操作子格局
#include <iostream> // std::cout, std::showpos, std::noshowposusing namespace std;int main () { int p = 1; int z = 0; int n = -1; cout << showpos << p << 't' << z << 't' << n << endl; cout << noshowpos << p << 't' << z << 't' << n << endl; return 0;}

复数虚部a+bi使用showpos卓殊确切。

问题

  1. 浮点数八进制/十六进制输出结果?
  2. 下列代码为何能转化成十六进制?
#include <iostream>#include <iomanip> // setiosflags() , ios::hexusing namespace std;int main(){ cout << setiosflags << 10 << endl;}

最新版C++的iostream库中,在使用setiosflags()前要先选取resetiosflags()破除旧有照顾消息。

cout << resetiosflags(ios::basefield)<< setiosflags << 10 << endl;

以下三类格式化在选取setiosflags(),要先使用resetiosflags()排除旧有照顾音讯。

必威 6

  • 字符串转化数字
istringstream iss;int n;iss >> n;

C++11提供如下函数简化字符串转数字

  • stoi() stol() stoul() stoll() stoull()

  • stof() stod() stold()

  • 数字转化字符串

int n;ostringstream oss;oss << n;oss.str();
  • C++文件读写文件:文件名+文件内容文件名:字符连串文件数量格式:二进制文件/文本文件

  • C++文件操作流程

  1. 开采文件
  2. 读写文件
  3. 关闭文件
  • 张开/关闭文件
操作 代码
定义读文件流对象 ifstream 读文件流对象
定义写文件流对象 ofstream 写读文件流对象
定义读写文件流对象 fstream 读写读文件流对象
成员函数打开文件 文件流对象.open(文件名,文件打开方式)
构造函数打开文件 文件流类 对象(文件名,文件打开方式)
判断文件是否打开 !文件流对象
关闭文件 文件流对象.close
  • 文件文件读写
操作 代码
提取运算符读文件 文件流对象 >> 变量
插入运算符写文件 文件流对象 << 变量
成员函数读文件 文件流对象.get
成员函数写文件 文件流对象.put
  • 二进制文件读写
操作 代码
读函数 read()
写函数 write()
测试文件结束 eof()
  • 文件展开药格局
类型 代码
ios::in
ios::out
添加末尾 ios::app
已存在文件 ios::nocreate
未打开文件 ios::noreplace
二进制 ios::binary
  • 文本对象指针地点函数
操作 代码
获取读位置 对象.tellg()
获取写位置 对象.tellp()
设置读位置 对象.seekg()
设置写位置 对象.seekp()
  • 函数后缀p表示put,后缀g表示get
  • 倘使文件是以ios::app文本追加格局张开,指针地点暗中同意在文件结束,其余景况默许在文书起初。
  • 文本对象情况函数
操作 代码
判断文件对象状态是否正常 对象.good()
重置文件对象状态 对象.clear()

流式文件类型

  1. stream流文件
  2. 文件指针FILE*

ios::in

为输入(读)而打开文件

ios::out

为输出(写)而打开文件

ios::ate

初始位置:文件尾

ios::app

所有输出附加在文件末尾

ios::trunc

如果文件已存在则先删除该文件

ios::binary

二进制方式

展开文件:   

必威 7

方式1:对文件输出流、文件流对象,通过ofstream类的构造函数张开文件

    格式: ofstream (磁盘文件名, 输入输出格局);      

    假使ofstream  为0(假),表示张开操作战败

    如:   ofstream fout1(fname,ios::out);

    输入输出方式得以选取能够举办重组使用的,以“或”运算(“|”)的措施,如:fstream fout(fname,ios::out|ios::in)

方式2:对文件的输出和输入流对象、文件流对象,都可经过open函数张开文件

    格式: 文件流对象.open(磁盘文件名, 输入输出方式);      

    重返值:为0(假),张开操作退步

    如:   fout.open(fname,ios::out)       

ios::app:   以充实的格局张开文件
ios::ate:   文件打开后一定到文件尾,ios:app就带有有此属性
ios::binary:  以二进制主意展开文件,缺省的章程是文件方式。三种情势的界别见前文
ios::in:     文件以输入格局张开
ios::out:   文件以出口方式展开
ios::nocreate: 不树立文件,所以文件官样文章时张开退步 
ios::noreplace:不覆盖文件,所以张开文件时只要文件存在停业
ios::trunc:   假诺文件存在,把公文长度设为0
  能够用“或”把上述属性连接起来,如ios::out|ios::binary

两种展开文件的章程都以不错的。

stream流文件读写

  • ifstream文件读
ifstream fin;fin >> 变量fin.close();
  • ofstream文件写
ofstream fout;fout << 变量fout.close();
  • fstream文件写
fstream fs(文件路径,ios::in|ios::out|ios::app);if{ fs << 变量; fs.seekg; fs >> 变量; fs.close();}

fstream的开辟情势是或不是成立不设有的文书

No. 打开模式 是否创建不存在的文件
1 ios::in
2 ios::out
3 `ios::in ios::out`
4 `ios::in ios::out

先读后写

 fstream fs("test.txt",ios::in|ios::out|ios::app); if{ // 读文件 string str; while(fs >> str){ cout << str << endl; } fs.clear();// 清除错误 // 写文件 while(cin >> str){ fs << str << endl; } }

先写后读

 fstream fs("test.txt",ios::in|ios::out|ios::app); if{ // 写文件 string str; while(cin >> str) fs << str << endl; // 读文件 fs.seekg; while(fs >> str) cout << str << endl; // 后续如果对fs操作,需要清空fs状态 }else{ cerr << "file not exist " << endl; }

这么些标记符能够被整合使用,中间以”或”操作符(|)间隔。比方,借使大家想要以二进制格局张开文件"example.bin" 来写入一些数码,大家得以因而以下格局调用成员函数open()来贯彻:

关闭文件

 在对已开垦的磁盘文件的读写操作完结后,必得求关门该文件  如:  outfile.close( );

  张开文件的习性取值是:

你能够因此调用成员函数is_open()来检查叁个文件是不是业已被顺遂的开辟了:bool is_open();

文件指针FILE读写

  • FILE文件指针读
FILE* fp = fopen;fscanf;fclose;
  • FILE文本指针写
FILE* fp = fopen;fprintf;fclose; 

对象的连串化与反体系化类别化:把对象转化成文本/二进制反系列化:把公文/二进制转化成对象

ofstream file; file.open ("example.bin", ios::out | ios::app | ios::binary);

文本操作

    1、能够用流插入运算符“<<”和流提取运算符“>>”输入输出标准项目标数码(>> 读出时在遇空格、换行都得了)。

    2、也足以用文件流的put、get、geiline等成员函数实行字符的输入输出。

#include <iostream>
using namespace std;
#include "fstream"

int main()
{
    char fname[] = "d:/file1.txt";
    char buff[1024]= {0};
    /***********  写文件  *************/
    //方式1 输出流ofstream对象调用fopen函数
    ofstream fout;
    fout.open(fname,ios::out);
    if(!fout)
    {
        cout<<"打开文件失败"<<fname<<endl;
    }
    fout<< "hello world !";  //通过左移运算符写入字符串
    fout.flush();
    fout.close();

    //方式2 调用输出流ofstream对象的构造函数
    ofstream fout1(fname,ios::out);
    if(!fout1)
    {
        cout<<"打开文件失败"<<fname<<endl;
    }
    fout1.put('h'); //通过put函数写入字符
    fout1.put('e');
    fout1.put('l');
    fout1.put('l');
    fout1.put('o');
    fout1.put('n');
    fout1.flush();
    fout1.close();

    //文件流对象写文件
    fstream file2(fname,ios::in|ios::out);
    file2<<"abdfdn";
    file2<<"11111n";
    file2.flush();
    file2.close();

    /***********  读文件  *************/
    //输入流ifstream对象读取文件内容
    ifstream fin;
    fin.open(fname,ios::in);
    fin.getline(buff,1024);       //通过getline函数读取字符串
    cout<<buff<<endl;   
    fin.close();

    //文件流对象读文件内容
    fstream file1(fname,ios::in|ios::out);
    file1>>buff;  //通过右移运算符读出字符串
    file1.close();
    cout<<buff<<endl;


    system("pause");
    return 0;
}

0:普通文书,打开访谈
1:只读文件
2:隐含文件
4:系统文件
  能够用“或”或然“+”把以上属性连接 起来 ,如3或1|2正是以只读和包含属性展开文件。

它回到三个布尔(bool)值,为真(true)代表文件已经被顺利张开,假( false )则相反。

文件重定向

freopen(文件路径,操作,标准IO)

操作:读(r) 写(w)

  • 重定向写
freopen("out.txt","w",stdout);cout << "out data" <<endl;
  • 重定向读
freopen("in.txt","r",stdin);string str;cin >> str;

三种常见的公文读取方式相比

  • ifstream + fin
  • freopen+cin+sync_with_stdio
  • FILE* + fscanf
  • freopen+scanf
  • freopen+cin

落到实处日志模块

freopen("test.log","w",stderr);cerr << "FATAL";cerr << "ERROR";clog << "WARNING";clog << "INFO";clog << "DEBUG";

ofstream, ifstream 和 fstream全体那些类的积极分子函数open 都带有了叁个暗中同意展开文件的格局,那三个类的暗中认可格局各分化:

二进制文件操作

    对二进制文件的读写主要用istream类的分子函数read和write来完结。那多个分子函数的原型为

     istream& read(char *buffer,int len);

     ostream& write(const char * buffer,int len);

#include <iostream>
using namespace std;
#include <fstream>

class Teacher
{
public:
    Teacher()
    {

    }
    Teacher(int age,char name[20])
    {
        this->age = age;
        strcpy(this->name,name);
    }
    void prinfInfo()
    {
        cout<<"Teacher name:"<<this->name<<"   age:"<<this->age<<endl;
    }
private:
    int age;
    char name[20];
};

int main()
{
    Teacher t1(31,"xiaoming");
    Teacher t2(32,"xiaohong");
    Teacher t3(33,"xiaohua");
    Teacher t4(34,"xiaoxin");
    char fname[] = "d:/file2";
    fstream fs(fname,ios::binary|ios::out);
    if(!fs)
    {
        cout<<"文件打开失败"<<endl;
    }
    fs.write((char *)&t1,sizeof(Teacher));
    fs.write((char *)&t2,sizeof(Teacher));
    fs.write((char *)&t3,sizeof(Teacher));
    fs.write((char *)&t4,sizeof(Teacher));
    fs.flush();
    fs.close();

    fstream fs2(fname,ios::binary|ios::in);
    if(!fs)
    {
        cout<<"文件打开失败"<<endl;
    }
    Teacher tt;
    fs2.read((char *)&tt,sizeof(Teacher));
    tt.prinfInfo();
    fs2.read((char *)&tt,sizeof(Teacher));
    tt.prinfInfo();
    fs2.read((char *)&tt,sizeof(Teacher));
    tt.prinfInfo();
    fs2.read((char *)&tt,sizeof(Teacher));
    tt.prinfInfo();
    fs2.close();

    system("pause");
    return 0;
}

输出:

Teacher name:xiaoming   age:31
Teacher name:xiaohong   age:32
Teacher name:xiaohua   age:33
Teacher name:xiaoxin   age:34

 

  例如:以二进制输入格局展开文件c:config.sys

关闭文件(Closing a file)
当文件读写操作落成之后,大家不可能不将文件关闭以使文件再次变成可访问的。关闭文件须求调用成员函数close(),它承担将缓存中的数据排泄出去并关闭文件。它的格式很轻易:void close ();

恢宏阅读

  • <<C++程序设计语言 中文第四版>>:第38章 I/O流

参数的默认方式

ofstream

ios::out | ios::trunc

ifstream

ios::in

fstream

ios::in | ios::out

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

其一函数一旦被调用,原先的流对象(stream object)就能够被用来展开其它的公文了,那些文件也就能够再度被别的的进程(process)全部访问了。

只有当函数被调用时未有申明情势参数的事态下,暗许值才会被应用。如若函数被调用时宣称了其余参数,暗中同意值将被统统改写,而不会与调用参数组合。

  借使open函数唯有文件名二个参数,则是以读/写普通文书展开,即:

为幸免流对象被销毁时还关系着展开的文书,析构函数(destructor)将会自动调用关闭函数close。

是因为对类ofstream, ifstream 和 fstream 的靶子所举行的首先个操作平时都是开荒文件,那么些类都有三个构造函数能够平昔调用open 函数,并装有一致的参数。那样,我们就足以由此以下方式举行与地方同样的定义对象和开发文件的操作:

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

文本文件(Text mode files)
类ofstream, ifstream 和fstream 是独家从ostream, istream 和iostream 中引申而来的。那就是干吗 fstream 的对象足以应用其父类的分子来寻访数据。

ofstream file ("example.bin", ios::out | ios::app | ios::binary);

  另外,fstream还只怕有和open()一样的构造函数,对于上例,在概念的时侯就能够打开文件了:

日常的话,大家将利用那几个类与同调整台(console)交互同样的积极分子函数(cin 和 cout)来拓宽输入输出。如上边包车型大巴例题所示,大家应用重载的插入操作符<<:

两种展开文件的点子都以科学的。

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

// writing on a text file
#include <fstream>
using namespace std;

int main()
{
    ofstream examplefile("example.txt");
    if (examplefile.is_open())
    {
        examplefile << "This is a line.n";
        examplefile << "This is another line.n";
        examplefile.close();
    }
    return 0;
}

您能够因此调用成员函数is_open()来检查三个文书是还是不是业已被顺顺当当的展开了:

  非常提议的是,fstream有五个子类:ifstream(input file stream)和ofstream(outpu file stream),ifstream私下认可以输入格局展开文件,而ofstream私下认可以出口格局张开文件。

从文件中读入数据也能够用与 cin的应用同样的艺术:

bool is_open();

  ifstream file2("c:pdos.def");//以输入格局打开文件
  ofstream file3("c:x.123");//以出口格局打开文件

// reading a text file
#include <iostream>
#include <fstream>
#include <cstdlib>
using namespace std;
int main ()
{
    char buffer[256];
    ifstream examplefile("example.txt");
    if (! examplefile.is_open())
    {
        cout << "Error opening file"; exit (1);
    }
    while (!examplefile.eof())
    {
        examplefile.getline(buffer,100);
        cout<<buffer<< endl;
    }
    return 0;
}
//This is a line.
//This is another line.

它回到三个布尔(bool)值,为真(true)代表文件已经被顺顺当当展开,假( false )则相反。

  所以,在其实使用中,依据必要的分裂,采纳分化的类来定义:如若想以输入方式展开,就用ifstream来定义;要是想以出口格局张开,就用 ofstream来定义;假诺想以输入/输出形式来开垦,就用fstream来定义。

地方的事例读入贰个文件文件的内容,然后将它打字与印刷到显示屏上。注意大家采用了三个新的积极分子函数叫做eof ,它是ifstream 从类 ios 中三番四回过来的,当达到文件末尾时再次回到true 。

 

二、关闭文件
  张开的文本使用完了后断定要关闭,fstream提供了成员函数close()来成功 此操作,如:file1.close();就把file1相连的公文关闭。

景况标识符的证实(Verification of state flags)
而外eof()以外,还应该有一对验证流的图景的积极分子函数(全数都回到bool型重临值):

闭馆文件(Closing a file)

三、读写文件
  读写文件分为文本文件和二进制文件的读取,对于文本文件的读取比较简单,用插入器和析取器就足以了;而对此二进制读取将要复杂些,下要就详细的介绍那二种方法

bad() 
若是在读写进程中失误,再次回到 true 。举例:当大家要对三个不是开发为写境况的文本举行写入时,也许我们要写入的装置尚未剩余空间的时候。

当文件读写操作达成现在,大家必需将文件关闭以使文件再度形成可访谈的。关闭文件需求调用成员函数close(),它担负将缓存中的数据排泄出去并关闭文件。它的格式很简单:

  1、文本文件的读写
  文本文件的读写很轻易:用插入器(<<)向文件输出;用析取器(>>)从文件输入。假设file1是以输入方式展开,file2以出口展开。示举例下:

fail() 
除去与bad() 一样的情形下会回去 true 以外,加上格式错误时也回到true ,比方当想要读入贰个卡尺头,而赢得了贰个字母的时候。

void close ();

  file2<<"I Love You";//向文件写入字符串"I Love You"
  int i;
   file1>>i;//从文件输入多个整数值。

eof() 
比方读文件达到文件末尾,重临true。

其一函数一旦被调用,原先的流对象(stream object)就能够被用来开垦别的的公文了,这几个文件也就足以再一次被别的的经过(process)全数访问了。

  这种办法还应该有一种简单的格式化本事,比方能够钦点输出为16进制等等,具体的格式有以下部分

good() 
那是最通用的:即使调用以上任何一个函数重临true 的话,此函数再次来到 false 。

为防止流对象被消亡时还联系着展开的公文,析构函数(destructor)将会自行调用关闭函数close。

操纵符 功能 输入/输出
dec 格式化为十进制数值数据 输入和出口
endl 输出一个换行符并刷新此流 输出
ends 输出叁个空字符 输出
hex 格式化为十六进制数值数据 输入和输出
oct 格式化为八进制数值数据 输入和输出
setpxecision(int p) 设置浮点数的精度位数 输出

要想重新恢复设置以上成员函数所检查的情状标识,你能够应用成员函数clear(),未有参数。

 

  比方要把123充任十六进制输出:file1<

赢得和安装流指针(get and put stream pointers)
装有输入/输出流对象(i/o streams objects)都有起码一个流指针:

文本文件(Text mode files)

  2、二进制文本的读写
①put()
  put()函数向流写入三个字符,其原型是ofstream &put(char ch),使用也相比较轻巧,如file1.put('c');就是向流写一个字符'c'。

ifstream, 类似istream, 有三个被称呼get pointer的指针,指向下贰个将被读取的因素。 
ofstream, 类似 ostream, 有四个指针 put pointer ,指向写入下二个要素的地方。 
fstream, 类似 iostream, 同时继续了get 和 put 
我们得以因此选拔以下成员函数来读出或安顿那些指向流中读写地方的流指针:

类ofstream, ifstream 和fstream 是分别从ostream, istream 和iostream 中引申而来的。那正是怎么 fstream 的目的足以利用其父类的积极分子来访谈数据。

②get()
  get()函数比较灵敏,有3种常用的重载格局:

tellg() 和 tellp() 
那多个成员函数不用传入参数,再次回到pos_type 类型的值(根据ANSI-C++ 标准) ,就是三个卡尺头,代表当前get 流指针的岗位 (用tellg) 或 put 流指针的岗位(用tellp).

经常的话,大家将选拔那一个类与同调整台(console)交互同样的积极分子函数(cin 和 cout)来展开输入输出。如上面包车型地铁例题所示,大家采取重载的插入操作符<<:

  一种正是和put()对应的格局:ifstream &get(char &ch);功用是从流中读取一个字符,结果保存在援用ch中,假如到文件尾,再次来到空字符。如file2.get(x);表示从文件中读取三个字符,并把读取的 字符保存在x中。

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)。它能够是: ios::beg 从流伊始地点总结的位移 
ios::cur 从流指针当前地点上马总计的位移 
ios::end 从流末尾处初阶总结的位移

// writing on a text file
      #include <fiostream.h>
     
      int main () {
          ofstream examplefile   ("example.txt");
          if (examplefile.is_open()) {
              examplefile <<   "This is a line.n";
              examplefile <<   "This is another line.n";
              examplefile.close();
          }
          return 0;
      }
   

file example.txt  

This is a line.  

This is another line.

  另一种重载情势的原型是: int get();这种样式是从流中重临多个字符,即便达到文件尾,再次来到EOF,如x=file2.get();和上例作用是同等的。

流指针 get 和 put 的值对文本文件(text file)和二进制文件(binary file)的猜想格局都是例外的,因为文件方式的公文中一些特殊字符只怕被修改。由于这么些原因,提出对以文件文件形式张开的文书三翻五次接纳seekg 和 seekp的首先种原型,而且不用对tellg 或 tellp 的再次来到值举行改换。对二进制文件,你能够大肆使用那些函数,应该不会有其余意外的表现发生。

从文件中读入数据也得以用与 cin的运用同一的办法:

  还恐怕有一种样式的原型是:ifstream &get(char *buf,int num,char delim=' ');这种形式把字符读入由 buf 指向的数组,直到读入了 num 个字符或遭受了由 delim 钦赐的字符,假如没动用 delim 那些参数,将接纳缺省值换行符' '。比方:

以下例子使用那一个函数来收获三个二进制文件的高低:

    // reading a text file
      #include <iostream.h>
      #include <fstream.h>
      #include <stdlib.h>
     
      int main () {
          char buffer[256];
          ifstream examplefile   ("example.txt");
          if (! examplefile.is_open())
          { cout << "Error   opening file"; exit (1); }
          while (! examplefile.eof() ) {
              examplefile.getline   (buffer,100);
              cout << buffer   << endl;
          }
          return 0;
      }

This is a line.  

This is another line.

  file2.get(str1,127,'A');//从文件中读取字符到字符串str1,当蒙受字符'A'或读取了 128个字符时停下。

// obtaining file size
#include <iostream>
#include <fstream>
using namespace std;

int main ()
{
    const char * filename = "example.txt";
    long l,m;
    ifstream file(filename, ios::in|ios::binary);
    l = file.tellg();
    file.seekg(0, ios::end);
    m = file.tellg();
    file.close();
    cout <<"size of "<< filename;
    cout <<" is "<< (m-l)<<" bytes.n";
    return 0;
}
//size of example.txt is 40 bytes.

下面的例证读入三个文件文件的内容,然后将它打字与印刷到显示器上。注意大家运用了三个新的积极分子函数叫做eof ,它是ifstream 从类 ios 中一而再过来的,当达到文件末尾时再次回到true 。

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

二进制文件(Binary files)
在二进制文件中,使用<< 和>>,以及函数(如getline)来操作符输入和出口数据,未有啥实际意义,纵然它们是相符语法的。

 

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

文 件流包罗三个为各种读写多少新鲜设计的积极分子函数:write 和 read。第一个函数 (write) 是ostream 的二个分子函数,都以被ofstream所承袭。而read 是istream 的三个分子函数,被ifstream 所承袭。类 fstream 的靶子同期负有那多个函数。它们的原型是:
write ( char * buffer, streamsize size );
read ( char * buffer, streamsize size ); 
这里 buffer 是一块内存的地点,用来存储或读出多少。参数size 是叁个整数值,表示要从缓存(buffer)中读出或写入的字符数。

动静标识符的表明(Verification of state flags)

  read()从文件中读取 num 个字符到 buf 指向的缓存中,若是在还未读入 num 个字符时就到了文本尾,能够用成员函数 int gcount();来获得实在读取的字符数;而 write() 从buf 指向的缓存写 num 个字符到文件中,值得注意的是缓存的品类是 unsigned char *,有时大概必要类型转变。

// reading binary file
#include <iostream>
#include <fstream>
using namespace std;
int main ()
{
    const char * filename = "example.txt";
    char * buffer;
    long size;
    ifstream file(filename, ios::in|ios::binary|ios::ate);
    size = file.tellg();
    file.seekg(0, ios::beg);
    buffer = new char [size];
    file.read(buffer, size);
    file.close();
    cout <<"the complete file is in a buffer";
    delete[] buffer;
    return 0;
}
//The complete file is in a buffer

除了那么些之外eof()以外,还恐怕有部分验证流的气象的积极分子函数(全数都回到bool型再次回到值):

例:

缓存和一道(Buffers and Synchronization)
当我们对文件流进行操作的时候,它们与三个streambuf 类型的缓存(buffer)联系在一块儿。这一个缓存(buffer)实际是一块内部存款和储蓄器空间,作为流(stream)和概略文件的媒婆。举个例子,对于二个输出流, 每一遍成员函数put (写二个单个字符)被调用,这一个字符不是平素被写入该出口流所对应的大意文件中的,而是首先被插入到该流的缓存(buffer)中。

  • bad()

    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();

当缓存被投放出去(flush)时,它里面包车型大巴享有数据或然被写入物理媒质中(倘若是一个输出流的话),或然轻松的被抹掉(如果是贰个输入流的话)。那些进度称为同步(synchronization),它会在偏下任一情形下发出:

假诺在读写进程中失误,重回 true 。举个例子:当大家要对叁个不是张开为写情状的文本进行写入时,大概我们要写入的设备尚未剩余空间的时候。

四、检测EOF
  成员函数eof()用来检查测量试验是不是到达文件尾,假使到达文件尾重回非0值,否则再次回到0。原型是int eof();

当文件被关门时: 在文书被关门在此以前,全部还不曾被统统写出或读取的缓存都将被一道。 
当缓存buffer 满时:缓存Buffers 有必然的空中限制。当缓存满时,它会被活动同步。 
调节符明显指明:当蒙受流中有些特定的支配符时,同步会发生。这几个决定符包涵:flush 和endl。 
众人周知调用函数sync(): 调用成员函数sync() (无参数)能够招引马上联合。这几个函数重回贰个int 值,等于-1 表示流未有交流的缓存或操作退步。 
在C++中,有二个stream那个类,全体的I/O都是这几个“流”类为根基的,满含大家要认知的文书I/O,stream那些类有多少个首要的运算符:

  • fail()

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

1、插入器(<<) 
向流输出多少。比方说系统有一个暗中认可的正经输出流(cout),平日景观下正是指的显示器,所以,cout<<"Write Stdout"<<'n';就象征把字符串"Write Stdout"和换行字符('n')输出到标准输出流。

除外与bad() 同样的事态下会回到 true 以外,加上格式错误时也回到true ,例如当想要读入二个整数,而收获了一个假名的时候。

五、文件定位
  和C的文书操作格局各异的是,C++ I/O系统管理四个与叁个文件相挂钩的指针。三个是读指针,它表达输入操作在文件中的地方;另三个是写指针,它下一次写操作的地方。每便试行输入或输出时, 相应的指针自动生成。所以,C++的公文定位分为读地方和写地点的从来,对应的成员函数是 seekg()和 seekp(),seekg()是设置读地点,seekp是安装写地方。它们最通用的方式如下:

2、析取器(>>) 
从流中输入数据。比方说系统有三个默许的正经输入流(cin),平日情形下正是指的键盘,所以,cin>>x;就代表从专门的学问输入流中读取三个钦命项目(即变量x的品类)的多寡。

  • eof()

    istream &seekg(streamoff offset,seek_dir origin);
     ostream &seekp(streamoff offset,seek_dir origin);

在C++中,对文件的操作是通过stream的子类fstream(file stream)来兑现的,所以,要用这种办法操作文件,就非得参与头文件fstream.h。上边就把该类的公文操作进程一一道来。

假设读文件到达文件末尾,重回true。

  streamoff定义于 iostream.h 中,定义有偏移量 offset 所能取得的最大值,seek_dir 表示移动的原则地方,是多少个有以下值的枚举:

一、展开文件 
在fstream类中,有七个成员函数open(),就是用来开发文件的,其原型是:

  • good()

ios::beg:  文件早先
ios::cur:  文件当前地点
ios::end:  文件结尾
  那八个函数 日常用于二 进制文件,因为文件文件会因为系统对字符的阐述而大概与预期的值不相同。

void open(const char* filename,int mode,int access);

那是最通用的:即便调用以上任何三个函数再次回到true 的话,此函数重临 false 。

例:

参数:

要想重新设置以上成员函数所检查的意况标识,你能够运用成员函数clear(),未有参数。

     file1.seekg(1234,ios::cur);//把文件的读指针从前段时间岗位向后移1233个字节
     file2.seekp(1234,ios::beg);//把公文的写指针从文件开端向后移12三十一个字节

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

得到和装置流指针(get and put stream pointers)

开荒文件的习性取值是:

全部输入/输出流对象(i/o streams objects)都有最少一个流指针:

0:普通文书,张开访谈 
1:只读文件 
2:隐含文件 
4:系统文件 
可以用“或”也许“+”把上述属性连接起来 ,如3或1|2正是以只读和含有属性打开文件。

  • ifstream, 类似istream, 有二个被堪称get pointer的指针,指向下多少个将被读取的因素。
  • ofstream, 类似 ostream, 有两个指南针 put pointer ,指向写入下一个因素的职位。
  • fstream, 类似 iostream, 同一时间继续了get 和 put

诸如:以二进制输入情势张开文件c:config.sys

大家能够经过行使以下成员函数来读出或配备这几个指向流中读写地方的流指针:

fstream file1;
file1.open("c:config.sys",ios::binary|ios::in,0);
  • tellg() tellp()

假若open函数唯有文件名三个参数,则是以读/写普通文书展开,即:

那三个分子函数不用传入参数,再次回到pos_type 类型的值(依照ANSI-C++ 标准) ,便是一个卡尺头,代表当前get 流指针的岗位 (用tellg) 或 put 流指针的职分(用tellp).

file1.open("c:config.sys");<=>file1.open("c:config.sys",ios::in|ios::out,0);
  • seekg() 和seekp()

另外,fstream还也可能有和open()一样的构造函数,对于上例,在概念的时侯就足以展开文件了:

这对函数分别用来改换流指针get 和put的职位。七个函数都被重载为二种差异的原型:

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

seekg ( pos_type position ); seekp ( pos_type position );

特意建议的是,fstream有多个子类:ifstream(input file stream)和ofstream(outpu file stream),ifstream暗中同意以输入方式展开文件,而ofstream暗许以出口格局张开文件。

动用那么些原型,流指针被改成为指向从文件起首猜想的叁个纯属地方。供给传入的参数类型与函数 tellg 和tellp 的回来值类型一样。

ifstream file2("c:pdos.def");//以输入方式打开文件
ofstream file3("c:x.123");//以输出方式打开文件

seekg ( off_type offset, seekdir direction ); seekp ( off_type offset, seekdir direction );

故此,在事实上行使中,根据须要的分裂,选用不一致的类来定义:借使想以输入格局伸开,就用ifstream来定义;即便想以出口情势张开,就用ofstream来定义;假诺想以输入/输出格局来开采,就用fstream来定义。

动用那些原型能够内定由参数direction决定的一个具体的指针开首总计的叁个移动(offset)。它能够是:

二、关闭文件 
开发的文书使用到位后肯定要关门,fstream提供了成员函数close()来形成此操作,如:file1.close();就把file1相连的文件关闭。

ios::beg

从流开始位置计算的位移

ios::cur

从流指针当前位置开始计算的位移

ios::end

从流末尾处开始计算的位移

三、读写文件 
读写文件分为文本文件和二进制文件的读取,对于文本文件的读取相比较轻巧,用插入器和析取器就能够了;而对于二进制的读取就要复杂些,下要就详细的牵线那二种办法

流指针 get 和 put 的值对文件文件(text file)和二进制文件(binary file)的持筹握算格局都是例外的,因为文件方式的文本中一些特殊字符只怕被改动。由于那个缘故,提议对以文件文件方式张开的文件一而再利用seekg 和 seekp的首先种原型,何况不用对tellg 或 tellp 的重回值进行修改。对二进制文件,你能够随便使用这么些函数,应该不会有任何意外的行为爆发。

1、文本文件的读写 
文本文件的读写不会细小略:用插入器(<<)向文件输出;用析取器(>>)从文件输入。假使file1是以输入方式张开,file2以出口展开。示举例下:

以下例子使用那么些函数来博取三个二进制文件的轻重缓急:

file2<<"I Love You";//向文件写入字符串"I Love You"
int i;
file1>>i;//从文件输入一个整数值。

     // obtaining file size
      #include <iostream.h>
      #include <fstream.h>
     
      const char * filename =   "example.txt";
     
      int main () {
          long l,m;
          ifstream file (filename,   ios::in|ios::binary);
          l = file.tellg();
          file.seekg (0, ios::end);
          m = file.tellg();
          file.close();
          cout << "size of   " << filename;
          cout << " is "   << (m-l) << " bytes.n";
          return 0;
      }

size of example.txt is 40   bytes.

这种情势还应该有一种简易的格式化技艺,比如能够钦命输出为16进制等等,具体的格式有以下一些

 

操纵符 功能 输入/输出 
dec 格式化为十进制数值数据 输入和输出 
endl 输出八个换行符并刷新此流 输出 
ends 输出二个空字符 输出 
hex 格式化为十六进制数值数据 输入和出口 
oct 格式化为八进制数值数据 输入和出口 
setpxecision(int p) 设置浮点数的精度位数 输出

二进制文件(Binary files)

诸如要把123看作十六进制输出:file1<<hex<<123;要把3.1415926以5位精度输出:file1<<setpxecision(5)<<3.1415926。

在二进制文件中,使用<< 和>>,以及函数(如getline)来操作符输入和输出数据,未有怎么实际意义,即便它们是相符语法的。

2、二进制文件的读写 
①put() 
put()函数向流写入贰个字符,其原型是ofstream &put(char ch),使用也相比简单,如file1.put('c');便是向流写一个字符'c'。

文本流蕴含五个为顺序读写多少新鲜设计的积极分子函数:write 和 read。第二个函数 (write) 是ostream 的一个成员函数,都以被ofstream所承继。而read 是istream 的三个分子函数,被ifstream 所承接。类 fstream 的对象同有时候全部那七个函数。它们的原型是:

②get() 
get()函数相比较灵活,有3种常用的重载方式:

write ( char * buffer, streamsize size ); read ( char * buffer, streamsize size );

一种便是和put()对应的花样:ifstream &get(char &ch);作用是从流中读取一个字符,结果保存在援引ch中,如若到文件尾,重返空字符。如file2.get(x);表示从文件中读取二个字符,并把读取的字符保存在x中。

本文由必威发布于必威-编程,转载请注明出处:Stdout"和换行字符(' ')必威:输出到标准输出流,

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。