精华内容
下载资源
问答
  • fstream
    2022-05-28 22:28:23

    C++文件流。
    首先需要包含头文件#include< fstream >
    fstream可以把它理解成一个父类,包含的子类有ifstream和ofstream等,
    fstream:文件输入输出类。表示文件级输入输出流(字节流);
    ifstream:文件输入类。表示从文件内容输入,也就是读文件;
    ofstream:文件输出类。表示文件输出流,即文件写。
    所以一般直接创建一个父类对象即可(即fstream类的对象)

    C++中seep()和seekg()函数功能
    seekg:设置输入文件流的文件流指针位置
    seekp:设置输出文件流的文件流指针位置

    C++文件流检测EOF
    成员函数eof()用来检测是否到达文件尾,如果到达文件尾返回非0值,否则返回0。原型是inteof();
    例:if(in.eof())ShowMessage("已经到达文件尾!");
    C++文件流文件定位
    和C的文件操作方式不同的是,C++ I/O系统管理两个与一个文件相联系的指针。一个是读指针,它说明输入操作在文件中的位置;另一个是写指针,它下次写操作的位置。每次执行输入或输出时,相应的指针自动变化。所以,C++的文件定位分为读位置和写位置的定位,对应的成员函数是 seekg()和 seekp(),seekg()是设置读位置,seekp是设置写位置。它们最通用的形式如下:
    1.  istream &seekg(streamoff offset,seek_dir origin);  
    2.  ostream &seekp(streamoff offset,seek_dir origin);  

    函数原型:
    ostream& seekp( streampos pos );
    ostream& seekp( streamoff off, ios::seek_dir dir );
    istream& seekg( streampos pos );
    istream& seekg( streamoff off, ios::seek_dir dir );
    函数参数
    pos:新的文件流指针位置值
    off:需要偏移的值
    dir:搜索的起始位置
    dir参数用于对文件流指针的定位操作上,代表搜索的起始位置


    seekg(绝对位置);      //绝对移动,    //输入流操作  
    seekg(相对位置,参照位置);  //相对操作  
    tellg();          //返回当前指针位置  
    seekp(绝对位置);      //绝对移动,    //输出流操作  
    seekp(相对位置,参照位置);  //相对操作     
    tellp();          //返回当前指针位置  


    在ios中定义的枚举类型:
    enum seek_dir {beg, cur, end};
    每个枚举常量的含义:
    ios::beg:文件流的起始位置
    ios::cur:文件流的当前位置
    ios::end:文件流的结束位置
    这两个函数一般用于二进制文件,因为文本文件会因为系统对字符的解释而可能与预想的值不同。
    例:
    1.  file1.seekg(1234,ios::cur);//把文件的读指针从当前位置向后移1234个字节  
    2.  file2.seekp(1234,ios::beg);//把文件的写指针从文件开头向后移1234个字节 

    下边的代码讲解了
    1:4种文件的读写操作
    2:如何使用get(),put(),getline(),write()以及read()函数。
    3:如何得到文件的大小。
    4:seekg()和teelg()配套使用的真谛,seekp()和teelp()同理

    //文件流;
    #include<iostream>
    #include<fstream>  //ifstream  ofstream
    using namespace std;
    /*
        No1.文件流流类
        ofstream:打开文件,写文件
        ifstream:打开文件,读操作
        fstream:可读可写
        No2.一般用包含#include<fstream>
        No3.打开文件,关闭文件
        打开文件:
        void open(const char* URL,ios::openmode mode);
        mode: 
            ios:in  读的方式打开文件
            ios:out 写的方式打开文件
            ios::app 追加的方式写文件
            ios::ate  在已有的文件,文件指针在文件末尾
            ios::trunc  文件不存在,创建文件
            ios::binary  二进制形式打开文件,默认方式ASCII码方式打开
            ios::nocreate  不创建的方式
            ios::norepalce  不替换
        组合方式:用的是位或
            ios::in|ios::out 可读写
            ios::out|ios::binary 二进制写的方式打开文件,
        判断文件是否打开成功:
            1.is_open() 判断打开是否成功
            2.!文件对象  判断文件是否打开成佛那个
        关闭文件:close()成员函数关闭;
        */
    void testOpenFile() {    //用于测试用的函数
        //C++中打开文件是文件对象,不是文件指针。

        fstream File,File1;
        File.open("2.txt", ios::in | ios::out );
        File1.open("3.txt", ios::in | ios::out | ios::trunc);
        //使用open函数和直接用构造函数是一样的效果。
        if (!File.is_open()) {
            cerr << "2.txt 打开文件失败!!\n";
        }
        if (!File) {
            cerr << "2.txt打开文件失败!!!\n";
        }//这个if语句和上一个if语句作用相同
        if (!File1.is_open()) {
            cerr << "3.txt打开文件失败!!\n";
        }
        else {
            cout << "3.txt 打开成功!!!\n";
        }
        File.close();
        File1.close();
    }
    //No2.读写方式:
    void asciiReadWriteFile(const char* readFileName, const char* writeFileName) {
        fstream read(readFileName, ios::in);
        fstream write(writeFileName, ios::out);
        //第一种读写方式:ASCII  直接流的方式读写, >>  <<
        /*while (1) {
            char temp;
            read >> temp;
            if (read.eof()) {
                break;
            }
            write << temp;
        }*/
        //第二种方式读写方式:可以保留空格和换行,用get()和put();
        /*while (1) {
            char temp;
            read.get(temp);
            //temp=read.get();一样的效果!
            if (read.eof()) {
                break;
            }
            write.put(temp);
        }*/
        //第三种读写方式:不能保留空格和换行,用getline()和write().
        char str[40]; 
        while (!read.eof()) {
            memset(str, ' ', 40);
            read.getline(str,40);
            int len = strlen(str);
            write.write(str,len);
            write.put('\n');
        }
    }
    //使用二进制读写方式  使用read()和write()函数来实现
    void binaryReadWriteFile(const char* readFile, const char* writeFile) {
        fstream read(readFile, ios::in | ios::binary);
        fstream write(writeFile, ios::out | ios::binary);
        while (!read.eof()) {
            char str[1024]="";
            read.read(str, 1024);
            
            write.write(str, 1024);
        }
        read.close();
        write.close();
    }
    //
    void testSeekReadFile(const char* fileName) {
        fstream fread(fileName, ios::in);
        fstream fwrite(fileName, ios::app|ios::out);
        if (!fread) {
            cerr << "打开文件\"fileName\"!失败!";
        }
        int f = fread.tellg();
        fread.seekg(0,ios::end);
        int l = fread.tellg();
        cout << "size  of  " << fileName << "is "<<(l - f) << "bytes.";
        fread.seekg(5);//表示将指针位置设置到绝对位置5;
        cout << (char)fread.get() << endl;
        fread.seekg(-1, ios::cur);        //seekg的第一个参数为负,表示从当前位置往前移
        cout << (char)fread.get() << endl;
        fread.seekg(1, ios::cur);//第一个参数为正,表示从当前位置往后数的第一个位置。
        
        fwrite.put('w');//在末尾追加写。
    }
    int main() {
        testOpenFile();
        asciiReadWriteFile("read.txt","write.txt");
        binaryReadWriteFile("read.txt", "binaryTest.txt");
        testSeekReadFile("read.txt");
        return 0;
    }
     

    更多相关内容
  • fstream是用于在二进制文件队列中收集/读取输入消息的简单解决方案。 每个文件包含1分钟内收到的所有消息。 文件格式: <uint16> <msg1> <uint16> <msg2> ... 消息大小存储在uint16值中。 所有文件都保存在所选...
  • c++中有个类叫做fstream,可以实现打开一个文件作为流。创建一个对象,然后调用该对象的open函数,其主要有两个参数,第一个参数是字符串,表示文件的地址,第二个参数是代开方式,如: fstream fin(a.txt,ios::in)...
  • C语言头文件 FSTREAM.H

    2022-06-11 12:17:02
    C语言头文件 FSTREAM.HC语言头文件 FSTREAM.HC语言头文件 FSTREAM.HC语言头文件 FSTREAM.HC语言头文件 FSTREAM.HC语言头文件 FSTREAM.HC语言头文件 FSTREAM.HC语言头文件 FSTREAM.HC语言头文件 FSTREAM.HC语言头文件...
  • node-fstream

    2021-05-07 13:13:51
    因此,如果调用fstream.Reader('/some/symlink')则将获得一个对象,该对象将进行统计,然后立即结束(因为它没有数据)。 要遵循符号链接,请执行以下操作: fstream.Reader({path:'/some/symlink', follow: true }...
  • 如果采用C++,首先想到的就是文件流fstream。虽然在COM层面上,我们还可以使用IStream来实现文件的读写,其效率也非常高。不过本文仅对C++流操作做简单的探讨,相比于Windows API或IStream,C++的流操作通用性更好...
  • 目录freopen重定向fstream文件流freopen 重定向 使用方法: freopen(“in.txt”,“r”,stdin);//从in.txt读入 freopen(“out.txt”,“w”,stdout);//向out.txt输出 freopen(“CON”,“r”,stdin);//从控制台读入 ...
  • fstream中文路径

    2022-05-23 10:04:31
    在C++的标准库中,std::fstream是个挺好用的文件读写流,操作文件很方便,因为是C++标准库,所以没有其它的环境依赖。在使用fstream过程中,有个打开中文路径文件会失败的问题,自己的代码中一直没处理好,这几天...

    目录

    中文路径

    编译器

    统一字符集

    修正方法

    改全局的Locale

    使用wstring

    字符集改为宽字符集

    升级编译器

    一劳永逸

    将fstream再包装

    总结


    在C++的标准库中,std::fstream是个挺好用的文件读写流,操作文件很方便,因为是C++标准库,所以没有其它的环境依赖。在使用fstream过程中,有个打开中文路径文件会失败的问题,自己的代码中一直没处理好,这几天终于有点闲心,把这里改透。涉及很多知识点,也是个遗留已久的问题,特此做个记录。

    在最后用了个一劳永逸的解决此问题方法:将fstream、FILE再包装下。

    1.中文路径

    使用fstream调试程序过程中,发现打开含中文路径的文件时,会打开失败。查了一些资料,说在VS2008、vs2005中,fstream的open函数中,会判断当前的全局编码环境,导致含中文的路径打开失败,也提到了很多修改方法,如让修改全局的Locale改为宽字符、使用宽字符集wstring。

    我当时的修改方法是调用重载的open(wstring),即将string的路径,转为wstring,然后fstream就可以打开有中文路径文件了,缺点是在string转wstring时需要调用windows的函数,产生了一个外部依赖,且多了几行代码。

    编译器

    我所使用的开发环境是vs2008,有些文章说只在vs2005、vs2008的环境中才有这个问题,好在我的开发环境中有vs2015,所以在vs2015中也测试下。很容易执行这个测试,vs2015中执行新建win32控制台程序,在main函数中添加测试代码,定义fstream打开文件,重点是文件路径要有中文。

    测试代码如下:

    #include <fstream>

    int main()

    {

        std::fstream st;

        st.open("D:/temp/fstream测试/测试1.log", std::fstream::app); //含中文的

        printf("%s\r\n", (st.is_open() ? "sucess" : "failed"));

        system("pause");

        return 0;

    }

    测试执行比对后,确认在vs2008中不能打开中文路径文件,而在2015中可以打开中文路径文件,显然这个问题和编译器是有关系的。我想linux环境中会怎么样,还需要测试下Gcc的现象、版本支持情况。在C++标准库中,不约定std::fstream的字符集支持与否的,这个问题肯定和编译器有关。

    测试项目的属性界面中,字符集都是默认设置的“使用Unicode字符集”,对比也是有效的。

    统一字符集

    程序运行的操作系统环境有字符集、程序源码文件有字符集、程序运行后处理字符也有字符集,改字符集是个繁琐的事情,源码文件、软件环境、都需要改。

    避免字符集的问题,最简单就是统一字符集,各个涉及字符集的地方都统一,我们写的程序就适应环境的字符集,此时问题就出现了,对于跨平台的开发,linux和windows差别太大了,会引入很多问题。

    2.修正方法

    为了在vs2008中使用std::fstream,可供使用的方法也有很多,最后总结罗列下面几种改进方法。

    改全局的Locale

    改全局的Locale,在调用open前调用setLocale修改为多字符集,open之后再改回来。产品是个多线程的程序,在基础库中修改全局的环境,可能会导致访问异常、崩溃,这不是个好方法。

    然而这个只需要一行代码即可,修改最简单。复杂软件系统中不要随意改全局编码,不要这么用。

    setlocale(LC_ALL,"Chinese-simplified");

    std::fstream stream;

    stream.open(“d:/数据/a.log”);

    使用wstring

    在fstream的接口方法中,重载有多个open函数,包括传入string、wstring等,实际测试确认调用重载传入wstring的open函数时,可以打开中文路径。

    定义一个string转wstring的函数,使用fstream的open函数时,先调用转换为wstring,然后调用open函数。这样引入了一个多字符转宽字符的函数,多几行调用,整体的稳定、可靠是没问题的。

    关于string转wstring,不要用C标准库的mbstowcs,该方法不支持中文,调用mbstowcs转换的中文会编程乱码。

    #include <Windows.h>

    //将string转换成wstring  

    inline wstring string2wstring(string str)  

    {  

    wstring result;  

    //获取缓冲区大小,并申请空间,缓冲区大小按字符计算  

    int len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), NULL, 0);  

    TCHAR* buffer = new TCHAR[len + 1];  

    //多字节编码转换成宽字节编码  

    MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), buffer, len);  

    buffer[len] = '\0';             //添加字符串结尾  

    //删除缓冲区并返回值  

    result.append(buffer);  

    delete[] buffer;  

    return result;  

    }  

    字符集改为宽字符集

    根源上还是字符集的问题,所有的string都改为wstring。我的软件中,一部分代码在windows vs2008开发、另一部分用的QtCreator开发、目前运行在windows,导致源码文件的默认编码是gb2312,软件运行的默认Locale也是多字符集。

    由于有跨平台的考虑,要减少环境的依赖、尽量只调用标准库、少改动代码,所以所有的编码应统一utf8,工程量太大,不太现实,后续再改进。

    升级编译器

    最简单的方法是升级编译器,不要用vs2008。升级编译器,不是小事,看使用者的习惯,代码会不会有影响。升级编译器、编译环境,还是有些繁琐的。导致产品代码,要对编译器有要求,约定了最低编译器版本。

    3.一劳永逸

    几种方法中都有缺点,转wstring的方式引入了操作系统的依赖,在我的产品代码中想尽量少依赖,可以用升级编译器的方式,但有几个库是vs2008的,都升级有些繁琐。

    想到个简单的、一劳永逸的方法,复用FILE指针、fopen函数可以支持中文路径、各种版本编译器中表现也一致。

    将fstream再包装

    在fstream的构造函数中,有输入FILE指针,在fstream构造函数传入FILE,所以可以先用fopen函数打开带中文路径的文件,然后构造fstream,之后就正常使用fstream即可。

    基于再包装wrap的方法,建立WrapFstream类,封装这几个操作。

    1. 成员变量包括std::fstream、FILE,对外接口主要open函数,在open函数内部用fopen打开FILE指针,然后构造fstream对象,此时不会有中文路径的问题。

    bool open(const std::string & fileName, const char * mode){

    close();

    file = fopen(fileName.c_str(), mode);

    if (file != NULL)

    {

    st = new std::fstream(file);

    return st->is_open();

    }

    return false;

    }

    1. 在关闭函数close中,需要释放资源。

    void close(){

    if (st != NULL){

    if (st->is_open())

    st->close();

    delete st;

    st = NULL;

    }

    if (file != NULL)

    fclose(file);

    file = NULL;

    st = NULL;

    }

    1. 然后是对外提供fstream接口方法,直接将fstream返回给调用者,调用者直接使用。
    2. 完整代码:

    /**

     * 将fstream再包装

     * 单元测试在CoreTest/test_TSore.cpp

     */

    class WrapFstream

    {

    std::fstream * st;

    FILE * file;

    public:

    MFileStream(){

    file = NULL;

    st = NULL;

    }

    ~MFileStream(){

    close();

    }

    bool open(const char * fileName, const char * mode){

    return this->open(string(fileName), mode);

    }

    bool open(const std::string & fileName, const char * mode){

           ...................

    }

    bool is_open(){

    if (st != NULL)

    return st->is_open();

    return false;

    }

    void close(){

    ..........

    }

    std::fstream * stream(){

    return st;

    }

    std::fstream & obj(){

    return (*st);

    }

    };

    总结

    vs2008中fstream用string不能打开中文路径,要用wstring.

    该问题设计多个知识点。文件编码等,有几个方式不能有效解决

    1.该全局的编码setLocate('c'). 该方法不可,由于TStore是基础库,整个软件是多线程,所有这个setLocate可能导致多线程的访问异常、崩溃。

    2.调用C库函数转换为宽字符串mbstowcs. 该方法不可,不能转换中文,VC的实现中只是在每个字节前插入一个x0。

    3.调用系统函数windows的多字符串转宽字符MuilteToWideChar,这个是可行的. 这几年一直这么跑,是windows环境,跨平台需要改下。

    4.有个文章说vc2005、vc2008有这个问题,而vc2005之前没有,作者跟着fstream的open函数代码,其中有判断全局环境编码的如果是'C'那么将string.c_str()直接转了(wchar*),然后调用CreateFile,所有不能打开。

    5.在vc2015确认无此问题。

    6.现在用FILE的fopen先打开,然后传递给fstream,再封装下。

    展开全文
  • 头文件fstream.h

    2016-07-19 14:46:31
    头文件fstream.h
  • fstream文件读写

    2018-06-02 14:57:18
    C++ iostream对文件流操作,实现文件读写,简单方便。
  • c++ fstream类详解

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

    在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,

    一,c++ 文件流的结构 :

    ‍1,几个文件流类名称:fstream,ifstream,ofstream,iofstream

    2,之间的关系:

    ifstream(input file stream)和ofstream(outpu file stream),ifstream默认以输入方式打开文件,而ofstream默认以输出方式打开文件。

    ifstream file2("c://pdos.def");//以输入方式打开文件,输入方式:读文档

    ofstream file3("c://x.123");//以输出方式打开文件 ,输出方式:写文档,向文档输出内容

    iostream是对屏幕上输入输出

    --------------------------------------

    二,构造函数:(ofstream与 ifstream的构造函数与fstream的相同)

    1,fstream fout("parts.txt");

    2,fstream logfile("database.dat", ios::in | ios::out);

    定义了下列打开模式和文件属性:

    ios::app // 从后面添加

    ios::ate // 打开并找到文件尾

    ios::binary // 二进制模式 I/O (与文本模式相对)

    ios::in // 只读打开

    ios::out // 写打开

    ios::trunc // 将文件截为 0 长度

    你可以用位域操作符 OR 组合这些标志:

    ofstream logfile("login.dat", ios::binary | ios::app); //向现有文件中添加二进制数据

    std::fstream test("hahahah",ios::in | ios::out | ios::trunc); //读、写、将文件设定为空

    ‍3,std::ifstream readfile();

    --------------------------------------

    二,打开文件的几种方式:

    1,使用上面的构造函数:

    std::ofstream logfile("log.dat");

    std::ifstream logfile("log.dat");

    std::fstream logfile("log.dat");

    std::fstream test("log.dat",ios::in | ios::out | ios::trunc);

    2,使用open函数:

    std::ifstream logfile();

    logfile.open("log.dat");

    3,打开文件的属性设置:

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

    例程:

    std::fstream file;

    try

    {

    file.open("C++.txt");

    }

    catch(std::exception &e)

    {

    cout<

    }

    --------------------------------------

    三,读写文件:(读文件:限ifstream,fstream;写文件:限ofstream,fstream)

    (1)文本的读写:

    1,使用插入器(<

    例程:file2<

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

    操纵符 功能 输入/输出

    dec 格式化为十进制数值数据 输入和输出

    endl 输出一个换行符并刷新此流 输出

    ends 输出一个空字符 输出

    hex 格式化为十六进制数值数据 输入和输出

    oct 格式化为八进制数值数据 输入和输出

    setpxecision(int p) 设置浮点数的精度位数 输出

    比如要把123当作十六进制输出:file1<

    例程:

    265 char * name = "danny";

    266 std::ofstream logfile("log.dat");

    267 logfile<

    2,使用析取器(>>)读文件

    从流中输入数据。比如说系统有一个默认的标准输入流(cin),一般情况下就是指的键盘,所以,cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。

    例程:

    std::ifstream readfile("log.dat");

    string name_01;

    readfile>>name_01;

    cout<

    //结果输出:danny

    -------------------------------------------

    (2)文本或二进制数据的读写:

    1,使用put()写数据

    put()函数向流写入一个字符,其原型是ofstream &put(char ch),使用也比较简单,如file1.put('c');就是向流写一个字符'c'。

    2,使用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个字符时终止。

    例程:

    std::ifstream readfile("log.dat");

    char ch = NULL;

    while(readfile.get(ch))

    {

    cout<

    }

    结果:

    char is :

    char is :d

    char is :a

    char is :n

    char is :n

    char is :y

    char is :

    -------------------------------------------结果输出结束

    3,使用getline(fstream &fs,string & str)方法,读取文件到str

    ‍例程:

    std::ifstream readfile("log.dat");

    string name_02;

    while(getline(readfile,name_02))

    {

    cout<

    }

    结果为:

    value is :

    value is :danny

    (3)读写数据块:

    要读写二进制数据块,使用成员函数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();

    (4)检测EOF

    成员函数eof()用来检测是否到达文件尾,如果到达文件尾返回非0值,否则返回0。原型是int eof();

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

    (5)文件定位

    和C的文件操作方式不同的是,C++ I/O系统管理两个与一个文件相联系的指针。一个是读指针,它说明输入操作在文件中的位置;另一个是写指针,它下次写操作的位置。每次执行输入或输出时,相应的指针自动变化。所以,C++的文件定位分为读位置和写位置的定位,对应的成员函数是 seekg()和 seekp(),seekg()是设置读位置,seekp是设置写位置。它们最通用的形式如下:

    fstream &seekp(seek_dir origin);

    ‍              fstream &seekp(streamoff offset,seek_dir origin);

    ‍               ifstream &seekg(seek_dir origin);

    ifstream &seekg(streamoff offset,seek_dir origin);

    ofstream &seekp(seek_dir origin);

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

    在BCB中也提供了文件操作的函数,这些函数的功能和前面所介绍的大致相同,但这类函数和BCB关系紧密,能使用BCB中的AnsiString等数据类型,在BCB中用这种方式的文件操作是最方便的,下面我就把这种文件操作详细介绍。

    http://blog.csdn.net/luhifeng/article/details/6433589

    展开全文
  • C++中fstream

    2022-03-02 16:05:12
    fstream> 包括进来以使用任何fstream。 如果只执行输入,使用ifstream类; 如果只执行输出,使用 ofstream类; 如果要对流执行输入和输出,使用fstream类。可以将文件名称用作构造函数参数。 ofstream: ...

    将文件<fstream> 包括进来以使用任何fstream。

    如果只执行输入,使用ifstream类;

    如果只执行输出,使用 ofstream类;

    如果要对流执行输入和输出,使用fstream类。可以将文件名称用作构造函数参数。

    ofstream: Stream class to write on files.

    ifstream: Stream class to read from files.

    fstream: Stream class to both read and write from/to files.

     These classes are derived directly or indirectly from the classes istream and ostream.

    对这些类的一个对象所做的第一个操作通常就是将它和一个真正的文件联系起来,也就是说打开一个文件。被打开的文件在程序中由一个流对象(stream object)来表示 (这些类的一个实例) ,而对这个流对象所做的任何输入输出操作实际就是对该文件所做的操作。

     要通过一个流对象打开一个文件,可以使用它的成员函数open()或直接通过构造函数。

     void open (constchar * filename, openmode mode);

     这里filename 是一个字符串,代表要打开的文件名,mode 是以下标志符的一个组合:

     ios::in  以输入(读)方式打开文件;

     ios::out  以输出(写)方式打开文件;

     ios::ate  初始位置:文件尾,文件打开后定位到文件尾;

     ios::app  以追加的方式打开文件,所有输出附加在文件末尾;

     ios::trunc  如果文件已存在则先删除该文件;

     ios::binary  二进制方式,以二进制方式打开文件;

     这些标识符可以被组合使用,中间以”或”操作符(|)间隔。

    ofstream类的默认打开方式是: ios::out | ios::trunc ;

    ifstream 类的默认打开方式是ios::in;

    fstream类的默认打开方式是: ios::in | ios::out

    seekg()是对输入流的操作 g是get缩写
    seekp()是对输出流的操作 p是put缩写

    seekg()
    Moves the read position in a stream.//移动在流中读的位置
    ------------------------------------------------------------------------
    basic_istream<Elem, Tr>& seekg(  //一个参数
        pos_type pos
    );
    basic_istream<Elem, Tr>& seekg(
        off_type off,                                     //两个参数
        ios_base::seekdir way
    );
    ------------------------------------------------------------------------
    参数
    pos :The absolute position in which to move the read pointer.
    //移动读取指针的绝对位置

    off //偏移量
    An offset to move the read pointer relative to way.

    way //  基地址
    One of the ios_base::seekdir enumerations.
    它有三个取值
    ios::beg:表示输入流的开始位置
    ios::cur:表示输入流的当前位置
    ios::end:表示输入流的结束位置

     示例

    #include <iostream>
    #include <fstream>
    #include <string>
    #include <cstdlib>
    #include <vector>
     
    #include "fstream.hpp"
     
    /* reference: 
    	http://www.tutorialspoint.com/cplusplus/cpp_files_streams.htm
    	https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp10_IO.html
    	http://www.bogotobogo.com/cplusplus/fstream_input_output.php
    */
     
    int test_file_size()
    {
    	std::ifstream in("E:/GitCode/Messy_Test/testdata/fstream_data.bin", std::ios::binary);
    	if (!in.is_open()) {
    		std::cout << "fail to open file\n";
    		return -1;
    	}
     
    	std::streampos begin, end;
    	begin = in.tellg();
    	in.seekg(0, std::ios::end);
    	end = in.tellg();
     
    	in.close();
     
    	std::cout << "this file's size is: " << (end - begin) << " bytes.\n";
     
    	return 0;
    }
     
    int test_fstream1()
    {
    	char data[100];
     
    	// open a file in write mode.
    	std::ofstream outfile;
    	outfile.open("E:/GitCode/Messy_Test/testdata/fstream.dat");
    	if (!outfile.is_open()) {
    		std::cout << "fail to open file to write\n";
    		return -1;
    	}
     
    	std::cout << "Writing to the file" << std::endl;
    	std::cout << "Enter your name: ";
    	std::cin.getline(data, 100);
     
    	// write inputted data into the file.
    	outfile << data << std::endl;
     
    	std::cout << "Enter your age: ";
    	std::cin >> data;
    	std::cin.ignore();
     
    	// again write inputted data into the file.
    	outfile << data << std::endl;
     
    	// close the opened file.
    	outfile.close();
     
    	// open a file in read mode.
    	std::ifstream infile;
    	infile.open("E:/GitCode/Messy_Test/testdata/fstream.dat");
    	if (!infile.is_open()) {
    		std::cout << "fail to open file to read\n";
    		return -1;
    	}
     
    	std::cout << "Reading from the file" << std::endl;
    	infile >> data;
     
    	// write the data at the screen.
    	std::cout << data << std::endl;
     
    	// again read the data from the file and display it.
    	infile >> data;
    	std::cout << data << std::endl;
     
    	// close the opened file.
    	infile.close();
     
    	return 0;
    }
     
    int test_fstream2()
    {
    	/* Testing Simple File IO (TestSimpleFileIO.cpp) */
    	std::string filename = "E:/GitCode/Messy_Test/testdata/test.txt";
     
    	// Write to File
    	std::ofstream fout(filename.c_str());  // default mode is ios::out | ios::trunc
    	if (!fout) {
    		std::cerr << "error: open file for output failed!" << std::endl;
    		abort();  // in <cstdlib> header
    	}
    	fout << "apple" << std::endl;
    	fout << "orange" << std::endl;
    	fout << "banana" << std::endl;
    	fout.close();
     
    	// Read from file
    	std::ifstream fin(filename.c_str());  // default mode ios::in
    	if (!fin) {
    		std::cerr << "error: open file for input failed!" << std::endl;
    		abort();
    	}
    	char ch;
    	while (fin.get(ch)) {  // till end-of-file
    		std::cout << ch;
    	}
    	fin.close();
    	return 0;
    }
     
    int test_fstream3()
    {
    	/* Testing Binary File IO (TestBinaryFileIO.cpp) */
    	std::string filename = "E:/GitCode/Messy_Test/testdata/test.bin";
     
    	// Write to File
    	std::ofstream fout(filename.c_str(), std::ios::out | std::ios::binary);
    	if (!fout.is_open()) {
    		std::cerr << "error: open file for output failed!" << std::endl;
    		abort();
    	}
    	int i = 1234;
    	double d = 12.34;
    	fout.write((char *)&i, sizeof(int));
    	fout.write((char *)&d, sizeof(double));
    	fout.close();
     
    	// Read from file
    	std::ifstream fin(filename.c_str(), std::ios::in | std::ios::binary);
    	if (!fin.is_open()) {
    		std::cerr << "error: open file for input failed!" << std::endl;
    		abort();
    	}
    	int i_in;
    	double d_in;
    	fin.read((char *)&i_in, sizeof(int));
    	std::cout << i_in << std::endl;
    	fin.read((char *)&d_in, sizeof(double));
    	std::cout << d_in << std::endl;
    	fin.close();
     
    	return 0;
    }
     
    int test_fstream4()
    {
    	std::string theNames = "Edsger Dijkstra: Made advances in algorithms, the semaphore (programming).\n";
    	theNames.append("Donald Knuth: Wrote The Art of Computer Programming and created TeX.\n");
    	theNames.append("Leslie Lamport: Formulated algorithms in distributed systems (e.g. the bakery algorithm).\n");
    	theNames.append("Stephen Cook: Formalized the notion of NP-completeness.\n");
     
    	std::ofstream ofs("E:/GitCode/Messy_Test/testdata/theNames.txt");
    	if (!ofs)	{
    		std::cout << "Error opening file for output" << std::endl;
    		return -1;
    	}
    	ofs << theNames << std::endl;
    	ofs.close();
     
    	char letter;
    	int i;
    	std::string line;
     
    	std::ifstream reader("E:/GitCode/Messy_Test/testdata/theNames.txt");
     
    	if (!reader) {
    		std::cout << "Error opening input file" << std::endl;
    		return -1;
    	}
     
    	//for (i = 0; !reader.eof(); i++) {
    	while (!reader.eof()) {
    		reader.get(letter);
    		std::cout << letter;
     
    		//getline( reader , line ) ;
    		//std::cout << line << std::endl;
    	}
     
    	reader.close();
     
    	return 0;
    }
     
    //
    std::ofstream _file;
     
    int test_init_database()
    {
    	_file.open("E:/GitCode/Messy_Test/testdata/data.bin");
    	if (!_file.is_open()) {
    		fprintf(stderr, "open file fail\n");
    		return -1;
    	}
     
    	return 0;
    }
     
    int test_store_database()
    {
    	for (int i = 0; i < 10; ++i) {
    		_file.write((char*)&i, sizeof(i));
    	}
     
    	return 0;
    }
     
    int test_close_database()
    {
    	_file.close();
    	return 0;
    }
     
    int test_fstream5()
    {
    	test_init_database();
     
    	for (int i = 0; i < 5; ++i) {
    		test_store_database();
    	}
     
    	test_close_database();
     
    	std::ifstream file("E:/GitCode/Messy_Test/testdata/data.bin");
    	if (!file.is_open()) {
    		fprintf(stderr, "open file fail\n");
    		return -1;
    	}
     
    	int a[100];
    	for (int i = 0; i < 50; ++i) {
    		file.read((char*)&a[i], sizeof(int));
    	}
     
    	file.close();
     
    	return 0;
    }
     
    //
    static void parse_string(char* line, std::string& image_name, std::vector<int>& rect)
    {
    	std::string str(line);
    	rect.resize(0);
     
    	int pos = str.find_first_of(" ");
    	image_name = str.substr(0, pos);
    	std::string str1 = str.substr(pos + 1, str.length());
    	for (int i = 0; i < 4; ++i) {
    		pos = str1.find_first_of(" ");
    		std::string x = str1.substr(0, pos);
    		str1 = str1.erase(0, pos+1);
    		rect.push_back(std::stoi(x));
    	}
    }
     
    int test_fstream6()
    {
    	std::string name{ "E:/GitCode/Messy_Test/testdata/list.txt" };
    	std::ifstream in(name.c_str(), std::ios::in);
    	if (!in.is_open()) {
    		fprintf(stderr, "open file fail: %s\n", name.c_str());
    		return -1;
    	}
     
    	int count{ 0 };
    	char line[256];
    	in.getline(line, 256);
    	count = atoi(line);
    	std::cout << count << std::endl;
    	//while (!in.eof()) {
    	for (int i = 0; i < count; ++i) {
    		in.getline(line, 256);
    		std::cout << "line: "<< line << std::endl;
    		std::string image_name{};
    		std::vector<int> rect{};
    		parse_string(line, image_name, rect);
    		std::cout << "image name: " << image_name << std::endl;
    		for (auto x : rect)
    			std::cout << "  " << x << "  ";
    		std::cout << std::endl;
    	}
     
    	in.close();
    	return 0;
    }
     
    //
    int test_fstream7()
    {
    	std::string name{ "E:/GitCode/Messy_Test/testdata/list.txt" };
    	std::ifstream in(name.c_str(), std::ios::in);
    	if (!in.is_open()) {
    		fprintf(stderr, "open file fail: %s\n", name.c_str());
    		return -1;
    	}
     
    	int count{ 0 };
    	std::string image_name{};
    	int left{ 0 }, top{ 0 }, right{ 0 }, bottom{ 0 };
    	in >> count;
    	std::cout << "count: " << count << std::endl;
    	for (int i = 0; i < count; ++i) {
    		in >> image_name >> left >> top >> right >> bottom;
    		fprintf(stdout, "image_name: %s, rect: %d, %d, %d, %d\n", image_name.c_str(), left, top, right, bottom);
    	}
     
    	in.close();
    	return 0;
    }

    展开全文
  • C语言头文件 FSTREAM

    2022-06-11 12:17:23
    C语言头文件 FSTREAMC语言头文件 FSTREAMC语言头文件 FSTREAMC语言头文件 FSTREAMC语言头文件 FSTREAMC语言头文件 FSTREAMC语言头文件 FSTREAMC语言头文件 FSTREAMC语言头文件 FSTREAMC语言头文件 FSTREAMC语言...
  • fstream头文件

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

    2020-12-19 03:59:36
    #include 头文件fstream包含了ifstream、ofstream、fstream三个类,可以通过定义这三个类的对象来实现相对应的文件操作。#include ofstream //文件写操作,内存写入存储设备ifstream //文件读操作,存储设备读取到...
  • 文件输入输出类
  • fstream

    2018-02-28 16:14:40
    fstream&gt; ofstream //文件写操作,内存写入存储设备(文件) 输出流 ifstream //文件读操作,存储设备到内存. 输入流 fstream //读写操作,对打开的文件可进行读写. 前两者的结合头文件 &lt; fstr...
  • C++文件流fstream相关操作 一、理解Open函数 利用fstream,使用open/close打开或创建,完成后关闭,对文件读入读出使用插入器(<<) 或析取器(>>)完成。参考C++文件写入、读出函数。 函数void open(…)...
  • Fstream: Managing Flash Sreams in the File System PPT
  • fstream读写文件

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

    千次阅读 2020-08-26 10:43:54
     在C++中,对文件的操作是通过stream的子类fstream(file stream)来实现的,所以,要用这种方式操作文件,就必须加入头文件fstream.h。下面就把此类的文件操作过程一一道来。 一、打开文件 在fstream类中,有一个...
  • fstream:节点的高级FS流

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

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

    千次阅读 2020-06-15 09:28:30
    在C++中,对文件的操作是通过stream的子类fstream(file stream)来实现的,所以,要用这种方式操作文件,就必须加入头文件fstream.h。 一、打开文件 在fstream类中,有一个成员函数open(),就是用来打开文件的,其...
  • c++中fstream的使用

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 91,490
精华内容 36,596
关键字:

fstream