ofstream_ofstream怎么初始化为空 - CSDN
  • 文章目录1.添加头文件2.打开文件3.关闭文件 1.添加头文件 #include <fstream> ...//在实际应用中,根据需要的不同,选择不同的类来定义:如果...//如果想以输出方式打开,就用ofstream来定义;如果想以输入/输...

    1.添加头文件

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

    2.打开文件

    //在实际应用中,根据需要的不同,选择不同的类来定义:如果想以输入方式打开,就用ifstream来定义;
    //如果想以输出方式打开,就用ofstream来定义;如果想以输入/输出方式来打开,就用fstream来定
     
    //ofstream         //文件写操作 内存写入存储设备   
    //ifstream         //文件读操作,存储设备读区到内存中  
    //fstream          //读写操作,对打开的文件可进行读写操作
     
    //(一)打开文件的方式在ios类(所以流式I/O的基类)中定义,有如下几种方式:
    //ios::in	为输入(读)而打开文件
    //ios::out	为输出(写)而打开文件
    //ios::ate	初始位置:文件尾
    //ios::app	所有输出附加在文件末尾
    //ios::trunc	如果文件已存在则先删除该文件
    //ios::binary	二进制方式 这些方式是能够进行组合使用的,以“或”运算(“|”)的方式:例如
     
    //(二)、保护模式
    //#define _SH_DENYRW      0x10    /* deny read/write mode */拒绝对文件进行读写 
    //#define _SH_DENYWR      0x20    /* deny write mode */拒绝写入文件 
    //#define _SH_DENYRD      0x30    /* deny read mode */拒绝文件的读取权限 
    //#define _SH_DENYNO      0x40    /* deny none mode */读取和写入许可 
    //#define _SH_SECURE      0x80    /* secure mode */共享读取,独占写入 
    //注意:假设A进程以_SH_DENYRW 打开,那么是B进程不能再对文件进行读写。
     
    ofstream ofs;							//打开文件用于写,若文件不存在就创建它
     
    locale loc = locale::global(locale("")); 		       //要打开的文件路径含中文,设置全局locale为本地环境 
     
    ofs.open("./out.bin",ios::out| ios::app | ios::binary,_SH_DENYNO); //输出到文件 ,追加的方式,二进制。 可同时用其他的工具打开此文件
     
    locale::global(loc);					      //恢复全局locale
     
    if (!ofs.is_open())return;	//打开文件失败则结束运行  
     
    for (int i=0;i<100;i++)
    {
    	char* buffer = "fdsfdsfdsfdsfdsfds\n";
    	ofs.write(buffer, sizeof(char)*17); 
    	ofs.flush();
    	Sleep(1000);
    }
     
    ofs.close();  
    

    3.关闭文件

    ofstream  file;
    locale::global(locale(""));//将全局区域设为操作系统默认区域
    string strFileName = "e:\\abc.bin";
    file.open(strFileName.c_str());
    locale::global(locale("C"));// 还原全局区域设定 
     
    std::ostringstream   str("");
    str	<<	"123" << "\n";
    file.write(str.str().c_str(),str.str().length());
    file.close();
    

    4.csv文件和txt文件区别

    csv文件分隔符是一般用’,’,保存用UTF-8格式
    txt文件分割符号一般用’\t’,保存是Unicode码
    换行都是’\n’

    //csv存入常规操作:
    std::string fn_out;
    std::ofstream ofs_log_csv;
    fn_out = "resault_real.csv";
    ofs_log_csv.open(fn_out.c_str(), std::ios::out);
    
    void GPSLocalizer::dump_trajectory_csv() {
    const char kDelimiter = ',';
    
    Eigen::AngleAxisd rollAngle(AngleAxisd(roll_ - roll1_,Vector3d::UnitX()));
    Eigen::AngleAxisd pitchAngle(AngleAxisd(pitch_ - pitch1_,Vector3d::UnitY()));
    Eigen::AngleAxisd yawAngle(AngleAxisd(yaw_ - yaw1_,Vector3d::UnitZ())); 
    Eigen::Quaterniond q;
    q= yawAngle * pitchAngle * rollAngle;
    q.normalized();//
    
    ofs_log_csv << std::fixed << std::setprecision(9)
             << nav_msg.time << kDelimiter 
             << 111<< kDelimiter 
             << x_ - x1_ << kDelimiter 
             << y_ - y1_<< kDelimiter 
             << z_ - z1_ << kDelimiter 
             << q.w()<< kDelimiter 
             << q.x() << kDelimiter 
             << q.y() << kDelimiter
             << q.z() << kDelimiter 
             << "\n";      
    }
    

    参考:https://blog.csdn.net/sinat_36219858/article/details/80380851#2-ofstreamopen

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

    ofstream的使用方法
    ofstream
    是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间;  
    C++中,有一个stream这个类,所有的I/O都以这个类为基础的,包括我们要认识的文件I/Ostream这个类有两个重要的运算符:  
    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
    :系统文件  
      可以用或者“+”把以上属性连接起来,如31|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;< span="" style="word-wrap: break-word;">要把3.14159265位精度输出:file1<<setpxecision(5)<<3.1415926< span="" style="word-wrap: break-word;">  
      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   
    #include   
    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++ ofstream和ifstream详细用法 原文出自【比特网】,转载请保留原文链接:http://soft.chinabyte.com/database/460/11433960.sh   [导读]  ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓...

    (转载)C++ ofstream和ifstream详细用法

    原文出自【比特网】,转载请保留原文链接: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("旧文件名","新文件名");

     

     

     

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

    int main()
    {
     int n[5] = {1, 2, 3, 4, 5};
     register int i;

     ofstream out("test", ios::out | ios::binary);
     if(!out) {
     cout << "Cannot open file.\n";
     return 1;
     }

     out.write((char *) &n, sizeof n);

     out.close();

     for(i = 0; i <5; i++) // clear array
     n[i] = 0;

     ifstream in("test", ios::in | ios::binary);
     if(!in) {
     cout << "Cannot open file.\n";
     return 1;
     }

     in.read((char *) &n, sizeof n);

     for(i = 0; i <5; i++) // show values read from file
     cout << n[i] << " ";

     in.close();

     return 0;
    }

    展开全文
  • ofstream:写操作,由ostream引申而来 ifstream:读操作,由istream引申而来 fstream :同时读写操作,由iostream引申而来 文件的类型:文本文件 和 二进制文件 文件读写的步骤: 1、包含的头文件:#includ...

    相关的头文件:#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...z

       2)使用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 78

    write( ):

          功能:把buf指向的内容取n个字节写入文件

          函数声明:ostream & ostream :: write ( char * buf ,  int  n ) ;

          参数说明:buf表示要写入内存的地址,传参时要取地址。n表示要读入字节的长度

          注意:1):该函数遇到空字符时并不停止,因而能够写入完整的类结构

                      2):第一个参数一个char型指针(指向内存数据的起始地址),与对象结合使用的时候,要在对象地址之前要char做强制类型转换。

    函数功能:使用write( )函数,一次从文件向内存写入一行数据

    #include <fstream>  
    
    #include <iostream>  
    
    using namespace std;  
    
    void main()  
    
    {  
    
      char ch[12];  
    
         ifstream OpenFile("file.txt");  
    
      if (OpenFile.fail())  
    
        {  
    
            cout<<"打开文件错误!"<<endl;  
    
            exit(0);  
    
        }  
    
        OpenFile.read(ch,12);  
    
        cout<<ch;  
    
        OpenFile.close();  
    
        system("pause");  
    
    }  

     

    运行结果:数组ch的内容为12 3 456 78 。

    说明:

    1、程序不再使用文件时,为什么要关闭文件?

    因为:1)文件缓冲区是一块小的内存空间.

                2)操作系统限制同时打开的文件数量 

    注意:close ( ) 函数关闭文件,但流对象仍然存在。

    2、文件的默认打开方式为文本文件,要是想以二进制的方式处理,在打开时要用 ios::binary 显式声明。

    3、针对文本文件操作时,get函数和>>的区别:

    区别:在读取数据时,get函数包括空白字符(遇空白字符不停止读取)

                >>在默认情况下拒绝接受空白字符(遇到空白符停止读取)

    4、判断文件是否打开的方法:

    if (OpenFile)  
    
    {  
    
        cout<<"打开文件失败!";  
    
        exit(0);  
    
    }  
    
    if (OpenFile.fail())  
    
    {  
    
        cout<<"打开文件错误!"<<endl;  
    
        exit(0);  
    
    }  

     

    5、判断文件是否结束的方法:

             1)使用成员函数eof()可以检测到这个结束符,如果非0表示文件结束。

      while (!OpenFile.eof())  

        {  

        //文件结束时的代码  

        }  

             2)使用流直接检测,如果为0表示文件结束

     

     

      while (!OpenFile)  

        {  

        //文件结束时的代码  

        }  

             3)使用get函数,读取最后一个结束符时,返回0.读取正常情况下,返回1,并把读取的字符放到ch中

     

     

      while ( (OpenFile.get(ch) )!=EOF)  

        {  

        //成功时候的代码  

        }  

    文本文件的读写常使用的方法:使用<<写入文件,使用getline 和 >> 读到内存

    二进制文件的读写常使用的方法:使用istream 类的成员函数read 和write 来实现,

    这两个成员函数的原型为:

     

     

     

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

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

    参数说明:字符指针 buffer 指向内存中一段存储空间。len 是读/写的字节数。

    与对象结合写入二进制文件时:

            write函数调用语句:

     

     

    输出文件流对象名.write((char*)& 对象名,sizeof(<对象所属类名>));  

    输出文件流对象名.write((char*)& 对象数组名[下标],sizeof(<对象所属类名>));  

            read函数调用语句:

     

     

    输入文件流对象名.read((char*)& 对象名,sizeof(<对象所属类名>));          

    输入文件流对象名.read((char*)& 对象数组名[下标],sizeof(<对象所属类名>));      

    注意:gcount()函数经常和read函数配合使用,用来获得实际读取的字节数。

    二进制文件的随机读写

    #include <iostream>  
    
    #include <fstream>  
    
    using namespace std;  
    
    int main(void)  
    
    {  
    
      //写文件:二进制存储1234  
    
      int writeNum1 = 1;  
    
      int writeNum2 = 2;  
    
      int writeNum3 = 3;  
    
      int writeNum4 = 4;  
    
        ofstream fout("test.txt", ios::out | ios::binary);  
    
        fout.write(reinterpret_cast<char *>(&writeNum1), sizeof(int));  
    
        fout.write(reinterpret_cast<char *>(&writeNum2), sizeof(int));  
    
        fout.write(reinterpret_cast<char *>(&writeNum3), sizeof(int));  
    
        fout.write(reinterpret_cast<char *>(&writeNum4), sizeof(int));  
    
        fout.close();  
    
      //读文件  
    
        ifstream fin("test.txt",ios::in | ios::binary);  
    
      if (!fin.good())  
    
        {  
    
            cout<<"文件打开错误"<<endl;    
    
            exit(0);  
    
        }  
    
      int readNum = 0;  
    
      //第一次输出:从第一个数字输出,结果是1 2 3 4  
    
        fin.seekg(0,ios::beg);  
    
      while (fin.peek() != EOF)  
    
        {  
    
            fin.read(reinterpret_cast<char*>(&readNum), sizeof(int));  
    
            cout<<readNum<<" ";  
    
        }  
    
      cout<<endl;  
    
      //第二次输出:从第三个数字输出,结果是3 4
    
      fin.seekg(2 * sizeof(int),ios::beg);//游标移动的次数 = 需要处理数的个数 × int占的字节数  
    
      while (fin.peek() != EOF)  
    
        {  
    
            fin.read(reinterpret_cast<char*>(&readNum), sizeof(int));  
    
            cout<<readNum<<" ";  
    
        }  
    
        cout<<endl;  
    
         fin.close();  
    
          system("pause");  
    
      return 0;  
    
    }  

     

    展开全文
  • ofstream //文件写操作,内存写入存储设备(文件) 输出流 通常我们所说的对一个文件进行写操作,就是把内存里的内容,也就是缓冲区的内容写到硬盘,可以将标准输出设备理解为显示器 ifstream //文件读操作,存储设备到...

    文件流

    ofstream  //文件写操作,内存写入存储设备(文件)  输出流
    通常我们所说的对一个文件进行写操作,就是把内存里的内容,也就是缓冲区的内容写到硬盘,可以将标准输出设备理解为显示器
    
    ifstream      //文件读操作,存储设备到内存.       输入流
    通常我们所说对一个文件读操作,就是把存在硬盘的内容写到内存中,也就是缓冲区
    
    fstream      //读写操作,对打开的文件可进行读写.   前两者的结合
    
    //文件打开方式选项
    ios::in  = 0x01, //供读,文件不存在则创建(ifstream默认的打开方 式)  
    ios::out  = 0x02, //供写,文件不存在则创建,若文件已存在则清空原内容(ofstream默认的打开方式)  
    ios::ate  = 0x04, //文件打开时,指针在文件最后。可改变指针的位置,常和in、out联合使用  
    ios::app  = 0x08, //供写,文件不存在则创建,若文件已存在则在原文件内容后写入 新的内容,指针位置总在最后  
    ios::trunc = 0x10,      // 在读写前先将文件长度截断为0(默认)  
    ios::nocreate  = 0x20,  //文件不存在时产生错误,常和in或app联合使用  
    ios::noreplace = 0x40,   //文件存在时产生错误,常和out联合使用  
    ios::binary   = 0x80  //二进制格式文件
    
    //文件保护方式选择项
    filebuf::openprot;   //默认的兼容共享方式  
    filebuf::sh_none;    //独占,不共享  
    filebuf::sh_read;    //读共享  
    filebuf::sh_write;   //写共享
    

    创建文件 

    ofstream ofs("example.txt"); //打开文件用于写,若文件不存在就创建它  
    if (!ofs) 
    {
        return;//打开文件失败则结束运行  
    }
    
    ofs << setw(10) << "Name: " << "Beethoven" << endl; //使用插入运算符写文件内容   
    ofs << setw(10) << "song: " << "Moonlight Sonata" << endl;
    ofs.close(); //关闭文件

     fstream

    open()用来打开指定的文件,可以通过is_open()判断是否打开成功
    is_open();用来判断单开文件是否成功,成功返回true,发欧泽返回false
    good();在没有发生任何错误的情况下返回true,否则返回false
    
    ofstream f;
    f.open("1.txt",ios_base::app);
    if(!f.is_open()){
       cout<<"open error";
       return -1;
    }
    f<<"1234";
    f<<"456";
    f.close();

    ifstream

    open()用来打开指定的文件,可以通过is_open()判断是否打开成功
    is_open();用来判断单开文件是否成功,成功返回true,发欧泽返回false
    good();在没有发生任何错误的情况下返回true,否则返回false
    eof();判断是否读取文件数结束,读取到结束返回true,否则返回false
    fail();当读取操作类型不匹配的情况下返回true,否则返回false
    
    int c;
    ifstream inFile;
    inFile.open("test.txt");//打开指定的文件
    if(!inFile.is_open()){//判断打开是否成功
        cout<<"打开失败"<<endl;
    }
    while(inFile.good())//判断是否发生任何类型的错误
        inFile>>c;
    if(inFile.eof())//判断是否文件结束
        cout<<"文件结束";
    else if(inFile.fail())//是否发生类型错误,本程序c为int,当出现char类型,就会出错
        cout<<"读取失败";
    else 
        cout<<"unkown error\n";
    inFile.close();

    getline()读取一行

    ifstream fin("test.txt",ios::in);
    string s;
    while(getline(fin,s))
            cout << s;//输出每一行
    每次从fin指向的文件中读取一行,一行之中的所有字符都会被读入,包括空格。但是结尾的空格不读入,回车换行也不读入。

    打开文件的方法

    调用构造函数时指定文件名和打开模式
    ifstream f("d:\\12.txt", ios::nocreate); //默认以 ios::in 的方式打开文件,文件不存在时操作失败  
    ofstream f("d:\\12.txt");  //默认以 ios::out的方式打开文件  
    fstream f("d:\\12.dat", ios::in|ios::out|ios::binary); //以读 写方式打开二进制文件  
    
    使用Open成员函数
    fstream f;  
    f.open("d:\\12.txt",ios::out);  //利用同一对象对多个文件进行操作时要用到open函数  
    

    检查是否成功打开

    成功:
    if (f) {...}       //对ifstream、ofstream对象可 用,fstream对象不可用。 mysql  
    if (f.good()) {...}  
    
    失败:
    if (!f) {...}       // !运算符已经重载  
    if (f.fail()) {...} 

    随机读写文件 

    通过移动文件读写指针,可在文件指定位置进行读写。
    
    seekg(绝对位置);      //绝对移动,    //输入流操作  
    seekg(相对位置,参照位置);  //相对操作  
    tellg();          //返回当前指针位置  
    seekp(绝对位置);      //绝对移动,    //输出流操作  
    seekp(相对位置,参照位置);  //相对操作     
    tellp();          //返回当前指针位置  
    
    参照位置: mysql
    ios::beg  = 0       //相对于文件头  
    ios::cur  = 1       //相对于当前位置  
    ios::end  = 2       //相对于文件尾  

    写文本文件的示例

    fstream f("try.txt", ios::out);  
    f << 1234 << ' ' << 3.14 << 'A' << "How are you"; //写入数据  
    f.close();  
    f.open("try.txt", ios::in);  
    int i;  
    double d;  
    char c;  
    char s[20];  
    f >> i >> d >> c;  //读取数据  
    f.getline(s,20);  
    cout << i << endl; //显示各数据  
    cout <<d << endl;  
    cout << c << endl;  
    cout << s << endl;  
    f.close(); 
    
    运 行结果:
    1234
    3.14
    A
    How are you
    Press any key to continue
    
    显示文本文件的内容

    使用get()一次读一个字符

    ifstream fin("简介.txt", ios::nocreate);  
    if (!fin) 
    {  
        cout << "File open error!\n";  
        return;  
    }  
    char c;  
    while ((c=fin.get()) != EOF) cout << c; //注意结束条件的判断  
    fin.close();

    使用get(char *,int n,char delim='\n')一次读多个字符

    ifstream fin("d:\\简介.txt",ios::nocreate);  
    if(!fin)
    {  
        cout<<"File open error!\n";  
        return;  
    }  
    char c[80];  
    while(fin.get(c,80,'\0')!=NULL)cout<<c; //注意结束条件的判断  
    fin.close();

    使用read(char *,int n)读文件

    ifstream fin("简介.txt",ios::nocreate);  
    if(!fin){  
    cout<<"File open error!\n";  
    return;  
    }  
    char c[80];  
    while(!fin.eof())            //判 断文件是否读结束  
    {  
        fin.read(c,80);  
        cout.write(c,fin.gcount());  
    }  
    fin.close();

    拷贝文件(二进制)

           尽管可以使用重载运算符<< 和>>,以及函数(如getline)来操作符输入和输出数据,是合法的,但是在在二进制文件中,这些操作没有什么实际意义。

           文件流包括两个为顺序读写数据特殊设计的成员函数:write 和 read。第一个函数 (write) 是ostream 的一个成员函数,都是被ofstream所继承。而read 是istream 的一个成员函数,被ifstream 所继承。类 fstream 的对象同时拥有这两个函数。它们的原型是:

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

    buffer 是一块内存的地址,用来存储或读出数据。参数size 是一个整数值,表示要从缓存(buffer)中读出或写入的字符数。

    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;  
    
    ifstream fin("1.exe", ios::nocreate|ios::binary);  
    if (!fin) 
    {  
        cout << "File open error!\n";  
        return;  
    }  
    ofstream fout("2.exe", ios::binary);  
    char c[1024];  
    while (!fin.eof())  
    {  
        fin.read(c, 1024);  
        fout.write(c, fin.gcount());  
    }  
    fin.close();  
    fout.close();  
    cout << "Copy over!\n";
    
    
    注意:若期望是二进制的文件读写,必须要指定读、写的模式有ios::binary,否则读取数据会出错。

    写操作
    ofstream write(char *buffer, int length) 
    buffer是变量指针,一般需要强制转化成char *类型,然后加取地址符,因为任何内容都可以表现成字符的形式,而后面的length则是变量类型的字节长,一般用sizeof进行计算防止不必要的错误,下面看实例。

    #include<fstream>
    int main()
    {
        using namespace std;
        int a = 1127;
        double b = 3.1415;
        ofstream ofs("test.txt",ios::binary);
        ofs.write((char*)&a,sizeof(int));
        ofs.write((char*)&b,sizeof(double));
    }
    
    注:(其中ios::binary以二进制方式打开文件) 
    
    

     一个打开并检查输入文件的程序

    #include<iostream>  
    #include<fstream>  
    #include<string>  
    using namespace std;  
    ifstream& open_file(ifstream &in,const string &file)  
    {  
        in.close();  
        in.clear();  
        in.open(file.c_str());  
        return in;  
    }  
    int main()  
    {  
        ifstream file;  
        open_file(file,"1.txt");  
        string s;  
        while(getline(file,s))  
        {  
            cout<<s<<endl;  
        }  
        file.close();  
        return 0;  
    }

    (二)读操作。 
    ifstream read(char * buffer, int length) 
    参数和刚才一样的道理,下面看将上文的a,b输出到控制台。

    #include<fstream>
    int main()
    {
        using namespace std;
        int a = 1127;
        double b = 3.1415;
        ofstream ofs("test.txt",ios::binary);
        ofs.write((char*)&a,sizeof(int));
        ofs.write((char*)&b,sizeof(double)); 
        ofs.close();   
        int a1;
        double b1;
        ifstream ifs("test.txt",ios::binary);
        ifs.read((char*)&a1,sizeof(int));
        cout<<a1<<endl;
        ifs.read((char*)&b1,sizeof(double));
        cout<<b1<<endl;
        ifs.close();
        return 0;
    }
    

     其实道理很简单,应用此模式,数据类型复杂一些像结构也照样可以进行读写操作。例如。 

    #include<fstream>
    #include<iostream>
    #include<cstring>
    struct A
    {
        int a;
        double b;
    };
    int main()
    {
        using namespace std;
        A aa={1127,3.1415};
        ofstream ofs("test.txt",ios::binary);
        ofs.write((char*)&aa,sizeof(A));
        ofs.close();
        A bb;
        ifstream ifs("test.txt",ios::binary);
        ifs.read((char*)&bb,sizeof(A));
        cout<<bb.a<<endl;
        cout<<bb.b<<endl;
        return 0;
    }

    参考:

    http://www.it610.com/article/5040888.htm

    展开全文
  • ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间 在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O. stream这个类有两个重要的...
  • ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间; 在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符:...
  • ofstream的使用方法

    2018-11-12 00:35:12
    ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间; 在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符: ...
  • 头文件 &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;fstream&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;...ofstream Output file stream (class )链
  • ofstream的使用方法–超级精细ofstream的使用方法ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间; 在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们...
  • ofstream奇怪问题解决方法 最近使用ofstream写数据到文件中出现了一些奇怪的问题,发现有时候写入的数据和原始数据不一致,经过观察发现,有些地方多了0D这个东西,查字符 表得知是回车符。因此得知可能是自动...
  • ofstream和ifstream详细用法 ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间(文章最末尾附上了MSDN中关于这两个函数的解释); 在C++中,有一个stream这个类,所有的I/O都...
  • ofstream和ifstream的区别

    2018-06-13 12:15:20
    ofstream是从内存到硬盘,ifstream是从硬盘到内存。 在实际应用中,根据需要的不同,选择不同的类来定义;如果想以输入方式打开,就用ifstream;如果想以输出方式打开,就用ofstream来定义;如果想以输入/输出方式来...
  • ofstream写大文件出错

    2019-09-29 11:00:44
    两个文件都是用ofstream对象来维护的。写操作是通过ofstream的write成员函数实现的。 现在的问题是:每次写文件写到64%左右就会出错,write函数的返回值显示写操作没有成功。第一回是在文件A出错,第二回则是在...
  • ifstream和ofstream都是包含在头文件&lt;fstream&gt;中的,ifstream是从硬盘读到内存,而ofstream则是从内存读到硬盘 fstream对打开的问件进行读写操作 打开方式有以下几种: 1、用输入/输出方式打开 ...
  • ofstream有时会打开失败,即ofs.fail()==true。并且在有的文件路径能够打开,成功生成文件,有的路径却不能。其原因可能是没有系统写文件的权限。 例如,在使用V3D中某个插件的dofunc功能的时候,由VS打开的命令行...
  • ofstream的使用方法ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间; 在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O,stream这个类有...
  • 中包含三个文件输入输出类——ifstream/ofstream/fstream,分别由相应的iostream中的类派生而来。又知道在创建各类对象时,有输入输出方式设置值可供精细地控制文件的输入与输出。而我们知道,所谓ifstream类的作用...
  • ofstream

    2018-04-24 19:24:30
    #include #include using namespace std; int main() { char buf[32] = "helloworld";... ofstream ofs("sad.txt"); //创建一个输出流对象 if(!ofs) //如果不存在这个文件报错 { cout<<"open failure"<<e
1 2 3 4 5 ... 20
收藏数 29,555
精华内容 11,822
关键字:

ofstream