C++快速文件輸入輸出

轉載請注明：

 

仰望高端玩家的小清新 http://www.cnblogs.com/luruiyuan/

 

C語言可以獲得接近匯編的性能，而輸入輸出常常是最為耗時的過程，因此可以使用 C 語言中的 fread 和 fwrite 來獲得最高的讀寫性能。

例如，可以將其寫在源碼文件中直接使用：不建議使用這種方式，並且FastIO.cpp代碼中有幾個bug，懶得改了。直接用FastIO.h即可，這里的改過bug了。

#include <cstdio> // EOF 的定義
#include <cassert> // assert 函數定義
#include <sys/stat.h> // 讀取文件狀態

/**
 * 快速輸入輸出模板 
 * 使用 fread 和 fwrite 獲得高於 scanf 和 printf 的文件 I/O 性能
 */
namespace FastIO {

    // 快速輸入
    namespace in{
        const int inputBuffSize = 67108864; // 輸入緩沖區大小 64MB
        char buff[inputBuffSize], *ptr = NULL, *pend = NULL;
        FILE *stream = NULL;
        int filesize, readsize, itemsize, maxcnt, maxbytes; // 文件大小字節數, 已讀字節數

        // 指定文件路徑, 並根據文件頭獲取文件大小
        inline int getsize(const char *path){
            struct stat statbuff;
            stat(path, &statbuff);
            return statbuff.st_size;
        }

        /* 初始化 Fast in 參數
         *      (const char*) path: 文件路徑
         *      (const char*) mode: 文件打開模式
         *   (const int) element_size=1: 文件讀取的塊大小, 默認為 1 字節, 緩沖區大小為 64M
         */
        inline void init(const char *path, const char *mode="rb", const int element_size=1){
            assert((stream == NULL) && (stream = fopen(path, mode)) != NULL);
            filesize = getsize(path);
            readsize = 0;
            itemsize = element_size;
            maxcnt = inputBuffSize / element_size; // buffer 整塊讀取時可容納的最大塊數
            maxbytes = (inputBuffSize / element_size) * element_size; // buffer 整塊讀取時可容納的最大字節數
            ptr = pend = NULL;
        }

        /**
         * 讀取流 stream 中的下一個字符, 當緩沖區內容讀取完畢后進行下一次I/O
         * 返回EOF(-1)表示讀取完成, 返回-2表示達到文件尾之前出錯
         */
        inline char nextchar(){
            if (readsize >= filesize) return EOF; // 文件讀取完成
            if (ptr >= pend){
                int realbytes = itemsize * fread(buff, itemsize, maxcnt, stream); // fread返回實際讀取的塊數
                if (realbytes < maxbytes && realbytes + readsize < filesize) return -2; // 讀取出錯 返回-2
                ptr = buff; // 重置首尾指針
                pend = buff + realbytes;
            }
            return readsize++, *ptr++;
        }

        // 讀取一個整數, true 表示讀取成功, false 表示讀取失敗
        inline bool read(int &x){
            char c = nextchar();
            while (c >= 0 && c != '-' && (c < '0' || c > '9')) c = nextchar();
            if (c < 0) return false; // c == -1 (EOF): 到達文件尾, c == -2: 讀取出錯
            int sign = (c == '-') ? -1 : 1; // 正負號
            x = (c == '-') ? 0 : c - '0';
            while (c = nextchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
            x *= sign;
            return true;
        }

        // 讀取一個長度為 n 的整數 tuple, 如 (1, -2, 31), true 表示讀取成功, false 表示失敗
        inline bool read(int *p, const int n){
            for (int *end = p + n; p < end; ++p) if (!read(*p)) return false;
            return true;
        }

        // 關閉輸入流釋放資源
        inline int close(){
            int ret = fclose(stream);
            filesize = readsize = itemsize = maxcnt = 0;
            ptr = pend = NULL;
            stream = NULL;
            return ret;
        }
    }

    // 快速輸出
    namespace out{
        const int outputBuffSize = 67108864; // 輸出緩沖區大小 64MB
        char buff[outputBuffSize], *ptr = NULL, *pend = NULL;
        FILE *stream = NULL;
        int itemsize, maxbytes; // 寫入的塊大小, 整塊存放時緩存的最大字節數

        inline void init(const char *path, const char *mode="wb", const int element_size=1){
            assert(stream == NULL && (stream = fopen(path, mode)) != NULL);
            itemsize = element_size;
            maxbytes = (outputBuffSize / element_size) * element_size; // 輸出緩沖的最大字節數
            ptr = buff;
            pend = buff + maxbytes;
        }

        // 沖刷緩沖區
        inline void flush(){
            fwrite(buff, itemsize, (ptr - buff) / itemsize, stream);
            ptr = buff; // 調整首指針
            fflush(stream);
        }

        // 寫入一個字符到文件中
        inline void write(const char &c){
            if (ptr >= pend) flush();
            *ptr++ = c;
        }

