I/O流的設計

C++通用框架的設計 作者：naven

1           I/O流介紹

I/O流，即輸入/輸出流（Input/Output Stream），是軟件框架中的核心系統。對程序設計語言設計者來說，設計一個令人滿意的I/O系統，是件極艱巨的任務，也是不可缺少的基礎設施。C++的標準模板庫已經提供一套很不錯的I/O流庫了，但是我還是喜歡Java和.Net框架提供的那樣的使用簡單且擴展性強的I/O系統，而且還需要自行做一些改進已融入到C++通用框架體系中，由于I/O系統是框架的基礎設施，所以設計它是很關鍵的任務。

本框架的I/O系統設計宗旨與Java的I/O系統設計初衷略有不同（Java I/O的設計原是為了防止classes膨脹，可是事與愿違），主要目標一是要讓使用更簡單，二是讓擴展更簡單。本I/O系統參考Java I/O設計，有InputStream/OutputStream和Reader/Writer兩部分的類，但是含義略有不同，本I/O系統的InputStream/OutputStream定義為流設備，可將系統中任何設備或者內存或者內存中的對象當作輸入/輸出流設備，它們實現I/O系統最底層的輸入/輸出的基本操作。而Reader/Writer定義為流設備的讀寫器，它實現對InputStream/OutputStream的流設備的讀寫功能，可以組裝和擴展讀寫功能，提供豐富的讀寫操作符。下面介紹一下I/O流主要的類：

主要有如下一些類

class AbstractFile                                  表示I/O設備（如File、Socket等）的Abstract基類

class File                                                 文件設備，表示系統的文件、目錄等

class InputStream                                           表示輸入流設備的Abstract基類

class FileInputStream                           表示文件輸入流設備

class SocketInputStream                      表示Socket輸入流設備

class StringBufferInputStream            表示String對象輸入流設備

class OutputStream                                        表示輸出流設備的Abstract基類

class FileOutputStream                        表示文件輸出流設備

class SocketOutputStream                   表示Socket輸出流設備

class StringBufferOutputStream         表示String對象輸出流設備

class SystemFileOutputStream           表示系統文件（STDOUT等）輸出流設備

class ConsoleOutputStream                表示系統控制臺輸出流設備

class STDERROutputStream               表示系統STDERR輸出流設備

class STDOUTOutputStream              表示系統STDOUT輸出流設備

class Reader                                                     表示讀操作器的Abstract基類

class BufferedReader                            表示緩沖的讀操作器

class FileReader                                     表示文件的讀操作器

class InputStreamReader                     把輸入流設備當作的讀操作器

class SocketReader                               表示Socket的讀操作器

class StringReader                                表示String對象的讀操作器

class Writer                                                      表示寫操作器的Abstract基類

class BufferedWriter                             表示緩沖的寫操作器

class FileWriter                             表示文件的寫操作器

class OutputStreamWriter                    把輸出流設備當作的寫操作器

class SocketWriter                                表示Socket的寫操作器

class StringWriter                                  表示String對象的寫操作器

2           Hello World!

下面的程序示例如何用上面的類進行讀寫操作：

void main() 
{
    // 定義一個文件的讀操作器，它將自動創建文件輸入流設備
    FileReader fr("c:\\temp\\test.txt"); 
    
    // 通過讀操作器構造一個緩沖的讀操作器
    BufferedReader rd(fr); 
    String s; 

    // 一行行讀取文件內容，并輸出
    // 注意：每一行自動帶“\r\n”
while( rd.readLine(s) > 0 ) {
    // 截掉后面的 \r\n 字符
       s.rtrimChars(“\r\n”);
        printf("%s\r\n", s.c_str()); 
    }

}

各個讀寫操作器還可以組合使用，跟Java的用法類似。

3           AbstactFile類

它描述了一個可進行輸入輸出操作的設備的通用公共的Abstract抽象基類，如文件、目錄、Socket等。它定義了一些公共的成員和方法，如果錯誤號等，還定義了一些子類必須實現的接口，即純虛方法，所以它是一個Abstract類。它的定義看起來如下所示：

class AbstractFile
{
public: 

    /**//**
     * Tests whether the application can read the file denoted by this
     * abstract pathname.
     *
     */
    virtual BOOL canRead() = 0; 

    /**//**
     * Tests whether the application can modify to the file denoted by this
     * abstract pathname.
     *
     */
    virtual BOOL canWrite() = 0; 

