精华内容
下载资源
问答
  • 如果采用C++,首先想到的就是文件流fstream。虽然在COM层面上,我们还可以使用IStream来实现文件的读写,其效率也非常高。不过本文仅对C++流操作做简单的探讨,相比于Windows API或IStream,C++的流操作通用性更好...
  • 因此,如果调用fstream.Reader('/some/symlink')则将获得一个对象,该对象将进行统计,然后立即结束(因为它没有数据)。 要遵循符号链接,请执行以下操作: fstream.Reader({path:'/some/symlink', follow: true }...
  • fstream文件读写

    2018-06-02 14:57:18
    C++ iostream对文件流操作,实现文件读写,简单方便。
  • 嵌入式Linux下QT程序设计;主要内容;输入/输出标准流类 ;所谓流是指数据从一个对象流向另一个对象在C++程序中数据可以从键盘流入到程序中也可以从程序中流向屏幕或磁盘文件把数据的流动抽象为流流在使用前要被建立...
  • fstream头文件

    2019-07-04 11:18:40
     在C++中,对文件的操作是通过stream的子类fstream(file stream)来实现的,所以,要用这种方式操作文件,就必须加入头文件fstream.h。 常见的文件操作: 1  一、打开文件  在fstream类中,有一个成员函数...

    原文出自【比特网】,转载请保留原文链接:http://soft.chinabyte.com/database/460/11433960.sh

    [导读]

     ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间
    
    
    在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O.
    
    
    
    stream这个类有两个重要的运算符:
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

      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: 以二进制方式打开文件,缺省的方式是文本方式。两种方式的区别见前文
      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有两个子类:
    
     
    • 1

    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();
    }
    }
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70

      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++中输出和输入导屏幕和键盘的类别声明包含再标题文件

    #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)
    例如:
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    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

    展开全文
  • fstream读写文件

    2021-01-05 11:01:47
    1.fstream是什么? fstream是C++标准库中面向对象库的一个,用于操作流式文件。 fstream本质上是一个class,提供file操作的各种方法。 2.关系图 basic_fstream是一个类模板,暂且不用深入理解它。我们关心的事,它...

    1.fstream是什么?

    fstream是C++标准库中面向对象库的一个,用于操作流式文件。
    fstream本质上是一个class,提供file操作的各种方法。

    2.关系图

    在这里插入图片描述
    basic_fstream是一个类模板,暂且不用深入理解它。我们关心的事,它前面继承的那一堆东西。

    fstream是basic_fstream<char>的一个模板类,也就说明,fstream也继承了一堆东西。

    我们再关心一下从 ios_base基类,重点继承了什么?文件流的打开模式。
    在这里插入图片描述

    3.实验

    3.1 打开/创建文件

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

    #include <iostream>
    #include <fstream>
    using namespace std;
    int main()
    {
        fstream fs;
        cout << "hello" << endl;
        fs.open("d://zhou");    
        if (fs.is_open())
        {
            cout << "open success" << endl;
        }
        else
        {
            cout << "open failed" << endl;
        }
        system("pause");
        return 0;
    }
    

    输出结果
    在这里插入图片描述
    打开失败了。
    说明不能自动创建不存在的文件。

    修改fs.open("d://zhou");fs.open("d://zhou", ios_base::in); ,即只读的方式打开。
    运行后,文件依旧不能被创建。

    修改fs.open("d://zhou");fs.open("d://zhou", ios_base::out); ,即只写的方式打开。
    运行后,文件在D盘被创建了。
    在这里插入图片描述在这里插入图片描述
    所以,想要打开一个不存的文件,并且创建它,必须包含 ios_base::out模式。

    3.2 写文件 write()

    basic_ostream& write( const char_type* s, std::streamsize count );
    它是继承于ostream类

    #include <iostream>
    #include <fstream>
    using namespace std;
    int main()
    {
        char str[] = "hello world";
        fstream fs;
        cout << "hello" << endl;
        fs.open("d://zhou.txt", ios_base::out); 
        if (fs.is_open())
        {
            cout << "open success" << endl;
        }
        else
        {
            cout << "open failed" << endl;
        }
        
        fs.write(str, sizeof(str) - 1);  //写入内容
        //fs << str << endl;
        
        system("pause");
    
        return 0;
    }
    

    实验结果
    在这里插入图片描述
    写入有两种方式,一种是使用 fs.write,另一种是使用 << 流操作符号。流操作符号本质也是调用了write方法。

    3.3 读文件 read()

    basic_istream& read( char_type* s, std::streamsize count );
    它是继承于istream类。

    #include <iostream>
    #include <fstream>
    using namespace std;
    int main()
    {
        char str[] = "hello world";
        char rstr[128] = {0};
        fstream fs;
    
        cout << "hello" << endl;
    
        fs.open("d://zhou.txt", ios_base::out | ios_base::in); 
        if (fs.is_open())
        {
            cout << "open success" << endl;
        }
        else
        {
            cout << "open failed" << endl;
        }
    
        fs.write(str, sizeof(str) - 1);  //写入
        fs.sync();                       //写入硬盘
        fs.seekg(ios_base::beg);         //文件指针的位置回到开头
        fs.read(rstr, sizeof(rstr));     //读数据
    
        cout << rstr << endl;
    
        fs.close();
        system("pause");
    
        return 0;
    }
    

    实验结果
    在这里插入图片描述
    写入"hello word" 再读出来。
    咦?怎么读一个数据不是只调用read就行吗?怎么多了好几个?
    因为…
    fs.write()是将内容写入缓冲区(内存)。fs.sync() 是为了将缓冲区的内容刷新写入硬盘。而read方法是只能读取硬盘上的内容,读不了缓冲区。
    fs.seekg()则是将文件的指针回到开头。当为了写入之后,文件指针指向了末尾了。调用read时候,也就会从末尾读,啥也读不出来。

    3.4 读文件 getline()

    读文件的操作,getlineread更加常用。
    getline一读就一整行了。
    getline的内容实现也是依靠read方法(c语言是这样,c++可能也是这样)。

        while (!fs.eof()) 
        {
            fs.getline(rstr, sizeof(rstr));     //读数据
            cout << rstr << endl;
        }
    

    fs.eof()是为了判断是否到达末尾,若抵达末尾,返回true,否则false。

    实验结果
    在这里插入图片描述

    4.最后

    fstream的方法何其之多,掌握比较常用的即可。许多操作跟C语言类似。
    学习C++最重要的技能之一是学会查找文档。
    中文手册:https://www.apiref.com/cpp-zh/cpp.html
    英文手册:http://www.cplusplus.com/reference/

    在这里插入图片描述

    展开全文
  • 嵌入式Linux下C++程序设计--流类库iostream,fstream.pdf
  • VC2003之后这两个头文件没有了,但是目前通过vc编译的帧需要这两个头文件,本人用作以太网帧的传输,供大家参考
  • C++ fstream详解

    万次阅读 多人点赞 2019-01-28 15:13:38
    没错,就是通过 fstream 这个文件流来实现的。当我们使用#include 时,我们就可以使用其中的 ifstream,ofstream以及fstream 这三个类了(ofstream是从内存到硬盘,ifstream是从硬盘到内存),也就可以用这三个类来定义...

    C语言里面对文件的操作是通过文件指针,以及一些相关的函数,那么C++中是如何对文件进行操作的呢?没错,就是通过 fstream 这个文件流来实现的。当我们使用#include 时,我们就可以使用其中的 ifstream,ofstream以及fstream 这三个类了(ofstream是从内存到硬盘,ifstream是从硬盘到内存),也就可以用这三个类来定义相应的对象了,这三个类分别代表一个输入文件,一个输出文件,以及一个输入输出文件。Ifstream类支持>>操作符,ofstream类支持<<操作符,fstream类同时支持>>和<<操作符。

    C语言文件操作

    函数 fopen()将一个文件和一个流关联起来,并初始化一个类型为 FILE 的对象,该对象包含了控制该流的所有信息。这些信息包括指向缓冲区的指针;文件位置指示器,它指定了获取文件的位置;以及指示错误和文件结尾情况的标志。
    每个用于打开文件的函数(也就是 fopen()、freopen()和 tmpfile())都会返回一个指向 FILE 对象的指针,该 FILE 对象包含与被打开文件相关联的流。一旦打开了文件,就可以调用函数传递数据并对流进行处理。这些函数都把指向 FILE 对象的指针(通常称为 FILE 指针)作为它们的参数之一。FILE 指针指定了正在进行操作的流

    FILE *fopen( const char * restrict filename,const char * restrict mode );
    FILE *freopen(const char * restrict filename,
                      const char * restrict mode,
                      FILE * restrict stream );
    FILE *tmpfile( void );
    

    所有三个打开文件的函数 fopen()、freopen()和 tmpfile(),都会返回一个指针。如果成功,该指针就指向已打开的流,如果失败,该指针就为空指针

    #include <stdio.h>
    #include <stdbool.h>
    _Bool isReadWriteable( const char *filename )
    {
      FILE *fp = fopen( filename, "r+" );   // 打开一个文件以用于读写
      if ( fp != NULL )                             // fopen()是否执行成功
      {
        fclose(fp);                                 // 成功:关闭文件,没有错误需要处理
        return true;
      }
      else                                          // 失败
        return false;
    }
    

    关闭文件时需要使用函数 fclose()

    int fclose( FILE *fp );
    

    正常返回:0。
    异常返回:EOF,表示文件在关闭时发生错误。

    C++文件操作

    1.直接使用流对象进行文件的操作,默认方式如下:

    ofstream out("...", ios::out);
    ifstream in("...", ios::in);
    fstream foi("...", ios::in|ios::out);
    

    文件写操作

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

    文件读操作

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

    2.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 打开文件的属性 //基本很少用到,在查看资料时,发现有两种方式

    **打开文件的方式(mode ): **

    ios::app:    //以追加的方式打开文件  
    ios::ate:    //文件打开后定位到文件尾,ios:app就包含有此属性  
    ios::binary:  //以二进制方式打开文件,缺省的方式是文本方式。两种方式的区别见前文  
    ios::in:     //文件以输入方式打开(文件数据输入到内存)  
    ios::out:    //文件以输出方式打开(内存数据输出到文件)  
    ios::nocreate: //不建立文件,所以文件不存在时打开失败  
    ios::noreplace://不覆盖文件,所以打开文件时如果文件存在失败  
    ios::trunc:   //如果文件存在,把文件长度设为0
    

    打开文件的属性取值(prot ):

    0:普通文件,打开访问  
    1:只读文件  
    2:隐含文件  
    4:系统文件 
    可以用“或”或者“+”把以上属性连接起来,如3或1|2就是以只读和隐含属性打开文件
    

    状态标志符:

    除了eof()以外,还有一些验证流的状态的成员函数(所有都返回bool型返回值):

    is_open():文件是否正常打开
    bad():读写过程中是否出错(操作对象没有打开,写入的设备没有空间)
    fail():读写过程中是否出错(操作对象没有打开,写入的设备没有空间,格式错误--比如读入类型不匹配)
    eof():读文件到达文件末尾,返回true
    good():以上任何一个返回true,这个就返回false
    

    要想重置以上成员函数所检查的状态标志,你可以使用成员函数clear(),没有参数

    获得和设置流指针

    - 对于所有的输入输出流都有至少一个指针,指向下一个要操作的位置
    
    ofstream  put_point
    
    ifstream  get_point
    
    fstream  put_point和get_point
    
    - 获取流指针位置
    
    tellg(): 返回输入流指针的位置(返回类型long)
    
    tellp(): 返回输出流指针的位置(返回类型long)
    
    - 设置指针位置
    
    seekg(long  position):  设置输入流指针位置为第position个字符(文件首位置为开始位置)
    
    seekp(long  position):  设置输出流指针到指定位置
    
    // position in output stream
    #include <fstream>      // std::ofstream
    
    int main () {
    
      std::ofstream outfile;
      outfile.open ("test.txt");
    
      outfile.write ("This is an apple",16);
      long pos = outfile.tellp();
      outfile.seekp (pos-7);
      outfile.write (" sam",4);
    
      outfile.close();
    
      return 0;
    }
    

    seekg ( off_type offset, seekdir direction );
    seekp ( off_type offset, seekdir direction );
    使用这个原型可以指定由参数direction决定的一个具体的指针开始计算的一个位移(offset)。它可以是:

    ios::beg 从流开始位置计算的位移
    ios::cur 从流指针当前位置开始计算的位移
    ios::end 从流末尾处开始计算的位移

    //假设test.txt中的内容是HelloWorld
    ifstream fin("test.txt",ios::in);
    cout << fin.tellg();//输出0,流置针指向文本中的第一个字符,类似于数组的下标0
    
    char c;
    fin >> c;
    fin.tellg();//输出为1,因为上面把fin的第一个字符赋值给了c,同时指针就会向后 移动一个字节(注意是以一个字节为单位移动)指向第二个字符
    
    fin.seekg(0,ios::end);//输出10,注意最后一个字符d的下标是9,而ios::end指向的是最后一个字符的下一个位置
    
    fin.seekg(10,ios::beg);//和上面一样,也到达了尾后的位置
    
    //我们发现利用这个可以算出文件的大小
    
    int m,n;
    m = fin.seekg(0,ios::beg);
    n =  fin.seekg(0,ios::end);
    //那么n-m就是文件的所占的字节数
    
    我们也可以从文件末尾出发,反向移动流指针,
    fin.seekg(-10,ios::end);//回到了第一个字符
    

    读取文件内容:

    // print the content of a text file.
    #include <iostream>     // std::cout
    #include <fstream>      // std::ifstream
    
    int main () {
      std::ifstream ifs;
    
      ifs.open ("test.txt", std::ifstream::in);
    
      char c = ifs.get();
    
      while (ifs.good()) {
        std::cout << c;
        c = ifs.get();
      }
    
      ifs.close();
    
      return 0;
    }
    

    使用重载的’<<’ 或者 ‘>>’, 也可以使用成员函数来实现

    #include <fstream>
    using namespace std;
    
    int main ()
    {
        ifstream fr;
        ofstream fw;
        char word[200], line[200];
        
        fw.open("write.txt");
        fr.open("read.txt");
        
        fr  >> word;    //读取文件,一个单词
        fr.getline (line, 100);        //读取一行内容
        
        fw << "write file test" << endl;
        
        fw.close();
        fr.close();
        
        return 0;
    }
    

    参考:
    http://www.cplusplus.com/reference/fstream/ifstream/open/

    https://www.cnblogs.com/journal-of-xjx/p/6679663.html

    https://www.cnblogs.com/alihenaixiao/p/6429854.html

    展开全文
  • fstream详解

    千次阅读 2018-06-27 15:43:23
    在看C++编程思想中,每个练习基本都是使用ofstream,ifstream,fstream,以前粗略知道其用法和含义,在看了几位大牛的博文后,进行整理和总结:这里主要是讨论fstream的内容:#include &lt;fstream&gt;...

    原地址:https://blog.csdn.net/kingstar158/article/details/6859379

    在看C++编程思想中,每个练习基本都是使用ofstream,ifstream,fstream,以前粗略知道其用法和含义,在看了几位大牛的博文后,进行整理和总结:






    这里主要是讨论fstream的内容:


    #include <fstream>
    ofstream         //文件写操作 内存写入存储设备 
    ifstream         //文件读操作,存储设备读区到内存中
    fstream          //读写操作,对打开的文件可进行读写操作 
    1.打开文件


    在fstream类中,成员函数open()实现打开文件的操作,从而将数据流和文件进行关联,通过ofstream,ifstream,fstream对象进行对文件的读写操作


    函数:open()




    public member function


    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类(所以流式I/O的基类)中定义,有如下几种方式:


    ios::in 为输入(读)而打开文件
    ios::out 为输出(写)而打开文件
    ios::ate 初始位置:文件尾
    ios::app 所有输出附加在文件末尾
    ios::trunc 如果文件已存在则先删除该文件
    ios::binary 二进制方式
    这些方式是能够进行组合使用的,以“或”运算(“|”)的方式:例如
    ofstream out;
    out.open("Hello.txt", ios::in|ios::out|ios::binary)                 //根据自己需要进行适当的选取
    打开文件的属性同样在ios类中也有定义:
    0 普通文件,打开操作
    1 只读文件
    2 隐含文件
    4 系统文件
    对于文件的属性也可以使用“或”运算和“+”进行组合使用,这里就不做说明了。
    很多程序中,可能会碰到ofstream out("Hello.txt"), ifstream in("..."),fstream foi("...")这样的的使用,并没有显式的去调用open()函数就进行文件的操作,直接调用了其默认的打开方式,因为在stream类的构造函数中调用了open()函数,并拥有同样的构造函数,所以在这里可以直接使用流对象进行文件的操作,默认方式如下:




    ofstream out("...", ios::out);
    ifstream in("...", ios::in);
    fstream foi("...", ios::in|ios::out);


    当使用默认方式进行对文件的操作时,你可以使用成员函数is_open()对文件是否打开进行验证
    2.关闭文件


    当文件读写操作完成之后,我们必须将文件关闭以使文件重新变为可访问的。成员函数close(),它负责将缓存中的数据排放出来并关闭文件。这个函数一旦被调用,原先的流对象就可以被用来打开其它的文件了,这个文件也就可以重新被其它的进程所访问了。为防止流对象被销毁时还联系着打开的文件,析构函数将会自动调用关闭函数close。






    3.文本文件的读写


    类ofstream, ifstream 和fstream 是分别从ostream, istream 和iostream 中引申而来的。这就是为什么 fstream 的对象可以使用其父类的成员来访问数据。


    一般来说,我们将使用这些类与同控制台(console)交互同样的成员函数(cin 和 cout)来进行输入输出。如下面的例题所示,我们使用重载的插入操作符<<:


         // writing on a text file
        #include <fiostream.h>
        int main () {
            ofstream out("out.txt");
            if (out.is_open()) 
           {
                out << "This is a line.\n";
                out << "This is another line.\n";
                out.close();
            }
            return 0;
        }
       //结果: 在out.txt中写入:
       This is a line.
       This is another line 
    从文件中读入数据也可以用与 cin>>的使用同样的方法:


     // reading a text file
        #include <iostream.h>
        #include <fstream.h>
        #include <stdlib.h>
        
        int main () {
            char buffer[256];
            ifstream in("test.txt");
            if (! in.is_open())
            { cout << "Error opening file"; exit (1); }
            while (!in.eof() )
            {
                in.getline (buffer,100);
                cout << buffer << endl;
            }
            return 0;
        }
        //结果 在屏幕上输出
         This is a line.
         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)。它可以是:


    ios::beg 从流开始位置计算的位移
    ios::cur 从流指针当前位置开始计算的位移
    ios::end 从流末尾处开始计算的位移
    流指针 get 和 put 的值对文本文件(text file)和二进制文件(binary file)的计算方法都是不同的,因为文本模式的文件中某些特殊字符可能被修改。由于这个原因,建议对以文本文件模式打开的文件总是使用seekg 和 seekp的第一种原型,而且不要对tellg 或 tellp 的返回值进行修改。对二进制文件,你可以任意使用这些函数,应该不会有任何意外的行为产生。


    以下例子使用这些函数来获得一个二进制文件的大小: 


     // obtaining file size
        #include <iostream.h>
        #include <fstream.h>
        
        const char * filename = "test.txt";
        
        int main () {
            long l,m;
            ifstream in(filename, ios::in|ios::binary);
            l = in.tellg();
            in.seekg (0, ios::end);
            m = in.tellg();
            in.close();
            cout << "size of " << filename;
            cout << " is " << (m-l) << " bytes.\n";
            return 0;
        }
       
       //结果:
       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)中读出或写入的字符数。




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


    5.缓存和同步(Buffers and Synchronization)


    当我们对文件流进行操作的时候,它们与一个streambuf 类型的缓存(buffer)联系在一起。这个缓存(buffer)实际是一块内存空间,作为流(stream)和物理文件的媒介。例如,对于一个输出流, 每次成员函数put (写一个单个字符)被调用,这个字符不是直接被写入该输出流所对应的物理文件中的,而是首先被插入到该流的缓存(buffer)中。


    当缓存被排放出来(flush)时,它里面的所有数据或者被写入物理媒质中(如果是一个输出流的话),或者简单的被抹掉(如果是一个输入流的话)。这个过程称为同步(synchronization),它会在以下任一情况下发生:


    当文件被关闭时: 在文件被关闭之前,所有还没有被完全写出或读取的缓存都将被同步。
    当缓存buffer 满时:缓存Buffers 有一定的空间限制。当缓存满时,它会被自动同步。
    控制符明确指明:当遇到流中某些特定的控制符时,同步会发生。这些控制符包括:flush 和endl。
    明确调用函数sync(): 调用成员函数sync() (无参数)可以引发立即同步。这个函数返回一个int 值,等于-1 表示流没有联系的缓存或操作失败。
    展开全文
  • 文件输入输出类
  • Fstream: Managing Flash Sreams in the File System PPT
  • C++ fstream文件流读 中字符串string与b VB ListView控件各种
  • node-fstream-源码

    2021-05-07 13:13:51
    因此,如果调用fstream.Reader('/some/symlink')则将获得一个对象,该对象将进行统计,然后立即结束(因为它没有数据)。 要遵循符号链接,请执行以下操作: fstream.Reader({path:'/some/symlink', follow: true }...
  • fstream的用法

    2021-08-17 15:15:02
    C++ fstream详解_windistance的博客-CSDN博客_fstream
  • fstream —文件读写操作

    千次阅读 2020-05-18 18:25:53
    一、fstream 文件输入输出流 1、文件读写的三种类型 ifstream:从一个给定文件中读取数据 。 ofstream:向一个给定的文件中写入数据 fstream:可以读写给定的文件。 它可以用IO库中的<<、>>、getline...
  • c++中有个类叫做fstream,可以实现打开一个文件作为流。创建一个对象,然后调用该对象的open函数,其主要有两个参数,第一个参数是字符串,表示文件的地址,第二个参数是代开方式,如: fstream fin(a.txt,ios::in)...
  • fstream file1(filename1, fstream::in | fstream::out | fstream::binary); if (!file1.is_open()) { cout ; } else { cout ; } file1.close(); string filename2 = "4.1.texture.fs...
  • fstream用法总结

    千次阅读 2018-07-11 15:00:12
    在C++中输入输出到指定文件,或者从指定文件中读出数据使用fstream类较为方便。C++中处理文件类似于处理标准输入和标准输出。类ifstream、ofstream(向文件中写入)和fstream分别从类 istream、ostream和iostream...
  • 头文件fstream.h

    2016-07-19 14:46:31
    头文件fstream.h
  • C++的IO类中定义了三个文件读写流fstream、ifstream以及ofstream,它们都继承于相同的父类istream,通过不同的实现以实现不同的文件流操作。 三者的区别为: ifstream:从文件读取数据 ofstream:从文件写入数据 ...
  • c++文件读写 fstream

    2018-02-06 09:31:14
    在看C++编程思想中,每个练习基本都是使用ofstream,ifstream,fstream,以前粗略知道其用法和含义,在看了几位大牛的博文后,进行整理和总结: 这里主要是讨论fstream的内容: [java] view ...
  • 【C/C++】fstream详解

    2020-05-28 20:51:34
    C++中是通过 fstream文件流来实现的,其包含ifstream、ofstream、fstream 三个类,通过定义这三个类的对象实现相对应的文件操作。 二、C中的文件操作 1、打开文件 包括fopen()、freopen()、tmpfile() 三个函数,...
  • fstream和sstream

    2020-03-31 00:11:14
    ①#include 是C++的预编译语句,作用是包含对应的文件,在这里是包含C++的STL头文件fstream。 在包含了这个文件后,就可以使用fstream中定义的类及各种成员函数了。 fstream是C++ STL中对文件操作的合集,包含了常用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 83,135
精华内容 33,254
关键字:

fstream