        // 寫一個字符串到文件中
        inline void write(const char *s){
            for(; *s; ++s) write(*s); // 讀取到字符串尾部時 '\0' ASCII為0
        }

        // 寫入一個整數到文件中
        inline void write(int x){
            char buf[20], *p = buf;
            if (x == 0) write('0');
            if (x < 0) write('-'), x = -x;
            while (x > 0) *p++ = x % 10 + '0', x /= 10;
            while (p > buf) write(*--p);
        }

        // 寫入一個整型tuple到文件中 如 (32, -1, 14), drop_end 控制是否輸出 end 符號
        inline void write(const int *p, const int n, const char *left="(", const char *right=")",
                          const char *split=", ", const char *end="\n", const bool drop_end=false){
            write(left);
            for (const int *ptrend = p + n - 1; p < ptrend; ++p){
                write(*p);
                write(split);
            }
            write(*++p);
            write(right);
            if (!drop_end) write(end);
        }

        // 沖刷緩沖並關閉輸出流釋放資源
        inline int close(){
            if (ptr > buff) flush();
            int ret = fclose(stream);
            ptr = pend = NULL;
            stream = NULL;
            return ret;
        }
    }
}

 

由於內聯函數可以寫入到頭文件中，因此可以將FastIO的實現放入 FastIO.h 中，然后在調用時通過 include 包含即可，FastIO.h 如下，其中包含了對於string類型的支持：強烈建議使用這種方式 

 

#pragma once
#include <cstdio> // EOF 的定義
#include <string> // string 類型的支持
#include <cassert> // assert 函數定義
#include <sys/stat.h> // 讀取文件狀態
#include <vector> // 讀寫vector

#define inputBuffSize (67108864) // 輸入緩沖區大小 64MB
#define outputBuffSize (67108864) // 輸入緩沖區大小 64MB

namespace FastIO { // 由於頭文件中可以定義內聯函數, 因此將FastIO定義在頭文件中便於使用
    // 快速輸入
    namespace in{
        char buff[inputBuffSize], *ptr = NULL, *pend = NULL;
        FILE *stream = NULL;
        int filesize, readsize, itemsize, maxcnt, maxbytes; // 文件大小字節數, 已讀字節數

        // 指定文件路徑, 並根據文件頭獲取文件大小
        inline int getsize(const char *path){
            struct stat statbuff;
            stat(path, &statbuff);
            return statbuff.st_size;
        }

        // 初始化 Fast in 參數
        //      (const char*) path: 文件路徑
        //      (const char*) mode: 文件打開模式
        //   (const int) element_size=1: 文件讀取的塊大小, 默認為 1 字節, 緩沖區大小為 64M
        inline void init(const char *path, const char *mode="rb", const int element_size=1){
            assert((stream == NULL) && (stream = fopen(path, mode)) != NULL);
            filesize = getsize(path);
            readsize = 0;
            itemsize = element_size;
            maxcnt = inputBuffSize / element_size; // buffer 整塊讀取時可容納的最大塊數
            maxbytes = (inputBuffSize / element_size) * element_size; // buffer 整塊讀取時可容納的最大字節數
            ptr = pend = NULL;
        }

        // 初始化 Fast in 參數
        //      (const string) path: 文件路徑
        //      (const char*) mode: 文件打開模式
        //   (const int) element_size=1: 文件讀取的塊大小, 默認為 1 字節, 緩沖區大小為 64M
        inline void init(const std::string &path, const char *mode="rb", const int element_size=1){
            init(path.c_str(), mode, element_size);
        }

        // 讀取流 stream 中的下一個字符, 當緩沖區內容讀取完畢后進行下一次I/O
        // 返回EOF(-1)表示讀取完成, 返回-2表示達到文件尾之前出錯
        inline char nextchar(){
            if (readsize >= filesize) return EOF; // 文件讀取完成
            if (ptr >= pend){
                int realbytes = itemsize * fread(buff, itemsize, maxcnt, stream); // fread返回實際讀取的塊數
                if (realbytes < maxbytes && realbytes + readsize < filesize) return -2; // 讀取出錯 返回-2
                ptr = buff; // 重置首尾指針
                pend = buff + realbytes;
            }
            return readsize++, *ptr++;
        }

        // 讀取一個字符, 讀取失敗則不改變char, 否則改變char c的值
        inline bool read(char &c){
            char tmp = nextchar(); // tmp == -1 (EOF): 到達文件尾, tmp == -2: 讀取出錯
            return tmp < 0 ? false : (c = tmp, true);
        }

