前言

数据是怎么写道磁盘的？

代码里面我们一个读写调用似乎就能将数据从磁盘读写。仿佛代码是直接和磁盘打交道。以我们最常见的笔记本、或台式机的磁盘SATA盘为例，其受南桥上ATA控制器支配，这里面传输的ATA指令。至少我们代码里面是没有处理这部分的，所以我们代码直接操控磁盘说不通。现实情况是，C++通过IO流库和磁盘打交道。

IO流库

C++语言中并没有输入/输出语句，而是在标准库里包含了一个I/O流类库，它与标准模板库同为C++标准库中最重要的组成部分。数据从一个对象到另一个对象的传送被抽象为“流”。数据的输入/输出就是通过输入/输出流来实现的。 流是一种抽象的概念，负责在数据的产生者和数据的使用者之间建立联系，并管理数据的流动。

流类体系

整个流类体系是一个派生类体系。按ANSI C++标准，类ios是抽象类，它的析构函数是虚函数，它的构造函数为保护的，作为所有基本流类的基类。

　　

ios提供了对流进行格式化输入输出和错误处理的成员函数。所有派生都是公有派生。

istream类提供完成提取（输入）操作的成员函数

ostream类提供完成插入（输出）操作的成员函数。

iostream类是前两者的组合。

streambuf是一个独立的类，只是ios有一个保护访问限制的指针指向它。streambuf的作用是管理一个流的缓冲区。

 

在流类库中，最重要的两部分功能为：

①标准输入/输出（standard input/output）

②文件处理

在C++的流类库中定义了四个全局流对象，可以完成人机交互的功能（要使用这四个功能，必须包含<iostream.h>文件。）：

①cin 标准输入流对象，键盘为其对应的标准设备。带缓冲区

②cout 标准输出流对象，显示器为标准设备。带缓冲区，一旦错误发生立即显示。

③cerr   标准错误输出流，输出设备是显示器。非缓冲区

④clog   标准错误输出流，输出设备是显示器。带缓冲区

输入输出格式控制

C++在类ios中提供格式化输入输出。这些格式是对所有文本方式的输入输出流均适用。格式控制符定义为公有的无名的枚举类型：

