大文件操作

工作中碰到需要处理超过2GB的文件，考虑到还要跨平台

封装C库函数成一个类，提供常见的一般IO操作

//Header File
#ifndef __LARGE_FILE_H
#define __LARGE_FILE_H

//This Marco forces all file access calls to use the 64 bit variants
#define FILE_OFFSET_BITS 64 

#include <cstdio>
#include <string>

class CLargeFile {
public:
    CLargeFile();
    CLargeFile(const std::string &strFile, const char *mode = "rb+");
    ~CLargeFile();
    bool Open(const std::string &strFile, const char *mode = "rb+");
    bool IsOpen(){ return m_bOpen; }
    size_t Read(void *ptr, size_t size, size_t nmemb);
    size_t Write(const void *ptr, size_t size, size_t nmemb);
    char *GetLine(char *s, int size);
    int Seek(off_t offset, int whence);
    int Flush();
    off_t Tell();
    void ReWind();
    void Close();
private:
    FILE *m_hFile;
    bool m_bOpen;
};

#endif

//Source File

#include "largefile.h"

CLargeFile::CLargeFile()
    : m_hFile(NULL)
    , m_bOpen(false)
{
}

CLargeFile::CLargeFile(const std::string &strFile, const char *mode)
    : m_hFile(NULL)
    , m_bOpen(false)
{
    Open(strFile, mode);
}

CLargeFile::~CLargeFile()
{
    Close();
}

bool CLargeFile::Open(const std::string &strFile, const char* mode)
{
    Close();

    if(strFile.empty())
        m_bOpen = false;
    else {
        FILE *hRet = fopen(strFile.c_str(), mode);
        if(hRet == NULL) {
            m_bOpen = false;
            m_hFile = NULL;
        } else {
            m_bOpen = true;
            m_hFile = hRet;
        }
    }

    return m_bOpen;
}

size_t CLargeFile::Read(void *ptr, size_t size, size_t nmemb)
{
    if(!m_hFile)
        return 0;

    return fread(ptr, size, nmemb, m_hFile);
}

size_t CLargeFile::Write(const void *ptr, size_t size, size_t nmemb)
{
    if(!m_hFile)
        return 0;

    return fwrite(ptr, size, nmemb, m_hFile);
}

char *CLargeFile::GetLine(char *s, int size)
{
    if(!m_hFile)
        return NULL;

    return fgets(s, size, m_hFile);
}

int CLargeFile::Seek(off_t offset, int whence)
{
    if(!m_hFile)
        return -1;

    return fseeko(m_hFile, offset, whence);
}

int CLargeFile::Flush()
{
    if(!m_hFile)
        return -1;

    return fflush(m_hFile);
}

off_t CLargeFile::Tell()
{
    if(!m_hFile)
        return -1;

    return ftello(m_hFile);
}

void CLargeFile::ReWind()
{
    if(!m_hFile)
        return;

    rewind(m_hFile);
}

void CLargeFile::Close()
{
    if(m_hFile) {
        fclose(m_hFile);
        m_hFile = NULL;
        m_bOpen = false;
    }
}