        // 讀取一個整數, true 表示讀取成功, false 表示讀取失敗
        inline bool read(int &x){
            char c = nextchar();
            while (c >= 0 && c != '-' && (c < '0' || c > '9')) c = nextchar();
            if (c < 0) return false; // c == -1 (EOF): 到達文件尾, c == -2: 讀取出錯
            int sign = (c == '-') ? -1 : 1; // 正負號
            x = (c == '-') ? 0 : c - '0';
            while (c = nextchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
            x *= sign;
            return true;
        }

        // 讀取一個長度為 n 的整數 tuple, 如 (1, -2, 31), true 表示讀取成功, false 表示失敗
        inline bool read(int *p, const int n){
            for (int *end = p + n; p < end; ++p) if (!read(*p)) return false;
            return true;
        }

        // 關閉輸入流釋放資源
        inline int close(){
            int ret = fclose(stream);
            filesize = readsize = itemsize = maxcnt = 0;
            ptr = pend = NULL;
            stream = NULL;
            return ret;
        }
    }

    // 快速輸出
    namespace out{
        char buff[outputBuffSize], *ptr = NULL, *pend = NULL;
        FILE *stream = NULL;
        int itemsize, maxbytes; // 寫入的塊大小, 整塊存放時緩存的最大字節數

        // 初始化 Fast out 參數
        //      (const char*) path: 文件路徑
        //      (const char*) mode: 文件打開模式
        //   (const int) element_size=1: 文件讀取的塊大小, 默認為 1 字節, 緩沖區大小為 64M
        inline void init(const char *path, const char *mode="wb", const int element_size=1){
            assert(stream == NULL && (stream = fopen(path, mode)) != NULL);
            itemsize = element_size;
            maxbytes = (outputBuffSize / element_size) * element_size; // 輸出緩沖的最大字節數
            ptr = buff;
            pend = buff + maxbytes;
        }

        // 初始化 Fast out 參數
        //      (const string) path: 文件路徑
        //      (const char*) mode: 文件打開模式
        //   (const int) element_size=1: 文件讀取的塊大小, 默認為 1 字節, 緩沖區大小為 64M
        inline void init(const std::string &path, const char *mode="wb", const int element_size=1){
            init(path.c_str(), mode, element_size);
        }

        // 沖刷緩沖區
        inline void flush(){
            fwrite(buff, itemsize, (ptr - buff) / itemsize, stream);
            ptr = buff; // 調整首指針
            fflush(stream);
        }

        // 寫入一個字符到文件中
        inline void write(const char &c){
            if (ptr >= pend) flush();
            *ptr++ = c;
        }

        // 寫一個字符串到文件中
        inline void write(const char *s){
            for(; *s; ++s) write(*s); // 讀取到字符串尾部時 '\0' ASCII為0
        }

        // 寫一個 string 類型的字符串到文件中
        inline void write(const std::string &s){
            write(s.c_str());
        }

        // 寫入一個整數到文件中
        inline void write(int x){
            char buf[20], *p = buf;
            if (x == 0) write('0');
            if (x < 0) write('-'), x = -x;
            while (x > 0) *p++ = x % 10 + '0', x /= 10;
            while (p > buf) write(*--p);
        }

        template<typename T>
        // 寫入一個含有n個元素的tuple到文件中 如 (32, -1, 14), drop_end 控制是否輸出 end 符號
        inline void write(const T *p, int n, const char *left="(", const char *right=")",
                          const char *split=", ", const char *end="\n", const bool drop_end=false){
            write(left);
            while (--n) write(*p++), write(split);
            write(*p);
            write(right);
            if (!drop_end) write(end);
        }

        template<typename T>
        // 寫入一個使用 vector 存儲的 tuple
        inline void write(std::vector<T> &vec, const char *left="(", const char *right=")",
                          const char *split=", ", const char *end="\n", const bool drop_end=false){
            int n = vec.size() - 1;
            write(left);
            for (int i = 0; i < n; ++i) write(vec[i]), write(split);
            write(vec[n]);
            write(right);
            if (!drop_end) write(end);
        }

        // 沖刷緩沖並關閉輸出流釋放資源
        inline int close(){
            if (ptr > buff) flush();
            int ret = fclose(stream);
            ptr = pend = NULL;
            stream = NULL;
            return ret;
        }
    }
}

 

調用時，只需將頭文件 FastIO.h 引入，然后使用其命名空間 FastIO::in, FastIO::out

簡單的使用方式如下，這里假定了 main.cpp 和 FastIO.h 在同一個目錄下：（如果不在，需要用相對路徑）

// 在 main.cpp 中引入FastIO.h 和 命名空間 FastIO 即可

#include"FastIO.h"
using namespace FastIO;

int main(int argc, char *argv[]){
    int buff[10];
    // 初始化寫入文件流
    out::init("out.txt", "wb");
    // 測試5個數一組的tuple讀取和寫入 
    in::init("in.txt", "rb");
    while(in::read(buff, 5)) out::write(buff, 5);
    // 釋放讀文件資源
    in::close();
    // 釋放寫文件資源，沖刷緩沖區
    out::close();
}