    /**//**
     * Tests whether the application can modify and read the file denoted by this
     * abstract pathname.
     *
     */
    virtual BOOL canReadWrite() = 0; 

};

4           File類

File類是描述操作系統的文件和目錄的類，可讀取文件的一些屬性信息，如創建時間、大小等，也可以通過此類修改這些信息。備注：目錄的一些功能還未完全實現。下面的程序展示了通過它來獲取文件的屬性信息：

    File file("C:\\Temp\\main.txt"); 

    printf("\n-----File--------\n" 
        "path = %s name = %s parent = %s\n" 
        "isAbsolute = %d absolutePath = %s\n" 
        "exists = %d canRead = %d canWrite = %d canReadWrite = %d\n" 
        "isDirectory = %d isFile = %d\n" 
        "lastModified = %d length= %d\n" 
        "lastModified time = %s\n", 
        file.getPath().c_str(), // 路徑
        file.getName().c_str(), // 文件名
        file.getParent().c_str(), // 父級目錄
        file.isAbsolute(),      // 是否絕對路徑
        file.getAbsolutePath().c_str(), // 絕對路徑
        file.exists(), file.canRead(), file.canWrite(), file.canReadWrite(), 
        file.isDirectory(), file.isFile(), // 是否文件或目錄
        file.lastModified(), // 最近修改時間
        file.length(), // 文件長度
        tff.format(file.lastModified()).c_str()); // 最近修改時間

5           InputStream類

它描述了一個輸入流設備的通用公共的Abstract抽象基類，每一種數據源都有相應的InputStream子類，如文件輸入流、Socket輸入流、字符串輸入流等。它跟AbstractFile類似，定義公共的方法，也定義了一些子類需要實現的接口。InputStream流設備實現的接口均是最基礎的操作，如讀取一個byte字節的數據，或者讀取指定長度的數據，它的定義看起來如下所示：

class InputStream 
{
protected: 
    /**//**
     * Offset for the file handle from origin.
     */
    long _position; 

    /**//** 
     * Is this stream closed? 
     */
    BOOL _closed;

public: 
    
    /**//**
     * Report position in input stream.
     */ 
    virtual long tellp() { return _position; } 

    /**//**
     * Returns the number of bytes that can be read (or skipped over) 
     * from this input stream without blocking by the next caller of 
     * a method for this input stream. 
     */ 
    virtual int available() = 0; 
    
    /**//**
     * Reads the next byte of data from the input stream. 
     */
    virtual int read() = 0; 
    
    /**//**
     * Reads some number of bytes from the input stream and stores 
     * them into the buffer array b.
     */
    virtual int read(void *b, int len) = 0; 
    
    /**//**
     * Reads up to len bytes of data from the input stream into 
     * an array of bytes.
     */
    virtual int read(void *b, int off, int len) = 0; 
    
    /**//**
     * Skips over and discards n bytes of data from this input stream. 
     */
    virtual long skip(long n) = 0; 

    /**//**
     * Closes this input stream and releases any system resources 
     * associated with the stream. 
     */
    virtual void close() = 0; 
    
};

6           OutputStream類

與InputStream輸入流相對應，它描述了一個輸出流設備的通用公共的Abstract抽象基類，每一種數據源都有相應的OuputStream子類，如文件輸出流、Socket輸出流、字符串輸出流等。它的接口定義看起來如下所示：

class OutputStream 
{
protected: 
    /**//**
     * Offset for the file handle from origin.
     */
    long _position; 

    /**//** 
     * Is this stream closed? 
     */
    BOOL _closed;

public: 
    
    /**//**
     * Report position in output stream.
     */ 
    virtual long tellp() { return _position; } 
    
    /**//**
     * Flushes this output stream and forces any buffered 
     * output bytes to be written out.
     */
    virtual void flush() = 0; 
    
    /**//**
     * Writes len bytes from the specified byte array to 
     * this output stream. 
     */ 
    virtual OutputStream& write(const void *b, int len) = 0; 
    
    /**//**
     * Writes len bytes from the specified byte array to 
     * this output stream. 
     */ 
    virtual OutputStream& write(const void *b, int off, int len) = 0; 

    /**//**
     * Writes the specified byte to this output stream. 
     */ 
    virtual OutputStream& write(int b) = 0; 
    
    /**//**
     * Closes this output stream and releases any system 
     * resources associated with this stream. 
     */ 
    virtual void close() = 0; 
    
};

7           Reader類

