精华内容
下载资源
问答
  • c++文件输入输出
    千次阅读
    2022-03-24 19:16:48

    文件输入/输出流类

    C++ 提供以下类来执行文件的字符输出和输入:

    • ofstream:写入文件的流类
    • ifstream:从文件中读取的流类
    • fstream:流类以读取和写入文件。
    表5: 文件读写模式
    读写模式意义
    ios::in打开输入操作(ifstream的默认模式)。
    ios::out打开以进行输出操作(ofstream的默认模式)。
    ios::binary以二进制模式打开。
    ios::ate在文件末尾设置初始位置。 如果未设置此标志,则初始位置是文件的开头。
    ios::app所有输出操作都在文件末尾执行,将内容附加到文件的当前内容。
    ios::trunc如果打开文件以进行输出操作并且它已经存在,则删除其先前的内容并用新的内容替换。
    表6:ios_base 标识的组合意义
    ios_base 标识意义C模式
    in读取 (文件必须存在)“r”
    out清空之后改写 (有必要才产生)“w”
    out | trunc清空之后改写 (有必要才产生)“w”
    out | app添加 (有必要才产生)“a”
    in | out读和写: 最初位置在起始点 (文件必须存在)“r + ”
    in | out | trunc先清空, 再读写 (有必要才产生)“w+”
    ofstream:写入文件的流类
    例8:输出文本文件
    #include <iostream>
    #include <iomanip>
    #include <vector>
    #include <string>
    #include <fstream>
    
    int main()
    {
        std::vector<std::string> fruit{ "火龙果","梨" };
        std::vector<double> price{ 3.02,4.51 };
        //使用输出至显示器
        std::cout << "水果名 单价\n" << std::setiosflags(std::ios::left);
        for (int i = 0; i < 2; ++i)
        {
            std::cout << std::setw(8) << fruit[i];
            std::cout << std::setw(6) << price[i];
            std::cout << std::endl;
        }
        // 使用文件输出流类ofstream的文件对象fout将数据输出到文本文件price.txt
        std::ofstream fout; //文件输出流类ofstream对象fout需要程序员自己定义
        fout.open("price.txt",std::ios::out);//打开文件price.txt,如文件不存在则创建新文件
        fout << "水果名 单价\n" << std::setiosflags(std::ios::left);
        for (int i = 0; i < 2; ++i)
        {
            fout << std::setw(8) << fruit[i];
            fout << " ";
            fout << std::setw(6) << price[i];
            fout << std::endl;
        }
        fout.close(); //关闭所打开的文件price.txt
        return 0;
    }
    

    结果:

    水果名 单价
    火龙果  3.02
    梨      4.51
    
    例9:输出二进制文件
    #include <iostream>
    #include <iomanip>
    #include <string.h>
    #include <fstream>
    
    int main()
    {
        char *fruit[] = { "火龙果","梨" };
        double price[] = { 3.02,4.51 };
        char str[7];
        //使用文件对象fout将数据输出到二进制文件price.dat
        std::ofstream fout; //文件输出流类ofstream对象fout需要程序员自己定义
        fout.open("price.dat",std::ios::out|std::ios::binary);//以二进制模式打开文件price.dat,如文件不存在则创建新文件
        for (int i = 0; i < 2; ++i)
        {
            strcpy(str,fruit[i]);
            fout.write(str,sizeof(str));//输出水果名
            fout.write((char*)(&price[i]),sizeof(double));//输出价格
        }
        fout.close(); //关闭所打开的文件price.dat
        return 0;
    }
    
    
    ifstream:从文件中读取的流类
    例10:输入文本文件
    #include <iostream>
    #include <fstream>
    
    int main()
    {
        char fruit[20];
        double price;
        std::ifstream fin; //使用文件输入流类ifstream的文件对象fin从文本文件price.txt中输入数据
        fin.open("price.txt"); //打开文本文件
        if(fin.is_open()==false) //检查打开文件是否成功
            std::cout<<"打开文件price.txt失败"<<std::endl;
        else
        {
            fin.getline(fruit,19); //读出标题行
            std::cout<<fruit<<std::endl; //显示所读出的标题行,显示结果:水果名称单价
    
            for(int i=0;i<2;++i)
            {
                fin>>fruit>>price; //从文件price.txt中读取水果名称和单价
                std::cout<<fruit<<","<<price<<std::endl; //显示水果名称和单价,验证输入结果
            }
            fin.close(); //关闭所打开的文件price.txt
        }
    
        return 0;
    }
    
    

    结果:

    水果名 单价
    火龙果,3.02
    梨,4.51
    
    例11:输入二进制文件
    #include <iostream>
    #include <iomanip>
    #include <fstream>
    
    int main()
    {
        char name[20];
        double num;
        std::ifstream fin; 
        fin.open("price.dat",std::ios::in |std::ios::binary);
        for (int i = 0; i < 2; ++i)
        {
            fin.read(name,7);
            fin.read((char*)(&num),8);
            std::cout<<name<<" "<<num<<std::endl;
        }
        fin.close(); //关闭所打开的文件price.dat
        return 0;
    }
    

    结果:

    火龙果 3.02
    梨 4.51
    
    表7:检查流的特定状态
    成员函数意义
    good检查是否没有发生错误,
    eof检查是否到达了文件末尾
    fail检查是否发生了可恢复的错误
    bad检查是否已发生不可恢复的错误
    例12:检查输入文件状态
    #include <iostream>
    #include <fstream>
    
    int main()
    {
        char ch;
        std::ifstream fin; //使用文件输入流类ifstream的文件对象fin从文本文件price.txt中输入数据
        fin.open("price.txt"); //打开文本文件
        while(true)
        {
            fin.get(ch); //从文件price.txt中每次读取一个字符
            //eof的返回值:true-文件已结束,false-文件未结束
         	//good的返回值:true-文件正常,false-文件已损坏
            if(fin.eof()==true||fin.good()==false)
                break; //结束文件输入
            std::cout <<ch; //显示所读出的字符ch
        }
        fin.close(); //关闭所打开的文件price.txt
        return 0;
    }
    
    

    结果:

    水果名 单价
    火龙果   3.02
    梨       4.51
    
    fstream:流类以读取和写入文件
    表 8: 文件定位标志
    模式标志描述
    ios::beg从文件头开始计算偏移量
    ios::end从文件末尾开始计算偏移量
    ios::cur从当前位置开始计算偏移量
    随机读写文件

    打开文件后,文件对象与外存文件建立起关联关系。此时,文件对象内部将保存当前读写数据的位置信息。该位置信息保存在被称作文件指针的数据成员中。文件输入流对象包含一个读文件指针,文件输出流对象包含一个写文件指针,而文件输入/输出流对象则分别包含一个读文件指针和一个写文件指针。
    通常情况下,打开文件后文件对象的读/写指针都定位于文件头的位置。每执行一次读/写操作,读/写指针将自动后移,移到下一次读/写数据的位置。这就是文件的顺序读/写。
    可以调用函数成员seekg和tellg来移动或读取读文件指针的位置,调用函数成员seekp知和tellp来移动或读取写文件指针的位置。程序员通过移动读/写指针,可实现对文件的随机读写。

    这4个与文件指针相关函数的原型如下:

    文件指针相关函数描述
    istream& seekg(long bytes,ios::seek dir origin )移动读文件指针
    long tellg()返回当前读文件指针的位置
    ostream& seekp(long bytes,ios::seek_dir origin )移动写文件指针
    long tellp()返回当前写文件指针的位置

    例13:随机读写文件

    #include <iostream>
    #include <fstream>
    
    int main()
    {
        char fruit[20];
        double price;
        std::ifstream fin; 
        fin.open("price.dat"); //打开二进制文件
        if(fin.is_open()==false) //检查打开文件是否成功
            std::cout<<"打开文件price.dat失败"<<std::endl;
        else
        {
            for(int i=0;i<2;++i)
            {
                fin.read(fruit,7); 
                //std::cout << fin.tellg() << '\n'; 
                fin.read((char*)&price,8);
                std::cout << fin.tellg() << '\n'; //当前读文件指针的位置
                std::cout<<fruit<<","<<price<<std::endl; //显示水果名称和单价,验证输入结果
            }
            fin.seekg(-30L,std::ios::end);//从文件尾向前(即往回)移动两行(一行有15个字节)
            fin.read(fruit,7); 
            std::cout<<fruit<<std::endl;
            fin.seekg(8L,std::ios::cur);//当前位置开始向后移动7个字节
            fin.read(fruit,7); 
            std::cout<<fruit<<std::endl;
            fin.close(); //关闭所打开的文件price.dat
        }
        return 0;
    }
    
    

    结果:

    15
    火龙果,3.02
    30
    梨,4.51
    火龙果
    梨
    

    参考资料:

    《大道至简—c++stl(标准模板库)精解》

    《c++语言程序设计》(第2版)

    http://c.biancheng.net/view/1541.html

    https://zh.cppreference.com/w/cpp/io/basic_fstream

    更多相关内容
  • C++文件输入输出,看这一篇就够了

    千次阅读 2022-04-30 21:56:11
    C++文件输入输出,看这一篇就够了 1 简介 1.1 继承关系 基类->继承类: ​ ios->ostream->ofstream ​ ios->istream->ifstream ​ iostream->fstream(还继承了两个缓冲区,一个用于输入,一个用于...

    1 简介

    1.1 继承关系

    基类->继承类:

    ​ ios->ostream->ofstream

    ​ ios->istream->ifstream

    ​ iostream->fstream(还继承了两个缓冲区,一个用于输入,一个用于输出)(此类用于文件I/O的同步,即协调地移动输入缓冲区的输入指针和输出缓冲区的输出指针)(输入输出模式时使用fstream类)

    1.2 流

    C++程序将文件输入和输出看作字符流;对于输入来说,程序从输入流中抽取字符,对于输出来说,程序向输出流中插入字符。流是程序与流源或流目的之间的中介,这样C++就可以对来源不同的字符做相同处理。

    1.3 缓冲区

    缓冲区就是一块存储空间,它是为了匹配程序处理速度和外设处理速度;比如程序一次处理1byte,但是磁盘一次读取512bytes;又或者程序一次处理1byte,可以1byte地从磁盘读取,但是由于硬件读取一次数据复杂且操作慢,因此使用缓冲区可以加快程序处理速度。

    flushing the buffer:刷新缓冲区就是清空缓冲区地内容以备下次使用。

    文件输出输入使用缓冲区,在声明每个ofsream or ifsream对象时程序会为其自动分配该对象自己的缓冲区;使用缓冲区可以提高文件输出速度。
    何时清空缓存:
    1.缓存区满时
    2.使用文件close()方法时,为了保证关闭文件时文件被更新。

    2 输入输出流状态

    流状态被定义为iostate,是由三个ios_base组成:eofbit, badbit, 和failbit,三者都为一位可以设置位1(设置)或0(清除)。当三者都为0时说明一切顺利。

    成员描述
    eofbit当读取文件到达文件尾时置为1
    failbit当输入流中的数据类型和目的数据类型不一致时置为1;I/O错误(读取一个不允许访问的只读磁盘或打开一个不存在的文件)时置为1
    badbit在一些无法诊断的失败破坏流时置为1
    goodbit另一种说明0的方法
    good()如果流可以使用,则返回true,反之返回false
    eof()如果eofbit被设置,则返回true,反之返回false
    bad()如果badbit被设置,则返回true,反之返回false
    fail()如果failbit或badbit被设置,返回true,反之返回false
    rdstate()返回流状态
    exceptions()返回一个位掩码,指出哪些标记导致异常被引发
    exceptions(iostate ex)设置哪些状态将导致clear()引发异常
    clear(iostate s)将流状态设置为s,s的默认值为0;如果rdstate() & exceptions()) != 0,将抛出basic_ios::failure异常;将会设置s,但是其他的会被置0
    setstate (iostate s)调用clear(rdstate()|s)。这将设置与s中设置的位对应的流的状态位,其他流状态保持不变。

    2.1 设置状态

    setstate()的主要目的是提供一种修改状态的途径。例如,如果num是一个int,则下面的调用将可能导致operator>>(int &)使用setstate()设置failbit或eofbit。

    clear();//清除所有的位
    clear(eofbit);//清楚指定的位
    setstate(eofbit);//设置指定的位
    //等等
    

    2.2 文件尾EOF

    文件尾 EOF
    如果输入来自于文件:使用文件尾(EOF)判断文件是否读完。
    当检测到EOF之后:cin将eofbit和failbit都设置为1;同时,将设置cin对象中的一个指示EOF条件的标记,设置这个标记后,cin将不读取输入,直到cin.clear()。
    EOF被定义为值为-1,因此不能将EOF赋给char类型,因为char类型没有符号,需要使用int类型接收EOF。

    举例:Windows允许通过键盘模拟文件尾:Ctrl+Z

    3 文件传输模式

    ios_base定义了openmode类型表示模式,类似于fmtflags和iostate类型,是bitmask类型。

    文件模式常量:

    ConstantMeaning
    ios_base::in读取文件
    ios_base::out写入文件
    ios_base::ate打开文件时文件指针指向文件尾
    ios_base::app在文件尾添加内容
    ios_base::trunc如果文件存在则截断它
    ios_base::binary二进制文件

    文件模式组合(|符号表示联合两个二进制为一个值,该值可以表达两个二进制模式)

    C++ 模式C模式含义
    ios_base::in“r”读文件模式
    ios_base::out“w”与ios_base::out | ios_base::trunc一样
    ios_base::out | ios_base::trunc“w”写文件模式,并且在打开文件时截断文件(将文件置为空)
    ios_base::out | ios_base::app“a”追加模式,将文件指针指向文件尾,向末尾添加内容;原始数据不可修改
    ios_base::in | ios_base::out“r+”打开以读写,在文件允许的位置写入
    ios_base::in | ios_base::out | ios_base::trunc“w+”打开以读写,如果文件已经存在,则首先截断文件
    c++mode | ios_base::binary“cmodeb”在C++模式和二进制模式打开
    c++mode | ios_base::ate“cmode”以指定的模式打开,并将文件指针移到文件尾。

    模式的使用方法:

    //第二个参数指定模式
    //ifstream fin(filename, c++mode);
    //fopen(filename, cmode);
    ifstream fin("banjo", mode1); // constructor with mode argument
    ofstream fout();
    fout.open("harp", mode2); // open() with mode arguments
    

    ifstream open()的默认模式为ios_base::in;

    ofstream open()的默认模式为ios_base::out | ios_base::trunc;

    fstream无默认模式,因此在创建fstream对象时要显示提高模式实参。

    4 相关函数

    4.1 ofstream对象 or ifstream对象.open(filename)

    可以接受C-风格字符串作为参数,也可以接受存储在数组中的字符串
    默认情况下,当filename所指文件不存在时,open()将在当前程序可执行目录创建名为filename的文件;
    作用:当存在时,open()将首先截断该文件,即删除原有的文件内容,然后再将新内容输出到文件中

    4.2 ofstream对象 or ifstream对象.close()

    作用:无参数,原因是ofstream对象 or ifstream对象已经关联文件,不需要参数;在关闭文件时,不会释放ofstream对象 or ifstream对象的缓冲区,只是解除了ofstream对象 or ifstream对象与文件的关联关系;ofstream对象 or ifstream对象可以重新与其他文件绑定。

    4.3 ofstream对象 or ifstream对象.isopen(filename)

    检查文件filename是否被成功打开;如果成功打开,则返回true;反之(文件不存在等原因),返回false。

    在流状态中的fin.fail()和fin.good()也能检查文件是否被正常打开,但是流状态相关函数不涉及文件传输模式;但是is_open()考虑了文件传输模式,因此is_open()更适用于检查文件是否正常打开。

    4.4 ifstream对象.get(char ch)

    作用:逐个字符获取文件中的内容,并将其赋值给ch;直到遇见文件尾。

    4.5 ofstream对象.write( (char *) &pl, size);

    第一个参数为要写入文件内容的地址(必须转换为char *类型),第二个参数为要写入内容的大小(单位为byte)。

    作用:将pl指向的大小为size的内容复制到ofstream对象绑定的文件中。

    注意事项:这个方法可以用于不含虚函数的类,原因是在这种情况下,只有数据成员被保存,而方法不会被保存;如果类有虚方法,则也将复制隐藏指针(该指针指向虚函数的指针表);由于下一次运行程序时,虚函数表可能在不同的位置,因此将文件中的旧指针信息复制到对象中,可能造成混乱。

    4.6 ifstream对象.read((char *) &pl, size);

    第一个参数为读入文件的存储地址(必须转换为char *类型),第二个参数为要读入内容的大小(单位为byte)。

    作用:将ifstream对象绑定的文件中大小为size的内容pl指向的地址。

    注意事项:这个方法可以用于不含虚函数的类,原因是在这种情况下,只有数据成员被保存,而方法不会被保存;如果类有虚方法,则也将复制隐藏指针(该指针指向虚函数的指针表);由于下一次运行程序时,虚函数表可能在不同的位置,因此将文件中的旧指针信息复制到对象中,可能造成混乱。

    4.7 fstream对象 or istream对象.seekg()

    将输入指针移动至给定文件位置(由于fstream对象使用缓冲区存取中间数据,因此指针指向的实际上是缓冲区的位置,而不是实际的文件)。

    也可以将seekg()用于ifstream对象。

    函数原型:

    第一个原型定位到离第二个参数指定的文件位置的偏移量(单位为字节)的位置,第一个参数off_type为偏移量,第二个参数ios_base::seekdir可以为三个常量—ios_base::beg(相对于文件开始处的偏移)、ios_base::cur(相对于文件当前位置的偏移)、ios_base::end(相对于文件结尾处的偏移);

    第二个原型定位到离文件开头特定距离(单位为字节)的位置,参数pos_type为偏移量。是一个绝对偏移量。

    //模板原型
    basic_istream<charT,traits>& seekg(off_type, ios_base::seekdir);
    basic_istream<charT,traits>& seekg(pos_type);
    //For the char specialization
    istream & seekg(streamoff, ios_base::seekdir);
    istream & seekg(streampos);//streampos包含一个接收streamoff参数的构造函数和一个接收整数参数的构造函数
    
    //eg
    fin.seekg(30, ios_base::beg); // 30 bytes beyond the beginning
    fin.seekg(-1, ios_base::cur); // back up one byte
    fin.seekg(0, ios_base::end); // go to the end of the file
    

    注意:streampos和streampos是off_type和pos_type对于char类型的专门化;同样,针对wistream对象,wstreampos和streamoff类型是off_type和pos_type对于wistream类型的专门化。

    4.8 fstream对象 or ostream对象.seekp()

    将输出指针移动至给定文件位置(由于fstream对象使用缓冲区存取中间数据,因此指针指向的实际上是缓冲区的位置,而不是实际的文件)。

    也可以将seekp()用于ofstream对象。

    将输出指针移动至给定文件位置(由于fstream对象使用缓冲区存取中间数据,因此指针指向的实际上是缓冲区的位置,而不是实际的文件)。

    也可以将seekp()用于ofstream对象。

    函数原型:

    第一个原型定位到离第二个参数指定的文件位置的偏移量(单位为字节)的位置,第一个参数off_type为偏移量,第二个参数ios_base::seekdir可以为三个常量—ios_base::beg(相对于文件开始处的偏移)、ios_base::cur(相对于文件当前位置的偏移)、ios_base::end(相对于文件结尾处的偏移);

    第二个原型定位到离文件开头特定距离(单位为字节)的位置,参数pos_type为偏移量。是一个绝对偏移量。

    //模板原型
    basic_istream<charT,traits>& seekp(off_type, ios_base::seekdir);
    basic_istream<charT,traits>& seekp(pos_type);
    //For the char specialization
    istream & seekp(streamoff, ios_base::seekdir);
    istream & seekp(streampos);//streampos包含一个接收streamoff参数的构造函数和一个接收整数参数的构造函数
    
    //eg
    fin.seekp(30, ios_base::beg); // 30 bytes beyond the beginning
    fin.seekp(-1, ios_base::cur); // back up one byte
    fin.seekp(0, ios_base::end); // go to the end of the file
    

    注意:streampos和streampos是off_type和pos_type对于char类型的专门化;同样,针对wistream对象,wstreampos和streamoff类型是off_type和pos_type对于wistream类型的专门化。

    4.9 fstream对象 or istream对象.tellg()

    返回值为streampos,表示输入指针的当前文件位置(单位为字节),相对于文件开始的偏移量。

    注意:如果创建了fstream对象,由于输入指针和输出指针将同时移动,因此tellg()和tellp()返回值相同;然而,如果使用istream对象来管理输入流,而使用ostream对象管理输出流,则输入指针和输出指针将彼此独立移动,tellg()和tellp()返回值将不同。

    4.10 fstream对象 or ostream对象.tellp()

    返回值为streampos,表示输出指针的当前文件位置(单位为字节),相对于文件开始的偏移量。

    注意:如果创建了fstream对象,由于输入指针和输出指针将同时移动,因此tellg()和tellp()返回值相同;然而,如果使用istream对象来管理输入流,而使用ostream对象管理输出流,则输入指针和输出指针将彼此独立移动,tellg()和tellp()返回值将不同。

    4.11 fstream对象 or ostream对象 or istream对象.seekg(偏移量)

    将文件指针指向距离文件开头 偏移量(单位为字节) 大小的位置。

    可以使用它将文件指针指向文件开头。

    5 简单文件输入输出

    5.1 写入到文本文件中

    步骤:

    • 1 包含fstream头文件,fstream头文件中定义了ofstream类用于处理输出
    • 2 包含std命名空间(ofstream在std命名空间中)
    • 3 定义一个或多个ofstream对象,命名要求符合命名规范,每个ofstream对象都与一个输出流绑定在一起
    • 4 将对象和文件关联起来,方法之一是open()方法,这种关联在对象释放时自动解除
    • 5 文件操作完成时,应使用close()方法关闭文件
    • 6 可以使用ofstream对象和<<操作符输出各种类型的数据,可以使用cout可使用的任何方法(cout使用方法见C++ cout的用法,看这一篇就够了)

    5.2 读取文本文件

    步骤:

    • 1 包含fstream头文件,fstream头文件中定义了ifstream类用于处理输入,ifstream与一个输入流绑定在一起
    • 2 包含std命名空间(ifstream在std命名空间中)
    • 3 定义一个或多个ifstream对象,命名要求符合命名规范,每个ofstream对象都与一个输入流绑定在一起
    • 4 将对象和文件关联起来,方法之一是open()方法
    • 5 文件操作完成时,使用close()方法关闭文件
    • 6 可以使用ifstream对象和>>操作符输出各种类型的数据,可以使用cin可使用的任何方法(cin使用方法见C++ cin的用法,看这一篇就够了)
    • 7 ifstream本身作为测试条件时,如果最后一个读取操作成功,ifstream将被转换为true,否则转换为false

    5.3 C++实例

    5.3.1 cpp代码

    /*
    Project name :			_26File
    Last modified Date:		2022年4月29日22点20分
    Last Version:			V1.0
    Descriptions:			简单文件输入输出
    */
    #include <iostream>
    #include <fstream> // for file I/O,这个头文件包含了iostream头文件,所以此处可以不显示包含iostream头文件
    #include <cstdlib> // support for exit()
    const int SIZE = 60;
    int main()
    {
    	using namespace std;
    	cout << "ofstream*********************************************************************" << endl;
    	char automobile[50];
    	int year;
    	double a_price;
    	double d_price;
    	string filename1;
    	cout << "Enter name for new file: ";
    	cin >> filename1;
    	while (cin.get() != '\n');
    	ofstream outFile; // create object for output
    	outFile.open(filename1.c_str()); // associate with a file  将文件和对象链接起来 
    	//创建对象和连接文件可以使用一个表达式实现:ofstream fout("jar.txt"); // create fout object, associate it with jar.txt
    	cout << "Enter the make and model of automobile: ";
    	cin.getline(automobile, 50);
    	cout << "Enter the model year: ";
    	cin >> year;
    	cout << "Enter the original asking price: ";
    	cin >> a_price;
    	d_price = 0.913 * a_price;
    	// display information on screen with cout
    	cout << fixed;
    	cout.precision(2);
    	cout.setf(ios_base::showpoint);
    	cout << "Make and model: " << automobile << endl;
    	cout << "Year: " << year << endl;
    	cout << "Was asking $" << a_price << endl;
    	cout << "Now asking $" << d_price << endl;
    	// now do exact same things using outFile instead of cout
    	outFile << fixed;
    	outFile.precision(2);
    	outFile.setf(ios_base::showpoint);
    	outFile << "Make and model: " << automobile << endl;
    	outFile << "Year: " << year << endl;
    	outFile << "Was asking $" << a_price << endl;
    	outFile << "Now asking $" << d_price << endl;
    	outFile.close(); // done with file
    	cout << "ifstream*********************************************************************" << endl;
    	while (cin.get() != '\n');
    	char filename[SIZE];
    	ifstream inFile; // object for handling file input
    	cout << "Enter name of data file: ";
    	cin.getline(filename, SIZE);
    	inFile.open(filename); // associate inFile with a file
    	//创建对象和连接文件可以使用一个表达式实现 ifstream inFile(filename);
    	if (!inFile.is_open()) // failed to open file
    	{
    		cout << "Could not open the file " << filename << endl;
    		cout << "Program terminating.\n";
    		exit(EXIT_FAILURE);//EXIT_FAILURE就是一个全局的常量
    		//exit():定义在头文件cstdlib,该头文件还定义了与操作系统通信的参数值EXIT_FAILURE
    	}
    	double value;
    	double sum = 0.0;
    	int count = 0; // number of items read
    	while (inFile>>value) // 判断读取是否成功,读取失败则退出循环
    	{
    		++count; // one more item read
    		sum += value; // calculate running total
    	}
    	//因此在这加两句读取最后一个数据
    	++count; // one more item read
    	sum += value; // calculate running total
    	//检查读取失败的原因
    	if (inFile.eof())
    		cout << "End of file reached.\n";
    	else if (inFile.fail())
    		cout << "Input terminated by data mismatch.\n";
    	else
    		cout << "Input terminated for unknown reason.\n";
    	if (count == 0)
    		cout << "No data processed.\n";
    	else
    	{
    		cout << "Items read: " << count << endl;
    		cout << "Sum: " << sum << endl;
    		cout << "Average: " << sum / count << endl;
    	}
    	inFile.close(); // finished with the file
    
    	return 0;
    }
    

    5.3.2 运行结果

    ofstream*********************************************************************
    Enter name for new file: list.txt
    Enter the make and model of automobile: mobile
    Enter the model year: 2022
    Enter the original asking price: 999
    Make and model: mobile
    Year: 2022
    Was asking $999.00
    Now asking $912.09
    ifstream*********************************************************************
    Enter name of data file: scores.txt
    End of file reached.
    Items read: 13
    Sum: 222.00
    Average: 17.08
    
    D:\Prj\_C++Self\_26File\Debug\_26File.exe (进程 5572)已退出,代码为 0。
    要在调试停止时自动关闭控制台,请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
    按任意键关闭此窗口. . .
    

    5.3.3 相关文件信息

    写入的文件内容:list.txt

    Make and model: mobile
    Year: 2022
    Was asking $999.00
    Now asking $912.09
    

    读入的文件内容:scores.txt

    18 19 18.5 13.5 14 16 19.5 20 18 12 18.5
    17.5
    

    6 命令行处理技术

    6.1 简介

    命令行处理程序经常使用命令行参数识别文件,命令行参数是指出现在当在command使用命令行时出现的参数。举例:

    wc report1 report2 report3
    此处wc是程序名,report1 report2 report3是文件名作为命令行参数传递给程序
    

    命令行处理技术也可以在main中使用:

    int main(int argc, char *argv[])
    //argc代表命令行中出现的参数个数,argv是指向 chart * 的指针;argv相当于指针数组,每个指针指向一个命令行参数;argv[0]是命令名,argv[1]指向第一个命令行参数字符串,以此类推
    

    注意事项:命令行参数与命令行操作系统息息相关;很多Windows IDEs提供了命令行参数的选项,如何打开需要研读相关说明文档;很多Windows IDEs都可以生成可执行我呢见,这些文件可以在Windows命令提示符模式下运行。

    6.2 C++实例

    6.2.1 代码

    项目_26_1file_command_arguments

    /*
    Project name :			_26_1file_command_arguments
    Last modified Date:		2022年4月30日09点53分
    Last Version:			V1.0
    Descriptions:			文件操作
    */
    
    #include <iostream>
    #include <fstream> // for file I/O,这个头文件包含了iostream头文件,所以此处可以不显示包含iostream头文件
    #include <cstdlib> // support for exit()
    int main(int argc, char* argv[])
    {
    	using namespace std;
    	
    	cout << "命令行处理技术**************************************************************" << endl;
    	if (argc == 1) // quit if no arguments
    	{
    		cerr << "Usage: " << argv[0] << " filename[s]\n";
    		exit(EXIT_FAILURE);
    	}
    	ifstream fin; // open stream
    	long count1;
    	long total = 0;
    	char ch;
    	for (int file = 1; file < argc; file++)
    	{
    		fin.open(argv[file]); // connect stream to argv[file]
    		if (!fin.is_open())
    		{
    			cerr << "Could not open " << argv[file] << endl;
    			fin.clear();
    			continue;
    		}
    		count1 = 0;
    		while (fin.get(ch))
    			count1++;
    		cout << count1 << " characters in " << argv[file] << endl;
    		total += count1;
    		fin.clear(); // needed for some implementations
    		fin.close(); // disconnect file
    	}
    	cout << total << " characters in all files\n";
    
    	return 0;
    }
    

    6.2.2 如何执行该代码

    首先在VS2022中编译该代码,生成_26_1file_command_arguments.exe可执行文件
    然后在cmd中找到_26_1file_command_arguments.exe可执行文件并执行以下语句将会得到以下结果:

    Microsoft Windows [版本 10.0.19044.1645]
    (c) Microsoft Corporation。保留所有权利。
    C:\Users\15495>d:
    D:\>cd D:\Prj\_C++Self\_26_1file_command_arguments\x64\Debug
    D:\Prj\_C++Self\_26_1file_command_arguments\x64\Debug>_26_1file_command_arguments.exe "list.txt" "carinfo.txt" "scores.txt"
    命令行处理技术**************************************************************
    Make and model: love
    Year: 2022
    Was asking $999.00
    Now asking $912.09
    70 characters in list.txt
    Make and model: kaaha
    Year: 2022
    Was asking $999.00
    Now asking $912.09
    71 characters in carinfo.txt
    18 19 18.5 13.5 14 16 19.5 20 18 12 18.5
    17.545 characters in scores.txt
    186 characters in all files
    
    D:\Prj\_C++Self\_26_1file_command_arguments\x64\Debug>
    

    6.3.3 相关文件信息

    carinfo.txt

    Make and model: kaaha
    Year: 2022
    Was asking $999.00
    Now asking $912.09
    

    list.txt

    Make and model: love
    Year: 2022
    Was asking $999.00
    Now asking $912.09
    

    scores.txt

    18 19 18.5 13.5 14 16 19.5 20 18 12 18.5
    17.5
    

    7 向文件追加内容(追加模式举例)

    7.1 代码

    /*
    Project name :			_26File
    Last modified Date:		2022年4月30日10点05分
    Last Version:			V1.0
    Descriptions:			向文件追加内容
    */
    
    #include <iostream>
    #include <fstream> // for file I/O,这个头文件包含了iostream头文件,所以此处可以不显示包含iostream头文件
    #include <cstdlib> // support for exit()
    #include <string>
    int main(int argc, char* argv[])
    {
    	using namespace std;
    	cout << "向文件追加内容*********************************************************************" << endl;
    	char ch;
    	const char* file = "guests.txt";
    	// show initial contents
    	ifstream fin;
    	fin.open(file);
    	if (fin.is_open())
    	{
    		cout << "Here are the current contents of the "
    			<< file << " file:\n";
    		while (fin.get(ch))
    			cout << ch;
    		fin.close();
    	}
    	// add new names
    	ofstream fout(file, ios::out | ios::app);//追加模式
    	if (!fout.is_open())
    	{
    		cerr << "Can't open " << file << " file for output.\n";
    		exit(EXIT_FAILURE);
    	}
    	cout << "Enter guest names (enter a blank line to quit):\n";
    	string name;
    	while (getline(cin, name) && name.size() > 0)
    	{
    		fout << name << endl;
    	}
    	fout.close();
    	// show revised file
    	fin.clear(); // not necessary for some compilers
    	fin.open(file);
    	if (fin.is_open())
    	{
    		cout << "Here are the new contents of the "
    			<< file << " file:\n";
    		while (fin.get(ch))
    			cout << ch;
    		fin.close();
    	}
    
    	return 0;
    }
    

    7.2 运行结果

    向文件追加内容*********************************************************************
    Here are the current contents of the guests.txt file:
    Jasmine
    lili
    bobo
    booooo
    boly
    Enter guest names (enter a blank line to quit):
    mama
    baba
    
    Here are the new contents of the guests.txt file:
    Jasmine
    lili
    bobo
    booooo
    boly
    mama
    baba
    

    8 二进制文件

    8.1 二进制文件与文本文件

    8.1.1 文本文件优缺点

    优点:

    • 易于阅读,可以使用文本编辑器或word阅读或修改文本文件
    • 文本文件在计算机之间容易传输

    缺点:如果将数字存储为文本格式的话,需要<<插入操作符将数字转换为字符才可存储到txt文件中。

    8.1.2 二进制格式文件优缺点

    优点:

    • 二进制格式对于数字来说更精确,因为它存储的是值的内部表示,因此不会有转换误差和舍入误差
    • 以二进制格式保存数据速度更快
    • 二进制格式占用空间更小

    缺点:二进制格式在计算机之间传输可能存在问题,因为不同计算机的内部存储格式可能不一样;这种情况下需要编写一个程序将一种数据格式转换为另一种数据格式。

    8.1.3 存储格式与文件格式

    使用二进制文件模式时,程序将数据从内存传输给文件(反之亦然)时,将不会发生任何隐藏的转换。

    Windows文本文件,使用回车和换行表示换行符;

    Mscintosh文本文件,使用回车表示换行符;

    UNIX和Linux文本文件,使用换行表示换行符;

    C++从UNIX发展而来,使用换行表示换行符;

    Windows C++程序在写文本文件时,自动将C++换行符转换为回车和换行;在读取文本文件时,将回车和换行转换为C++换行符。

    对于二进制数据,如果使用文本格式文件存储,可能会出现问题,double值中间的字节可能与换行符的ASCII码有相同的位模式;另外,文件尾的检测也存在区别;因此以二进制格式保存数据时,应使用二进制文件模式。

    8.2 C++实例

    8.2.1 代码

    /*
    Project name :			_26File
    Last modified Date:		2022年4月30日11点39分
    Last Version:			V1.0
    Descriptions:			二进制文件存储
    */
    
    #include <iostream>
    #include <fstream> // for file I/O,这个头文件包含了iostream头文件,所以此处可以不显示包含iostream头文件
    #include <cstdlib> // support for exit()
    #include <string>
    #include <iomanip>
    const int SIZE = 60;
    
    //用于二进制文件存储
    inline void eatline() { while (std::cin.get() != '\n') continue; }
    struct planet
    {
    	char name[20]; // name of planet
    	double population; // its population
    	double g; // its acceleration of gravity
    };
    
    int main()
    {
    	using namespace std;
    	cout << "二进制文件存储*******************************************************************" << endl;
    	char file[30] = "planets.dat";
    	planet pl;
    	cout << fixed << right;
    	// show initial contents
    	ifstream fin;
    	fin.open(file, ios_base::in | ios_base::binary); // binary file
    	//NOTE: some systems don't accept the ios_base::binary mode
    	if (fin.is_open())
    	{
    		cout << "Here are the current contents of the "
    			<< file << " file:\n";
    		while (fin.read((char*)&pl, sizeof pl))
    		{
    			cout << setw(20) << pl.name << ": "
    				<< setprecision(0) << setw(12) << pl.population
    				<< setprecision(2) << setw(6) << pl.g << endl;
    		}
    		fin.close();
    	}
    	// add new data
    	ofstream fout1(file, ios_base::out | ios_base::app | ios_base::binary);
    	//NOTE: some systems don't accept the ios::binary mode
    	if (!fout1.is_open())
    	{
    		cerr << "Can't open " << file << " file for output:\n";
    		exit(EXIT_FAILURE);
    	}
    	cout << "Enter planet name (enter a blank line to quit):\n";
    	cin.get(pl.name, 20);
    	while (pl.name[0] != '\0')
    	{
    		eatline();
    		cout << "Enter planetary population: ";
    		cin >> pl.population;
    		cout << "Enter planet's acceleration of gravity: ";
    		cin >> pl.g;
    		eatline();
    		fout1.write((char*)&pl, sizeof pl);
    		cout << "Enter planet name (enter a blank line to quit):\n";
    		cin.get(pl.name, 20);
    	}
    	fout1.close();
    	// show revised file
    	fin.clear(); // not required for some implementations, but won't hurt
    	fin.open(file, ios_base::in | ios_base::binary);
    	if (fin.is_open())
    	{
    		cout << "Here are the new contents of the "
    			<< file << " file:\n";
    		while (fin.read((char*)&pl, sizeof pl))
    		{
    			cout << setw(20) << pl.name << ": "
    				<< setprecision(0) << setw(12) << pl.population
    				<< setprecision(2) << setw(6) << pl.g << endl;
    		}
    		fin.close();
    	}
    
    	return 0;
    }
    

    8.2.2 运行结果

    二进制文件存储*******************************************************************
    Here are the current contents of the planets.dat file:
                   earth:          70.  9.98
    Enter planet name (enter a blank line to quit):
    viras
    Enter planetary population: 20
    Enter planet's acceleration of gravity: 6.77
    Enter planet name (enter a blank line to quit):
    
    Here are the new contents of the planets.dat file:
                   earth:          70.  9.98
                   viras:          20.  6.77
    
    D:\Prj\_C++Self\_26File\Debug\_26File.exe (进程 5992)已退出,代码为 0。
    要在调试停止时自动关闭控制台,请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
    按任意键关闭此窗口. . .
    

    9 随机存取

    9.1 简介

    随机存取指的是直接移动到文件的任何位置;常用于数据库文件,程序维护一个独立的索引文件,该文件指出数据在主数据文件中的位置。如果文件由长度相同的记录组成,这种方法实现起来最简单;每条记录表示一组相关的数据。

    9.2 随机位置输入输出实例–修改记录

    9.2.1 代码

    /*
    Project name :			_26File
    Last modified Date:		2022年4月30日21点49分
    Last Version:			V1.0
    Descriptions:			随机位置输入输出实例
    */
    
    #include <iostream>
    #include <fstream> // for file I/O,这个头文件包含了iostream头文件,所以此处可以不显示包含iostream头文件
    #include <cstdlib> // support for exit()
    #include <string>
    #include <iomanip>
    const int SIZE = 60;
    const int LIM = 20;
    
    //用于二进制文件存储
    inline void eatline() { while (std::cin.get() != '\n') continue; }
    struct planet
    {
    	char name[LIM]; // name of planet
    	double population; // its population
    	double g; // its acceleration of gravity
    };
    
    int main()
    {
    	using namespace std;
    	cout << "随机位置输入输出文件*********************************************************" << endl;
    	const char* file = "planets.dat";
    	planet pl;
    	cout << fixed;
    	// show initial contents
    	fstream finout; // read and write streams
    	finout.open(file,ios_base::in | ios_base::out | ios_base::binary);//输入输出模式打开
    	//NOTE: Some Unix systems require omitting | ios::binary
    	int ct = 0;
    	if (finout.is_open())
    	{
    		finout.seekg(0); // go to beginning
    		cout << "Here are the current contents of the " << file << " file:\n";
    		while (finout.read((char*)&pl, sizeof pl))
    		{
    			cout << ct++ << ": " << setw(LIM) << pl.name << ": "
    				<< setprecision(0) << setw(12) << pl.population
    				<< setprecision(2) << setw(6) << pl.g << endl;
    		}
    		if (finout.eof())
    			finout.clear(); // clear eof flag
    		else
    		{
    			cerr << "Error in reading " << file << ".\n";
    			exit(EXIT_FAILURE);
    		}
    	}
    	else
    	{
    		cerr << file << " could not be opened -- bye.\n";
    		exit(EXIT_FAILURE);
    	}
    	// change a record
    	cout << "Enter the record number you wish to change: ";
    	long rec;
    	cin >> rec;
    	eatline(); // get rid of newline
    	if (rec < 0 || rec >= ct)
    	{
    		cerr << "Invalid record number -- bye\n";
    		exit(EXIT_FAILURE);
    	}
    	streampos place = rec * sizeof pl; // convert to streampos type
    	finout.seekg(place); // random access 随机访问到指定位置
    	if (finout.fail())
    	{
    		cerr << "Error on attempted seek\n";
    		exit(EXIT_FAILURE);
    	}
    	finout.read((char*)&pl, sizeof pl);
    	cout << "Your selection:\n";
    	cout << rec << ": " << setw(LIM) << pl.name << ": "
    		<< setprecision(0) << setw(12) << pl.population
    		<< setprecision(2) << setw(6) << pl.g << endl;
    	if (finout.eof())
    		finout.clear(); // clear eof flag
    	cout << "Enter planet name: ";
    	cin.get(pl.name, LIM);
    	eatline();
    	cout << "Enter planetary population: ";
    	cin >> pl.population;
    	cout << "Enter planet's acceleration of gravity: ";
    	cin >> pl.g;
    	finout.seekp(place); // go back
    	finout.write((char*)&pl, sizeof pl) << flush;
    	if (finout.fail())
    	{
    		cerr << "Error on attempted write\n";
    		exit(EXIT_FAILURE);
    	}
    	// show revised file
    	ct = 0;
    	finout.seekg(0); // go to beginning of file
    	cout << "Here are the new contents of the " << file << " file:\n";
    	while (finout.read((char*)&pl, sizeof pl))
    	{
    		cout << ct++ << ": " << setw(LIM) << pl.name << ": "
    			<< setprecision(0) << setw(12) << pl.population
    			<< setprecision(2) << setw(6) << pl.g << endl;
    	}
    	finout.close();
    
    	return 0;
    }
    

    9.2.2 运行结果

    随机位置输入输出文件*********************************************************
    Here are the current contents of the planets.dat file:
    0:                earth:           70  9.98
    1:                 Boly:            4  9.99
    2:                earth:           80  9.98
    Enter the record number you wish to change: 2
    Your selection:
    2:                earth:           80  9.98
    Enter planet name: Jasminely
    Enter planetary population: 4
    Enter planet's acceleration of gravity: 9.99
    Here are the new contents of the planets.dat file:
    0:                earth:           70  9.98
    1:                 Boly:            4  9.99
    2:            Jasminely:            4  9.99
    
    D:\Prj\_C++Self\_26File\Debug\_26File.exe (进程 16340)已退出,代码为 0。
    要在调试停止时自动关闭控制台,请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
    按任意键关闭此窗口. . .
    

    10 生成不同的文件名

    10.1 简介

    //tmpnam函数生成临时文件名并将其放置到pszName指向的存储空间中;定义在头文件cstdio中的常量L_tmpnam限制了文件名包含的字符数,TMP_MAX限制了在生成文件名不重复的条件下tmpnam()函数可被调用的最多次数。
    char* tmpnam( char* pszName );
    

    10.2 代码

    #include <cstdio>
    #include <iostream>
    int main()
    {
    	using namespace std;
    	cout << "This system can generate up to " << TMP_MAX
    		<< " temporary names of up to " << L_tmpnam
    		<< " characters.\n";
    	char pszName[L_tmpnam] = { '\0' };
    	cout << "Here are ten names:\n";
    	for (int i = 0; 10 > i; i++)
    	{
    		tmpnam(pszName);
    		cout << pszName << endl;
    	}
    	return 0;
    }
    

    10.3 运行结果

    每次运行的结果不同。

    生成不同的文件名*************************************************************
    This system can generate up to 2147483647 temporary names of up to 260 characters.
    Here are ten names:
    C:\Users\15495\AppData\Local\Temp\u994.0
    C:\Users\15495\AppData\Local\Temp\u994.1
    C:\Users\15495\AppData\Local\Temp\u994.2
    C:\Users\15495\AppData\Local\Temp\u994.3
    C:\Users\15495\AppData\Local\Temp\u994.4
    C:\Users\15495\AppData\Local\Temp\u994.5
    C:\Users\15495\AppData\Local\Temp\u994.6
    C:\Users\15495\AppData\Local\Temp\u994.7
    C:\Users\15495\AppData\Local\Temp\u994.8
    C:\Users\15495\AppData\Local\Temp\u994.9
    
    D:\Prj\_C++Self\_26File\Debug\_26File.exe (进程 11992)已退出,代码为 0。
    要在调试停止时自动关闭控制台,请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
    按任意键关闭此窗口. . .
    
    展开全文
  • JAVA开发与应用输入输出流和文件.ppt
  • C++文件输入输出

    2012-05-17 17:02:43
    刚学习到这一部分,谭浩强的书介绍的很少,网上搜集了一下,顺便分享下
  • 至此你不需要配置任何其他东西,就可以在本地利用输入输出文件安心调试你的代码,调试后直接拷贝,提交到各大OJ平台即可 该代码真的超级好用 例如: #include using namespace std; typedef long long ll; int main...

    相信很多人都用过freopen,但是是不是有时候在网上提交代码的时候需要把这句话注释掉,我一开始也是这样的,但还是觉得很麻烦,有时忘记注释,会多错一次,让人很不爽。

    网上的资料很乱,什么代码都有,也不一定有效

    但经过我的摸索,你只需要在main函数的开头写上以下代码

    #ifdef ONLINE_JUDGE  
    #else
        freopen("in.txt","r",stdin);
        freopen("out.txt","w",stdout);
    #endif

    更简单地写法

    #ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    #endif
    

    ifndef相当于 if not def


    因为大部分OJ都预定义了宏ONLINE_JUDGE

    对于这种问题,大部分OJ系统是考虑到了这个问题,比如杭电的OJ系统,在FAQ里就有这个问题:
    Q:Is there any way to determine if my program is runned at Online Judge or not ?
    A:There is a conditional define of compiler called ONLINE_JUDGE. Example of using:
    C/C++

    #ifdef ONLINE_JUDGE
    running on online judge
    #else
    you can do something here on your local computer
    #endif

    又比如:


    当然你事先要在和当前cpp相同位置创建好in.txt和out.txt文件,用于输入数据和观察结果

    至此你不需要配置任何其他东西,就可以在本地利用输入输出文件安心调试你的代码,调试后直接拷贝,提交到各大OJ平台即可

    该代码真的超级好用


    例如:

    #include <bits/stdc++.h>
    
    using namespace std;
    
    typedef long long ll;
    
    int main(void) {
    
        #ifndef ONLINE_JUDGE
        freopen("in.txt", "r", stdin);
        #endif
    
        int T;
        cin >> T;
        for (int cnt = 0; cnt < T; cnt++) {
            string s1, s2, s;
            cin >> s1 >> s2 >> s;
            
            if (s.find(s1) == string::npos || s.find(s2) == string::npos) {
                cout << "case #" << cnt << ":"  << endl;
                cout << 0 << endl;
            } else {
                int res = 0;
                int a1 = s.find(s1), a2 = s.rfind(s1);
                int b1 = s.find(s2), b2 = s.rfind(s2);
    
                int s1tos2 = abs(a1 - b2) - (int)s1.size();
                if (s1tos2 < 0) {
                    s1tos2 = 0;
                }
                int s2tos1 = abs(a2 - b1) - (int)s2.size();
                if (s2tos1 < 0) {
                    s2tos1 = 0;
                }
    
                res = max(s1tos2, s2tos1);
    
                cout << "case #" << cnt << ":"  << endl;
                cout << res << endl;
            }
        }
    
        return 0;
    }
    

    阅读更多文章,请看学习笔记汇总

    展开全文
  • C/C++文件输入输出(详细介绍)

    万次阅读 多人点赞 2018-10-28 09:39:20
    ´在头文件iostream中定义有两个流类:输入流类istream和输出流类ostream,且用这两个类定义了流对象cin和cout: ´Istream cin; ´ostream cout; ´cin是一个istream类的对象,它从标准输入设备(键盘)获取数据,...

     如果有需要请关注下面微信公众号,会有更多收获!

    ´在头文件iostream中定义两个流类:输入流类istream和输出流类ostream,且用这两个类定义了流对象cincout:

    ´Istream cin;

    ´ostream cout;

    ´cin是一个istream类的对象,它从标准输入设备(键盘)获取数据,程序中的变量通过流提取符“>>”从流中提取数据。流提取符“>>”从流中提取数据时通常跳过输人流中的空格、tab键、换行符等空白字符。注意:只有在输入完数据再按回车键后,该行数据才被键盘缓冲区,形成输入流,提取运算符“>>”才能从中提取数据。注意保证从流中读取数据能正常进行

    ´cout是一个ostream类的对象,它有一个成员运算函数operator<<,每次调用的时候就会向输出设备输出。operator用运算符重载,可以接受不同类型的数据,如整型、浮点型、字符串甚至指针,等等cout是标准输出设备,一般输出到屏幕。

    在定义流对象时,系统会在内存中开辟一段缓冲区,用来暂存输入输出流的数据

     

    C++iostreamCprintf/scanf的区别

    ´1. 类型处理更安全、智能,printf中对付intfloat等说明符比较麻烦

    ´2. 扩展性更强,iostream使用的<<>>操作符都是可重载,只要重载相关的运算符就可以

    ´ 3. 流风格的写法也比较自然简洁

    ´4. printf/scanf的速度比cin/cout

     

    几个输入函数介绍:

    ´1cin.get()

    ´ cin.get(字符变量名)可以用来接收字符

    ´cin.get(字符数组名,接收字符数目)用来接收一行字符串,可以接收空格
    2cin.getline(接收字符串的变量,接收字符个数,结束字符)用法:接收一个字符串,可以接收空格并输出

    3getline()用法:接收一个字符串,可以接收空格并输出,需包含“#include<string>”

    ´注意:cin.getline()属于istream流,而getline()属于string流,是不一样的两个函

    文件I/O也称为读文件(输入)和写文件(输出),c++标准库中提供两个类ifstreamofstream,分别用于文件的输入和输出。

    .文件的写操作:

    写操作对应的有:<<putwrite 等,我们来看下他们分别都能实现什么样的写文件功能!

    ①、写文本类型/ASCII码类型的可见字符串:<<put

    int main(){
    
      short var = 20000;
    
      ofstream fs;
    
      fs.open("1.txt");
    
      if (!fs) return 0;
    
      fs << var << endl;
    
      fs << "文件写入" << endl;
    
      fs.put('Y');
    
      fs.close();
    
      return 0;
    
    }

    这就是写文本文件的方式,其中 << 支持的类型比较多,put 只能写单个字符到文件,还是有一定局限性的,所以 put 平时用的比较少

    参考网站:http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/

    C/C++重定向 标准输入输出的库函数

    ´所谓重定向输出,就是可以把原本只是输出在控制台的字符,输出到你指定的路径文件中。(输入类似,就是从指定的文件中读取,而不是读取在控制台中的输入。)重定向函数可以在任何时候开启、关闭

    ´函数名:freopen 

    ´标准声明:FILE *freopen( const char *path, const char *mode, FILE *stream ); 

    ´所在文件: <stdio.h>

    参数说明: path: 文件名,用于存储输入输出的自定义文件名。 mode: 文件打开的模式。和fopen中的模式(如r, w)相同。 stream: 一个文件,通常使用标准流文件。 返回值:成功,则返回一个path所指定文件的指针;失败,返回NULL。功能:实现重定向,把预定义的标准流文件定向到由path指定的文件中。标准流文件具体是指stdinstdoutstderr。其中stdin是标准输入流,默认为键盘;stdout是标准输出流,默认为屏幕;stderr是标准错误流,一般把屏幕设为默认

     

    输入一个正整数nn<100n从文件in.txt读入),n的阶乘(答案写入文件out.txt)。

    //c++语法
    #include<iostream>
    #include<stdio.h>
    using namespace std;
    int fac(int n){
    	return (n==1)? 1:n*fac(n-1);
    }
    int main(){
    	int n,m;
    	freopen("in.txt","r",stdin); //输入重定向,输入数据将从in.txt文件中读取 
    	freopen("out.txt","w",stdout); //输出重定向,输出数据将保存out.txt文件中 
    	while(cin>>n){
    		//m=fac(n);
    		cout<<"输入n的阶乘为:"<<fac(n)<<endl; // 注意使用endl 
    	}
    	fclose(stdin);//关闭重定向输入
    	fclose(stdout);//关闭重定向输出 
    	return 0;
    }
    //c语法
    #include<stdio.h>
    int fac(int n){
    	return (n==1)? 1:n*fac(n-1);
    }
    int main(){
    	int n,m;
    	freopen("in2.txt","r",stdin); //输入重定向,输入数据将从in.txt文件中读取 
    	freopen("out2.txt","w",stdout); //输出重定向,输出数据将保存out.txt文件中 
    	while(scanf("%d %d",&n,&m)!=EOF){
    		printf("n的阶乘为:%d\n",fac(n)); 
    	} 	
    	fclose(stdin);//关闭重定向输入
    	fclose(stdout);//关闭重定向输出 
    	return 0;
    }
    
    getline()该函数是从文件中读取一行数据,一行就是有换行符 \n,或者达到 getline 的缓冲区大小,或者读到文件末尾。
    #include <fstream>
    using namespace std;
    int main(int argc, char* argv[]){
        short var = 20000;
        ofstream fs_out;
        fs_out.open("d:\\123.txt");
        if (!fs_out) return 0;
        fs_out << var << endl;
        fs_out << var + 1 << endl;
        fs_out << var + 2 << endl;
        fs_out.close();
        ifstream fs_in;
        fs_in.open("d:\\123.txt");
        if (!fs_in) return 0;
        char sz[100] = { 0 };//缓存区
        fs_in.getline(sz, 100);
        fs_in.getline(sz, 100);
        fs_in.getline(sz, 100);
        fs_in.close();
        return 0;
    }
    
    //②、二进制类型写文件:write
    int main(){
    	short var = 20000;
    	ofstream fs;
    	fs.open("3.txt");
    	if (!fs) return 0;
    
    	fs.write((char*)&var, sizeof(var));
    	fs.close();
    	return 0;
    }
    
    //①、读文本类型/ASCII码类型的文件:>>、get、getline
    int main(){
    	short var = 20000;
    	ofstream fs_out;
    	fs_out.open("4.txt");
    	if (!fs_out) return 0;
    	fs_out << var << endl;
    	fs_out.close();
    	var = 3000;
    	ifstream fs_in;
    	fs_in.open("4.txt");
    	if (!fs_in) return 0;
    	fs_in >> var;
    	char ch = fs_in.get();
    	fs_in.close();
    	return 0;
    }

    闲鱼算法书PDF:有需要的同学可以看看:

     

    展开全文
  • 本文实例为大家分享了C++输入输出流及文件流操作笔记,供大家参考,具体内容如下 1、流的控制  iomanip 在使用格式化I/O时应包含此头文件。  stdiostream 用于混合使用C和C + +的I/O机制时,例如想将C程序...
  • C++实现简单的文件输入输出

    千次阅读 2022-03-18 20:10:09
    这样的输入输出有时候不能满足要求,这个时候需要我们读写文件来获得、存储我们的数据。 读文件或者写文件 大致分为5个步骤 包含头文件(fstream)-创建流-打开文件,使文件和流建立联系-读写操作-关闭文件 流的...
  • c++文件输入输出

    千次阅读 2022-03-14 09:58:45
    基于流的文件IO 头文件 ofstream : 写文件 ifstream : 读文件 fstream : 读写文件 using namespace std; //打开文件 std::ifstream fin("xxx.txt"); //std::ifstream fin; //fin.open("xxx.txt"); std::ofstream ...
  • C++文件输入输出

    千次阅读 2021-01-27 15:48:58
    文件输入输出在计算机的使用过程中非常的常见,这篇文章我们只介绍一些简单的输入输出,可以对文件进行基本的操作。首先来明确一下输入输出的概念: 输入输出是相对的,一般我们是一程序的控制台作为目标...
  • C++文件输入输出

    2013-09-02 17:18:01
    关于C++输入输出,并且给原有文档加上行号,输出到指定文档中。
  • c++简单文件输入/输出介绍

    千次阅读 2021-12-17 14:53:06
    有时候通过键盘输入并不是最好的选择,下面我将介绍写入到文本文件中和读取文本文件两种简单的文件输入输出。 写入到文本文件 1.必须包含头文件iostream。 2.头文件iostream定义了一个用处理输出的ostream类。 3....
  • C++文件输入输出

    万次阅读 2018-07-20 14:48:56
    c++中我们易知的是cout和cin俩个标准输入输出,而在真实的状况中。我们则是需要对文件的内容进行读取和重新写入,这样我们只有cin和cout这俩个标准输入和输出就明显的不够满足条件了。所以有一个fstream类中的...
  • c/c++文件输入输出语句

    千次阅读 2019-11-20 10:11:11
    读入读出文件: freopen("D:\\in.txt","r",stdin);//读入文件in.txt freopen("D:\\out.txt","w",stdout);//读出文件out.txt 关闭文件: fclose(stdin); fclose(stdout); 简单例子: #include<bits/stdc++...
  • C++输入输出

    千次阅读 2022-03-31 10:56:46
    C++用继承方法建立了I/O流类库,输入输出过程(input/output)称为流,输入是指将数据从输入设备保存到内存的过程,输出是指从内存传输到输入设备的过程
  • c++输入输出

    千次阅读 2022-03-23 10:15:11
    输出操作中,字节从内存流向设备(例如,显示屏、打印机、磁盘驱动器、网络连接等)。 应用程序通过字节传达信息。字节可以组成字符、原始数据、图形图像、数字语音、数字视频或者任何应用程序所需要的其他信息。...
  • C++文件输入输出流及标准I/O流类知识总结

    万次阅读 多人点赞 2018-10-13 23:42:06
    在学习使用C++进行STL模型文件的读写与显示时,遇到了一些文件读取的问题,在网上找了很多资料,有些写的比较模糊,自己也遇到了很多坑,在参考以前大神的资料基础上,C++文件流及I/O流相关知识进行了一些总结。...
  • C++如何输入/输出

    千次阅读 2022-05-05 12:51:33
    C++有两种方式输入/输出,分别是C++风格的iostream和C风格的stdio,其实没什么不同 先来介绍第一种,iostream 头文件:iostream(#include<iostream>) iostream输出的写法:cout<<你要输出的变量1的...
  • C++文件输入输出流fstream的用法

    千次阅读 2021-03-24 19:52:40
    C++的IO类中定义了三个文件读写流fstream、ifstream以及ofstream,它们都继承于相同的父类istream,通过不同的实现以实现不同的文件流操作。 三者的区别为: ifstream:从文件读取数据 ofstream:从文件写入数据 ...
  • C++语言的输入输出.ppt
  • c++文件输入输出基本操作

    千次阅读 2018-05-06 20:41:34
    ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间 在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O. stream这个类有两个重要的运算符:...
  • c++文件输入输出重定向到文件中

    千次阅读 2019-05-20 21:42:58
    #include using namespace std; int a[11][38];... freopen("1.txt","r",stdin);...如果你不想输入输出文件了,就加上一句 freopen("CON","r",stdin ); 对应输入 freopen("CON","w",stdout); 对应输出
  • C/C++文件输入输出代码演示

    千次阅读 2020-03-07 22:22:46
    1.重定向 ...//从in.txt读入整数n和字符串sg,将其输出n次到out.txt中 //代码与文件放在一个文件夹中 int main(){ freopen("in.txt","r",stdin); freopen("out.txt","w",stdout); int n; st...
  • C++ 中的基本输入/输出

    千次阅读 2022-07-03 12:53:06
    C++ 中的基本输入/输出
  • C++输入流和输出流(超级详细)

    千次阅读 2022-02-13 09:31:32
    C++输入流和输出流(超级详细) C++ 又可以称为“带类的 C”,即可以理解为 C++ 是 C 语言的基础上增加了面向对象(类和对象)。在此基础上,学过 C 语言的读者应该知道,它有一整套完成数据读写(I/O)的解决方案:...
  • C++ 输入输出

    千次阅读 2021-04-06 20:08:31
    C++ 输入输出输入输出流基本概念 与输入输出流操作相关的类:类的继承关系从上往下如下图所示 istream:用于输入的流类,cin 是该类的对象 ostream:用于输出的流类,cout cerr clog 是该类的对象 ifstream:...
  • C++文件读写 #include #include //加载c++用于文件读写的头文件 ofstream outFile; //实例化ofstream类,创建outFile对象,outFile是对象名字,可以随便取,以后的操作就是对outFile对象进行的 outFile.open(...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 268,172
精华内容 107,268
关键字:

c++文件输入输出