1 enum{ skipws=0x0001,    //跳过输入中的空白字符 2    left=0x0002,                 //输出左对齐 3    right=0x0004,        //输出右对齐 4    internal=0x0008,            //在输出符号或数制字符后填充 5    dec=0x0010,                    //在输入输出时将数据按十进制处理 6    oct=0x0020,                    //在输入输出时将数据按八进制处理 7    hex=0x0040,                    //在输入输出时将数据按十六进制处理 8    showbase=0x0080,            //在输出时带有表示数制基的字符 9    showpoint=0x0100,        //输出浮点数时,必定带小数点10    uppercase=0x0200,    //输出十六进制,用大写11    showpos=0x0400,        //输出正数时,加”+”号12    scientific=0x0800,        //科学数方式输出浮点数13    fixed=0x1000,        //定点数方式输出实数14    unitbuf=0x2000,        //插入后,立即刷新流15    stdio=0x4000}            //插入后,立即刷新stdout和stderr16 17

1 #include
      
        2 using namespace std; 3  4 void main() 5 { 6     for (int i=1; i <=10; ++i) 7     { 8         for (int j = 1; j <= 10; ++j) 9         {10             cout.width(5);11             cout.flags(ios::left);12             cout << i * j;13         }14         cout << endl;15     }16 }
      

该枚举量说明中每一个枚举量实际对应两字节数据（16位）中的一个位，所以可以同时采用几个格式控制，只要把对应位置1即可，这样既方便又节约内存。取多种控制时，用或“|”运算符来合成，合成为一个长整型数，在ios中为：

1 protected:2     long x_flags;

类ios中还设置了三个输入输出流格式控制标志：

1 protected:2    int x_precision;     //标志浮点数精度,缺省为6位3    int x_width;          //输出域宽,缺省域宽为0，4    //重设域宽只对其后第一输出项有效,如域宽不足,则不受限制5    char x_fill;            //标志域宽有富余时填入的字符

流操作子（setiosflags stream manipulator）

可代替流格式控制成员函数，但绝大多数流操作子VC++不支持

#include
      
       using namespace std;void main(){    int a = 12345678;    cout << hex << a << endl;}
      

文件的输入输出

这里的文件指的是磁盘文件。C++根据文件（file）内容的数据格式，可分为两类：二进制文件和文本文件。文本文件由字符序列组成，也称ASCII码文件，在文本文件中存取的最小信息单位为字符（character），而二进制文件中存取的最小信息单位为字节（Byte）。

文件的使用步骤

①声明一个文件流对象，这又被称为内部文件：

ifstream ifile；//只输入用

ofstream ofile；//只输出用

fstream iofile；//既输入又输出用

②使用文件流对象的成员函数打开一个磁盘文件。这样在文件流对象和磁盘文件名之间建立联系。文件流中说明了三个打开文件的成员函数。

void ifstream::open(const char*,int =ios::in,int=filebuf::openprot);void ofstream::open(const char *,int=ios::out,int=filebuf::opernprot);void fstream::open(const char*,int,int=filebuf::openprot);

第一个参数为要打开的磁盘文件名。

第二个参数为打开方式，有输入（in），输出（out）等，打开方式在ios基类中定义为枚举类型。

文件打开方式是在ios类中定义的，公有枚举成员：

enum open_mode{            in=0x01, //打开文件用于输入操作(从文件读取)，文件指针在文件头    out=0x02, /*打开文件用于写入文件。如文件不存在，则建立，但指定目录必须存在，否则建立文件失败。如文件存在，未同时设app,ate,in则文件清空*/                                               ate=0x04,//打开文件用于输入/输出,文件指针在文件尾,但新数据可写到任何位置      app=0x08, //打开文件用于输出,但从尾部添加,新数据只能添加在尾部    trunce=0x10, //打开文件,并清空它,以建立新文件    nocreate=0x20, //如文件存在则打开,不存在并不创建新文件    noreplace=0x40,//如文件不存在则创建,如文件存在则只能设为ate及app方式    binary=0x80  //以二进制方式打开文件};

第三个参数为指定打开文件的保护方式，一般取缺省。

三个文件流类都重载了一个带缺省参数的构造函数，功能与open函数一样：

ifstream::ifstream(const char*,int=ios::in,int=filebuf::openprot);ofstream::ofstream(const char*,int=ios::out,int=filebuf::openprot);fstream::fstream(const char*,int,int=filebuf::operprot);

所以1，2两步可合成：

fstream iofile(“myfile.txt”,ios::in|ios::out）;

打开文件也应该判断是否成功，若成功，文件流对象值为非零值，不成功为0（NULL），文件流对象值物理上就是指它的地址。

因此打开一个文件完整的程序为：

fstream iofile（”myfile.txt”,ios::in|ios::out）;if(!iofile){
    //失败退回操作系统    cout<<”不能打开文件:”<<”myfile,txt”<

③使用提取（>>）和插入（<<）运算符对文件进行读写操作，或使用成员函数进行读写

④关闭文件。三个文件流类各有一个关闭文件的成员函数 

void ifstream::close();void ofstream::close();void fstream::close();

使用很方便，如：iofile.close();

关闭文件时，系统把该文件相关联的文件缓冲区中的数据写到文件中，保证文件的完整，收回与该文件相关的内存空间，可供再分配，把磁盘文件名与文件流对象之间的关联断开，可防止误操作修改了磁盘文件。如又要对文件操作必须重新打开。关闭文件并没有取消文件流对象，该文件流对象又可与其他磁盘文件建立联系。文件流对象在程序结束时，或它的生命期结束时，由析构函数撤消。它同时释放内部分配的预留缓冲区。

代码演示

#include
      
       #include
       
        using namespace std;int main(){    int ar[] = {
    1,2,3,4,5,6,7,8,9};    //1    ofstream ofile;    //2    ofile.open("test.txt",ios::out);    if (!ofile)    {        cerr << "Open File Fail!" << endl;        exit(1);    }    //3    for (int i = 0; i < sizeof(ar) / sizeof(int);++i)    {        //cout<
        
         <<" ";        ofile << ar[i] << " ";    }    ofile.close();    return 0;}
        
       
      

#include
      
       #include
       
        using namespace std;int main(){    int ar[] = {
    1,2,3,4,5,6,7,8,9};    ofstream ofile("test.txt", ios::out);    if (!ofile)    {        cerr << "Open File Fail!" << endl;        exit(1);    }    //3    for (int i = 0; i < sizeof(ar) / sizeof(int);++i)    {        //cout<
        
         <<" ";        ofile << ar[i] << " ";    }    ofile.close();    return 0;}
        
       
      

再见文件内容读入到数组

#include
      
       #include
       
        using namespace std;int main(){    int ar[9];    ifstream ifile("test.txt", ios::out);    if (!ifile)    {        cerr << "Open File Fail!" << endl;        exit(1);    }    //3    for (int i = 0; i < sizeof(ar) / sizeof(int);++i)    {        //cout<
        
         <<" ";        ifile >> ar[i];    }    ifile.close();    return 0;}
        
       
      

二进制文件读写

C++提供了对二进制文件进行读取的成员函数：

istream&istream::read(char *,int); //从二进制流提取istream&istream::read(unsigned char*,int);istream&istream::read(signed char *,int);

第一个参数指定存放有效输入的变量地址

第二个参数指定提取的字节数

C++提供了对二进制文件进行写入的成员函数：

ostream&ostream::write(const char *,int);    ostream&ostream::write(const unsigned char *,int);ostream&ostream::write(const signed char *,int);

第一个参数指定输出对象的内存地址

第二个参数指定插入的字节数

之前用循环每次像数组读取一个字符，速度很慢。可以采用二进制读取，在读取二进制文件之前需要构造二进制文件。

1 #include
      
        2 #include
       
         3 using namespace std; 4 int main() 5 { 6     int ar[] = { 1,2,3,4,5,6,7,8,9 }; 7     int br[9]; 8     ofstream ofile("test.txt", ios::out|ios::binary); 9     if (!ofile)10     {11         cerr << "Open File Fail!" << endl;12         exit(1);13     }14     ofile.write((char*)ar,sizeof(ar));15     ofile.close();16     ifstream ifile("test.txt", ios::in | ios::binary);17     if (!ifile)18     {19         cerr << "Open File Fail!" << endl;20         exit(1);21     }22     ifile.read((char*)br, sizeof(br));23     return 0;24 }
       
      

读函数并不能知道文件是否结束，可用状态函数int ios::eof()来判断文件是否结束。必须指出系统是根据当前操作的实际情况设置状态位，如需根据状态位来判断下一步的操作，必须在一次操作后立即去调取状态位，以判断本次操作是否有效。

使用二进制文件，可以控制字节长度，读写数据时不会出现二义性，可靠性高。同时不知格式是无法读取的，保密性好。

文件结束后，系统不会再读，但程序不会自动停下来，所以要判断文件中是否已没有数据。

如写完数据后没有关闭文件，直接开始读，则必须把文件定位指针移到文件头。

如关闭文件后重新打开，文件定位指针就在文件头。

文件随机访问

C++把每一个文件都看成一个有序的字节流，每一个文件或者以文件结束符（end of file marker）结束，或者在特定的字节号处结束。 

当打开一个文件时，该文件就和某个流关联起来了。对文件进行读写实际上受到一个文件定位指针（file position pointer）的控制。

输入流的指针也称为读指针，每一次提取操作将从读指针当前所指位置开始，每次提取操作自动将读指针向文件尾移动。

输出流指针也称写指针，每一次插入操作将从写指针当前位置开始，每次插入操作自动将写指针向文件尾移动。

在C++中可以由程序移动文件指针，从而实现文件的随机访问，即可读写流中任意一段内容。一般文本文件很难准确定位，所以随机访问多用于二进制文件。

在ios类中说明了一个公有枚举类型：

enum seek_dir{    beg=0, //文件开头    cur=1, //文件指针的当前位置    end=2 //文件结尾};

 istream类中提供了如下三个成员函数：

istream&istream::seekg(streampos); //指针直接定位istream&istream::seekg(streamoff, ios::seek_dir); //指针相对定位long istream::tellg(); //返回当前指针位置

流的指针位置类型streampos和流的指针偏移类型streamoff定义为长整型，也就是可访问文件的最大长度为4G

datafile.seekg(-20L,ios::cur);表示将文件定位指针从当前位置向文件头部方向移20个字节。datafile.seekg(20L,ios::beg);表示将文件定位指针从文件头向文件尾方向移20个字节。datafile.seekg(-20L,ios::end);表示将文件定位指针从文件尾向文件头方向移20个字节。tellg()和seekg()往往配合使用。指针不可以移到文件头之前或文件尾之后。

ostream类也提供了三个成员函数管理文件定位指针，它们是：

ostream&ostream::seekp(streampos);ostream&ostream::seekp(streamoff,ios::seek_dir);long ostream::tellp();

为了便于记忆，函数名中g是get的缩写，而p是put的缩写。

借助二进制读写优化文件读取，代码演示

#include
      
       #include
       
        using namespace std;int main(){    int ar[] = {
    12,23,34,45,56,67,78,89,90,100};    ofstream ofile("test.txt", ios::out|ios::binary);    if (!ofile)    {        cerr << "Open File Fail!" << endl;        exit(1);    }    ofile.write((char*)ar, sizeof(ar));    ofile.close();    ifstream ifile;    ifile.open("test.txt", ios::in | ios::binary);    if (!ifile)    {        cerr << "Open File Fail!" << endl;        exit(1);    }    int pos;    int value;    while (1)    {        cout << "请输入位置：>" << endl;        cin >> pos;        ifile.seekg((long)(pos * sizeof(int)), ios::beg);        ifile.read((char*)&value, sizeof(int));        cout << "value = " << value << endl;    }    ifile.close();    return 0;}
       
      

文件与对象

在面向对象的程序设计中，信息总是放在对象的数据成员里。这些信息最终应该保存到文件中。当程序开始运行时，就要根据打开的文件重新创建对象。在运行过程中，放在对象的数据成员里的信息得到利用和修改。运行结束时必须把这些信息重新保存到文件中，然后关闭文件。

磁盘文件打开时建立的内部文件流是在运行时动态分配的资源。在面向对象的C++程序设计中，文件应该在构造函数中打开，并创建对象；而在析构函数中保存和关闭文件，并撤销对象。这样，与动态安排的其他资源一样，当撤销对象时，能自动释放资源。特别在程序发生异常时，C++系统有异常处理机制，该机制要求动态分配的资源是在类对象中，这样C++保证退出异常点时资源得到完整的释放。

对文件而言，释放资源同时包括将对象中的信息再次存入磁盘文件。在程序运行过程中，应该将信息适时保存到相应的磁盘文件中，以免数据意外丢失。

代码演示

1 #include
      
        2 #include
       
         3 using namespace std; 4  5 class Complex; 6 ostream& operator<<(ostream &out, const Complex &c); 7 class Complex 8 { 9     friend ostream& operator<<(ostream &out, const Complex &c);10 public:11     Complex() :m_real(0), m_img(0)12     {13         ifstream ifile;14         ifile.open("data.dat",ios::in);15         if (!ifile)16         {17             cerr << "Open File Fail" << endl;18             exit(1);19         }20         ifile >> m_real >> m_img;21         ifile.close();22     }23     Complex(int real, int imag)24     {25         m_real = real;26         m_img = imag;27     }28     ~Complex()29     {30         ofstream ofile;31         ofile.open("data.dat", ios::in);32         if (!ofile)33         {34             cerr << "Open File Fail" << endl;35             exit(1);36         }37         ofile << m_real <<" "<< m_img;38         ofile.close();39     }40     void SetComplex(int real, int imag)41     {42         m_real = real;43         m_img = imag;44     }45 private:46     int m_real;47     int m_img;48 };49 50 ostream& operator<<(ostream &out, const Complex &c)51 {52     out << "(" << c.m_real << "," << c.m_img << ")" << endl;53     return out;54 }55 56 int main()57 {58     Complex c;59     cout << c << endl;60     c.SetComplex(10, 60);61     cout << c << endl;62     return 0;63 }