它描述了一個對流設備的讀操作器的通用公共的Abstract抽象基類，每一種輸入流設備都有相應的讀操作器，如文件讀操作器、Socket讀操作器、字符串讀操作器等。它的定義與Java有所區別，Java里的Reader主要用于“相容于Unicode并基于字符”的數據源的讀取操作，而本系統的Reader是用于所有輸入流設備進行的讀操作。另外某些Reader可以通過另一個Reader來進行創建，以實現比較復雜的讀取操作，如帶緩沖的或一行行的讀取。

它的接口定義看起來如下所示：

class Reader 
{
public: 

    /**//**
     * Check this stream if is closed. 
     */
    BOOL isClosed(); 

    /**//**
     * Report position in input stream.
     */ 
    virtual long tellp() = 0; 

    /**//**
     * Read a single character. 
     */
    virtual int read() = 0; 

    /**//**
     * Read characters into a portion of an array. 
     */
    virtual int read(char *cbuf, int len) = 0; 

    /**//**
     * Read characters into a portion of an array.  
     */
    virtual int read(char *cbuf, int off, int len) = 0; 

    /**//**
     * Reads up to <code>len</code> bytes of data from this input stream
     * into an array of bytes. 
     */
    int read(String &b, int len); 

    /**//**
     * Reads up to <code>len</code> bytes of data from this input stream
     * into an array of bytes. 
     */
    int read(String &b, int off, int len); 

    /**//**
     * Skip characters.
     */
    virtual long skip(long n) = 0; 

    /**//**
     * Tell whether this stream is ready to be read.
     */
    virtual BOOL ready(); 

    /**//**
     * Tell whether this stream supports the mark() operation. 
     */
    virtual BOOL markSupported(); 

    /**//**
     * Mark the present position in the stream. 
     */
    virtual BOOL mark(int readAheadLimit); 

    /**//**
     * Reset the stream. 
     */
    virtual void reset(); 

    /**//**
     * Close the stream. 
     */
    virtual void close(); 

};

8           Writer類

與Reader對應，它描述了一個對流設備的寫操作器的通用公共的Abstract抽象基類，每一種輸出流設備都有相應的寫操作器，如文件寫操作器、Socket寫操作器、字符串寫操作器等。同樣，它也是用于所有輸出流設備進行的寫操作。某些Writer也可以通過另一個Writer來進行創建，以實現比較復雜的寫操作，如帶緩沖的寫操作。

考慮到C++的特性，本Writer還實現了所有的Operator<<操作符，所以可以進行與C++標準庫類似的格式化輸出，如下所示：

    FileWriter fw("c:\\temp\\test.txt"); 

    fw << "This is the NOTICE log message" 
       << 123456 << "    " 
       << String("fdsafdas  ");

它的接口定義看起來如下所示：

class Writer 
{
public: 
    /**//**
     * Check this stream if is closed. 
     */
    BOOL isClosed(); 

    /**//**
     * Report position in output stream.
     */ 
    virtual long tellp() = 0; 

    /**//**
     * Write a single character.
     */
    virtual Writer& write(int c) = 0; 

    /**//**
     * Write an array of characters.
     */
    virtual Writer& write(const char *cbuf) = 0; 

    /**//**
     * Write a portion of an array of characters.
     */
    virtual Writer& write(const char *cbuf, int len) = 0; 

    /**//**
     * Write a portion of an array of characters.
     */
    virtual Writer& write(const char *cbuf, int off, int len) = 0; 

    /**//**
     * Write a string.
     */
    virtual Writer& write(String &str) = 0; 

    /**//**
     * Write a portion of a string.
     */
    virtual Writer& write(String &str, int len) = 0; 

    /**//**
     * Write a portion of a string.
     */
    virtual Writer& write(String &str, int off, int len) = 0; 

    /**//**
     * Flush the stream. 
     */
    virtual void flush(); 

    /**//**
     * Close the stream. 
     */
    virtual void close(); 

};

9           InputStreamReader類和OuputStreamWriter類

這是兩個特殊讀寫操作器類，它的設計是運用Bridge模式，可以將一個InputStream流設備或OuputStream流設備轉換成一個Reader或一個Writer。所以讀取文件的操作，通過它們也可以如下實現：

void main() 
{
    FileInputStream fis("c:\\temp\\test.txt"); 
    
    InputStreamReader isr(fis); 
    
    BufferedReader rd(isr); 
    String s; 

    while( rd.readLine(s) > 0 ) {
        printf("%s\r\n", s.c_str()); 
    }

}

C++通用框架的設計 作者：naven 日期：2005-11-9