精华内容
下载资源
问答
  • 详细介绍了C++流操作之fstream用法,有需要的朋友可以参考一下
  • C++ fstream 用法

    2019-12-12 22:00:00
    fstream> #include <iostream> main() { int a,b,c,d; std::ifstream infile ("test.txt", std::ifstream::in); while (!infile.eof()) { infile >> a; infile >>...
    #include <fstream>
    #include <iostream>
    
    main()
    {
    	int a,b,c,d;
    	std::ifstream infile ("test.txt", std::ifstream::in);
    
    	while (!infile.eof())
    	{
    		infile >> a;
    		infile >> b;
    		infile >> c;
    		infile >> d;
    	}
    	std::cout << a << std::endl;
    }
    

    text.txt

     1 2   6                     5
    
    • 数字以空格(数量不限)分隔即可
    • 每运行一次infile >>, 读取位置跑到下一个数字
    展开全文
  • c++ fstream用法

    2018-11-22 17:02:09
    [导读]  ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是... 在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O.    stream这个类有两个...

    转载请保留原文链接:http://soft.chinabyte.com/database/460/11433960.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"
     

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

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

      操纵符 功能 输入/输出

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

    示例:

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

     

    void main( void )
    {
    //利用ofstream类的构造函数创建一个文件输出流对象来打开文件 
    ofstream fout( "d:\\mytest.txt" );  
    if ( ! fout)
    {
    cout << "文件不能打开" <<endl;
    }
    else
    {
    // 输出到磁盘文件
    fout << "Learning C++ is very useful."<< endl; 
    //关闭文件输出流
    fout.close();           

    //利用ifstream类的构造函数创建一个文件输入流对象
    ifstream fin( "d:\\mytest.txt" );   
    if ( ! fin)
    {
    cout << "文件不能打开" <<endl;
    }
    else
    {
    char buffer[80];  
                // 从磁盘文件输入
    fin >> buffer;  
    // 关闭文件输入流      
    fin.close();  
    cout << buffer << endl;
    }
    }
    ofstream file1;

    if (!file1)
    {
    cout << "文件不能打开" <<endl;
    }
    else
    {
            //open函数只有文件名一个参数,则是以读/写普通文件打开
    file1.open("d:\\mytest.txt");
    //相当于file1.open("d:\\mytest.txt",ios::out|ios::in,0);

    //文本文件的写:用插入器(<<)向文件输出.
            file1<<"写入文件操作!"<<endl;
                file1.close();
    }

    ifstream file2("d:\\mytest.txt");
    if (!file2)
    {
    cout << "文件不能打开" <<endl;

    else
    {
    char ch1[100];
    //文本文件的读:用析取器(>>)从文件输入.
    file2>>ch1;

    cout<<ch1<<endl;
    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!";

    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 字符串数据的输入

    数据多的时候读写速度比较快,输入时以整行字符串加上换行符号一次写入。读取的时候以语句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<<endl;

    }

    4 浮点数

    浮点数因为有小数点,在存储数据时与整数相同,只要每个数据加上一个空格就可以区隔相邻的数据

    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++)

    {

    n[0]=i+1;

    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 随机存取文件

    文件能够随意读出,读出后又可以更新,更新后可以回存到源文件内。fstream file ;

    file.open("文件名",存取模式);

    file.open("x.dat",ios::app|ios::in|ios::out|ios::binary);

    in 打开文件输入或者读取 ifstream

    out 打开文件输出或者写入 ofstream

    ate 从文件尾开始写入或者读取

    app 加在文件尾

    arunc 若文件存在,讲其长度设为0

    binary 打开二进制文件

    二进制文件中有一个指针,指向当前数据在文件中的位置,这个文件指针和一般的指针变量不一样,它只是一个纯粹的指示器。

    函数介绍

    seekg()

    seekg(0) 指针移到文件的最前面

    seekg(0,ios::cur);把当前的指针当作0

    seekg(0,ios::end);将指针移到文件尾,若再配合file.tellg()则可以求出文件的大小为多少bytes

    以下两个操作都必须在文件关闭后才可以使用

    remove("文件名”);把这个文件删除

    rename("旧文件名","新文件名");

     

    展开全文
  • C++ fstream 详解

    2020-12-18 23:54:55
    最近在写哈夫曼压缩,遇到了一个比较让人头疼的问题,那就是对文件的读写操作,尤其是以二进制的形式来读写,无奈C++Primer第五版上写的并不详细,很多让人困惑的地方没有涉及或者没有讲清楚。于是这几天我一直在...

    最近在写哈夫曼压缩,遇到了一个比较让人头疼的问题,那就是对文件的读写操作,尤其是以二进制的形式来读写,无奈C++Primer第五版上写的并不详细,很多让人困惑的地方没有涉及或者没有讲清楚。于是这几天我一直在网上看了很多这方面相关的文章,同时自己也在电脑上试了很多,觉得理解了不少,很多困惑也迎刃而解。

    我们都知道,C语言里面对文件的操作是通过文件指针,以及一些相关的函数,那么C++中是如何对文件进行操作的呢?没错,就是通过 fstream 这个文件流来实现的。第一次听到文件流这个名字时,我也是一脸懵逼,总感觉这东西太抽象了,其实我们可以简单地把它理解成一个类,这样是不是清楚多了,当我们使用#include 时,我们就可以使用其中的 ifstream,ofstream以及fstream 这三个类了,也就可以用这三个类来定义相应的对象了,例如:

    ifstream fin();

    这样我们就定义了一个叫做fin的对象了,它就和我们自己定义的其他对象一样,可以调用ifstream类中的一些函数,可以使用ifstream类中定义的一些操作符等等。那么我们定义完这个对象后,怎么和某个文件关联起来呢?毕竟我们最终是希望它能帮我们实现对文件的操作。没错,我们可以调用它的一个成员函数来实现,如下:

    fin.open("test.txt");

    open()这个成员函数重载了好几种形式,上面这种是最简单的,它中间的参数是一个常量字符指针,你可以填入所要打开文件的相对路径(比如和你的.cpp文件在同一目录下你就可以直接输入文件名,注意必须是完整的文件名,包含文件拓展名,否则找不到这个文件的),也可以填入绝对路径(比如 "D:\CodeBlocks\Myprojects\0407test\test.txt"),当然,你也可以填入一个指向文件名字符串的指针常量,或者内容等于文件名的string常量,例如:

    const char * c = "test.txt";

    fin.open(c);

    或者

    const string s = "test.txt";

    fin.open(s);

    注意必须是指向常量的指针或string

    如果不是const string 那么得这样用

    string s = "test.txt";

    fin.open(str.c_str()); 这里的c_str()是 string 的一个成员函数,作用就是变成一个const string ,其实也就相当于上面的了

    另外,open()函数里还可以加上其他参数,例如打开的方式,等等。但是文件名是最基本的一个,如果其他参数未加,将使用缺省值,这个函数的声明,

    void open ( const char *filename,

    ios_base::openmode mode= ios_base::in | ios_base::out);void open(const wchar_t *_Filename,

    ios_base::openmode mode= ios_base::in | ios_base::out,int prot = ios_base::_Openprot);

    参数:

    filename    操作文件名

    mode        打开文件的方式

    prot          打开文件的属性   //基本很少用到,在查看资料时,发现有两种方式

    ios::in

    为输入(读)而打开文件

    ios::out

    为输出(写)而打开文件

    ios::ate

    初始位置:文件尾

    ios::app

    所有输出附加在文件末尾

    ios::trunc

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

    ios::binary

    二进制方式

    这些方式是能够进行组合使用的,以“或”运算(“|”)的方式,例如:

    fin.open("test.txt", ios::in|ios::out|ios::binary)

    另外,这个类有一个构造函数允许我们在定义流对象的时候以文件名初始化,如下:

    ifstream fin("test.txt");

    ifstream fin("test.txt",ios::in);

    const string s = "test.txt";

    ifstream fin(s,ios::in);

    ofstream,ftream和上面是类似的,就不详细展开了

    接下来说说几个重要的函数,

    一个是成员函数is_open(),可以判断文件是否正确打开,如果是,返回true,否则,返回false。

    然后是getline()函数,这个函数是按行读取txt中的内容,示例如下

    ifstream fin("test.txt",ios::in);strings;while(getline(fin,s))

    cout<< s;//输出每一行

    每次从fin指向的文件中读取一行,一行之中的所有字符都会被读入,包括空格。但是结尾的空格不读入,回车换行也不读入。

    我们知道,所有输入/输出流对象(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)。它可以是:

    ios::beg 从流开始位置计算的位移

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

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

    文本中的字符是从position = 0开始的,例如

    //假设test.txt中的内容是HelloWorld

    ifstream fin("test.txt",ios::in);

    cout<< fin.tellg();//输出0,流置针指向文本中的第一个字符,类似于数组的下标0

    charc;

    fin>>c;

    fin.tellg();//输出为1,因为上面把fin的第一个字符赋值给了c,同时指针就会向后 移动一个字节(注意是以一个字节为单位移动)指向第二个字符

    fin.seekg(0,ios::end);//输出10,注意最后一个字符d的下标是9,而ios::end指向的是最后一个字符的下一个位置

    fin.seekg(10,ios::beg);//和上面一样,也到达了尾后的位置//我们发现利用这个可以算出文件的大小

    intm,n;

    m= fin.seekg(0,ios::beg);

    n= fin.seekg(0,ios::end);//那么n-m就是文件的所占的字节数

    我们也可以从文件末尾出发,反向移动流指针,

    fin.seekg(-10,ios::end);//回到了第一个字符

    tellp()以及seekp()的用法类似

    顺便讲一下 << 以及 >> 这两个操作符

    由于ifstream以及ofstream分别继承于istream和ostream,所以他们也分别继承了相应的运算符,这就是为什么我们可以有下面这种操作的原因了:

    ifstream fin("test.txt");

    char c;

    fin >> c;

    这其实和我们从控制台读取文件是一个道理,我们利用istream 中的对象cin 和其中的操作符 >> 来从控制台读取数据

    这里我们用fin对象和 >> 操作符来从相应的文件中读取数据,相当于流的方向从控制台改变到文件中去了

    不过这里应该要注意一下 >> 这个操作符的特点,有如下例子:

    假如test.txt中的内容是Hello World

    ifstream fin("test.txt");

    string s;

    fin >> s;

    cout << s;

    我们发现输出并不是Hello World,而是Hello,这是为什么呢?

    几番试验后,我们发现,文件的每个空白之后, ">>" 操作符会停止读取内容, 直到遇到另一个>>操作符. 因为我们读取的每一行都被换行符分割开(是空白字符), ">>" 操作符只把这一行的内容读入变量。这就是这个代码也能正常工作的原因。如果你想把整行读入一个char数组, 我们没办法用">>"?操作符,因为每个单词之间的空格(空白字符)会中止文件的读取。为了验证,有如下示例:

    char  c[20] ;

    fin >> c;

    我们想包含整个句子, 所以当我们想读取整行时,我们得用上面提到的getline()。这就是我们要做的:

    fin.getline(c, 20);

    cout << c;

    这是函数参数. 第一个参数显然是用来接受的char数组. 第二个参数是在遇到换行符之前,数组允许接受的最大元素数量

    现在我们得到了想要的结果:Hello World。

    或者这样用也行:

    string s;

    getline(fin,s);

    cout << s;

    注意这样操作后流指针会指向文件的尾后

    接下来说说本文的重点了,那就是以二进制的形式读写文件

    这里的重点就是两个函数的使用,分别是read()和write()函数

    二进制文件会复杂一点, 但还是很简单的。 首先你要注意我们不再使用插入和提取操作符(译者注:<< 和 >> 操作符). 你可以这么做,但它不会用二进制方式读写。你必须使用read() 和write() 方法读取和写入二进制文件. 创建一个二进制文件, 看下一行。

    ofstream fout("file.dat", ios::binary);

    这会以二进制方式打开文件, 而不是默认的ASCII模式。首先从写入文件开始。函数write() 有两个参数。 第一个是指向对象的char类型的指针, 第二个是对象的大小(译者注:字节数)。 为了说明,看例子:

    int number = 30;

    fout.write((char *)(&number), sizeof(number));

    第一个参数写做"(char *)(&number)". 这是把一个整型变量转为char *指针。如果你不理解,可以立刻翻阅C++的书籍,如果有必要的话。

    第二个参数写作"sizeof(number)". sizeof() 返回对象大小的字节数. 就是这样!

    这样就写入了整个结构! 接下来是输入. 输入也很简单,因为read()函数的参数和 write()是完全一样的, 使用方法也相同。

    ifstream fin("file.dat", ios::binary);

    fin.read((char *)(&obj), sizeof(obj));

    我不多解释用法, 因为它和write()是完全相同的。二进制文件比ASCII文件简单, 但有个缺点是无法用文本编辑器编辑。 接着, 我解释一下ifstream 和ofstream 对象的其他一些方法作为结束.

    参考文章:

    展开全文
  • c++中有个类叫做fstream,可以实现打开一个文件作为流。创建一个对象,然后调用该对象的open函数,其主要有两个参数,第一个参数是字符串,表示文件的地址,第二个参数是代开方式,如: fstream fin(a.txt,ios::in)...
  • C++fstream用法

    千次阅读 2014-12-04 14:50:12
    C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符: 1、插入器( 2、析取器(>>) 从流中输入数据。比如说系统有一个默认的标准输入...

    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<<hex<<123;要把3.1415926以5位精度输出:file1<<setpxecision(5)<<3.1415926。

    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个字节

    fstream的用法

    开一个文件 fstream f; f.open("1.txt", ios::in | ios::binary); if (!f.is_open()) // 检查文件是否成功打开 cout << "cannot open file." << endl; ios::in与ios::bianry均为int型,定义文件打开的方式。 ios::in -- 打开文件用于读。 ios::out -- 打开文件用于写,如果文件不存在,则新建一个;存在则清空其内容。 ios::binary -- 以二进制bit流方式进行读写,默认是ios::text,但最好指定这种读写方式,即使要读写的是文本。因为在ios::text模式下,在写入时'\ n'字符将转换成两个字符:回车+换行(HEX: 0D 0A) 写入,读入时作逆转换,这容易引起不必要的麻烦。 ios::app -- 打开文件在文件尾进行写入,即使使用了seekp改变了写入位置,仍将在文件尾写入。 ios::ate -- 打开文件在文件尾进行写入,但seekp有效。

    读写位置的改变 f.seekg(0, ios::beg); // 改变读入位置 g mean Get f.seekp(0, ios::end); // 改变写入位置 p mean Put 第一个参数是偏移量offset(long),第二个参数是offset相对的位置,三个值: ios::beg -- 文件头 ios::end -- 文件尾 ios::cur -- 当前位置

    文件读写 char s[50]; f.read(s, 49); s[50] = '\0'; // 注意要自己加上字符串结束符

    char *s = "hello"; f.write(s, strlen(s));

    补充 记得读写完成后用f.close()关闭文件。

    例子 下面的程序用于删除带有行号的源程序中的行号。

    #include <iostream>
    #include <fstream>
    using namespace std;
    
    //定义要删除的行号格式,下面定义的是型如: #0001 的行号
    const int LINE_NUM_LENGTH = 5;
    const char LINE_NUM_START = '#';
    
    int main(int argc, char *argv[])
    {
        fstream f;
        char *s = NULL;
        int n;
        for (int i = 1; i < argc; i++)
        {
            cout << "Processing file " << argv[i] << "......";
            f.open(argv[i], ios::in | ios::binary);
            if (!f.is_open())
            {
                cout << "CANNOT OPEN"<< endl;
                continue;
            }
            f.seekg(0, ios::end);
            n = f.tellg(); // 文件大小
            s = new char[n+1];
            f.seekg(0, ios::beg);
            f.read(s, n);
            s[n] = '\0';
            f.close();
            // 采用一种简单的判断,遇到LINE_NUM_START后接一个数字,
            // 则认为它是一个行号.
            for (int j = 0; j < n; j++)
            {
                if (s[j] == LINE_NUM_START &&
                (s[j+1] >= '0' && s[j+1] <= '9'))
                {
                    for (int k = j; k < j + LINE_NUM_LENGTH; k++)
                        s[k] = ' ';
                }
            }
    
            f.open(argv[i], ios::out | ios::binary);
            if (!f.is_open())
            {
                cout << "CANNOT OPEN" << endl;
                delete[] s;
                continue;
            }
            f.write(s, n);
            f.close();
            cout << "OK" << endl;
            delete[] s;
        }
        return 0;
    }
    展开全文
  • c++ fstream类详解

    2021-01-11 20:57:07
    C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,一,c++ 文件流的结构:‍1,几个文件流类名称:fstream,ifstream,ofstream,iofstream2,之间的关系:ifstream(input file stream)和ofstream...
  • C++ fstream详解

    2020-06-23 21:39:29
    当我们使用#include 时,我们就可以使用其中的 ifstream,ofstream以及fstream 这三个类了(ifstream是从硬盘到内存,ofstream是从内存到硬盘),也就可以用这三个类来定义相应的对象了,这三个类分别代表一个输入文件...
  • [c++] fstream使用方法

    2020-12-18 23:54:55
    C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符:1、插入器(<向流输出数据。比如说系统有一个默认的标准输出流(cout),一般情况下...
  • C++fstream使用

    万次阅读 多人点赞 2016-06-02 22:36:08
    C++fstream使用
  • C++fstream使用方法

    千次阅读 2018-06-11 10:57:14
    1)C++中的三个流文件 ofstream  ofs("文件名",打开方式); ifstream  ifs("文件名",打开方式); fstream  fs("文件名",输入打开方式 | 输出打开方式); 三种文件方式分别用于读...
  • // 读取Text文件中的内容 //并将结果保存在 str中。 void QtWidgetsApplication1::readFile() { char data[100]; vector<string> str; ifstream infile; infile.open("F:/text.txt");... // 一.
  • 讲解文件操作的类fstream 并对ifstream和ofstream一并做讲解
  • c++fstream用法实例

    2019-07-16 20:05:39
    #include <fstream> using namespace std; int main(){ ifstream fin("test.DAT"); ofstream fout_imu("imu.DAT"); ofstream fout_ipv("ipv.DAT"); if(!fin.is_open()) { cout !" ; return -1; } string ...
  • c++fstream使用方法

    2020-06-24 16:53:30
    fstream使用方法 ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间; 在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O,stream这个类...
  • C++fstream使用

    2019-10-23 15:45:04
    # include <fstream> using namespace std ;...fstream 是给文件中(文件...打开的文件使用完成后一定要关闭,fstream提供了成员函数close()来完成此操作,如操作完文件不关闭文件可能会导致文件里的数据丢失。
  • c++ fstream用法(2)

    2018-05-21 16:49:00
    一> 1 #include "stdafx.h" 2 #include<iostream> 3 #include<string>...fstream> 5 using namespace std; 6 7 class Rectangle 8 { 9 private: 10 doub...
  • fstream用法总结 C++

    万次阅读 2016-09-01 15:20:28
    C++中输入输出到指定文件,或者从指定文件中读出数据使用fstream类较为方便。 1.将数据写到磁盘的指定文件中 首先第一步是加头文件#include ,引入库函数 第二步,声明一个ofstream对象,调用ofstream的成员函数...
  • C++ 使用 fstream 创建输出文件

    千次阅读 2018-04-03 09:28:42
    C++ 使用 fstream 创建输出文件 在C++文件操作中,我们可能想先创建一个文件,然后向其中写入内容。本文介绍一种可以用于创建文件并向其中写入内容的方法。 代码如下: #include &lt;fstream&gt; using...
  • C++中文件流(fstream)的使用方法及示例

    万次阅读 多人点赞 2012-07-30 15:48:14
    C++文件流: fstream // 文件流 ifstream // 输入文件流 ofstream // 输出文件流     #include //创建一个文本文件并写入信息 //同向屏幕上输出信息一样将信息输出至文件 #include #include...
  • c++-fstream使用

    千次阅读 2016-10-22 10:08:00
    C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符:1、插入器()  向流输出数据。比如说系统有一个默认的标准输出流(cout),一般情况下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,502
精华内容 5,400
关键字:

c++fstream用法

c++ 订阅