一个基于STL的ini文件解析类，测试通过

windows平台自带ini解析的接口，但是如果要跨平台的话，就要自己来实现一个，网上找了下，发现在跨平台不够理想

遂自己修改了一个出来。支持解析utf-8, unicode big endian, unicode little endian格式文件，请勿使用windows的

ansi保存的文件测试。文件操作时，空格和注释会被丢弃，可能下次有空考虑加上来吧。

代码如下：

//head file

#ifndef IniParser_
#define IniParser_

#include <vector>
#include <string>
#include <map>

class IniParser
{
public:
    IniParser();
    ~IniParser();
protected:
    typedef unsigned char Byte;
    typedef std::map<std::string, std::string> KeyVector;
    typedef std::map<std::string, KeyVector> SectionVector;
    enum FileEncode {
        Unknow_Encode,
        Unicode_BE,
        Unicode_LE,
        Utf8_Encode,
    };
public:
    bool Open(const std::string &szIni);
    std::string GetPrivateProfileString(const std::string &section, 
            const std::string &key);
    int GetPrivateProfileInt(const std::string &section, const std::string &key);
    bool SetPrivateProfileString(const std::string &section, 
            const std::string &key, const std::string &value);
    bool SetPrivateProfileInt(const std::string &section, 
            const std::string &key, int value);
    bool Flush(void);
protected:
    bool Parser(const std::string &strbuf);
    std::string GetLine(void);
    bool IsComment(const std::string &line);
    bool IsSection(const std::string &line);
    std::string GetKeyValueFromLine(const std::string &line);
    std::string GetKeyNameFromLine(const std::string &line);
    std::string GetSectionNameFromLine(const std::string &line);
    std::string RemoveSpace(const std::string &strbuf);
    void ResetOffset();
    bool IsOffsetEnd();
private:
    FileEncode m_encode;
    std::string m_strIni;
    std::string m_fileBuff;
    std::string::size_type m_offset;
    SectionVector m_mpValue;
};

#endif

// source file

#include <fstream>
#include <iostream>
#include <algorithm>
#include <deque>
#include <sstream>
#include "IniParser.h"

// Convert Unicode big endian to Unicode little endian
static unsigned Ucs2BeToUcs2Le(unsigned short *ucs2bige, unsigned int size)
{
    printf("@ %s %d line\n", __FUNCTION__, __LINE__);

    if (!ucs2bige) {
        return 0;
    }
    
    unsigned int length = size;
    unsigned short *tmp = ucs2bige;
    
    while (*tmp && length) {
        
        length--;
        unsigned char val_high = *tmp >> 8;
        unsigned char val_low = (unsigned char)*tmp;
        
        *tmp = val_low << 8 | val_high;
        
        tmp++;
    }
    
    return size - length;
}

// Convert Unicode little endian to Unicode big endian
static unsigned Ucs2LeToUcs2Be(unsigned short *ucs2le, unsigned int size)
{
    if (!ucs2le) {
        return 0;
    }
    
    printf("@ %s %d line\n", __FUNCTION__, __LINE__);

    unsigned int length = size;
    unsigned short *tmp = ucs2le;
    
    while (*tmp && length) {
        
        length--;
        unsigned char val_high = *tmp >> 8;
        unsigned char val_low = (unsigned char)*tmp;
        
        *tmp = val_low << 8 | val_high;
        
        tmp++;
    }
    
    return size - length;
}

// Convert Ucs-2 to Utf-8
static unsigned int Ucs2ToUtf8(unsigned short *ucs2, unsigned int ucs2_size, 
                        unsigned char *utf8, unsigned int utf8_size)
{
    unsigned int length = 0;
    
    if (!ucs2) {
        return 0;
    }
    
    unsigned short *inbuf = ucs2;
    unsigned char *outbuf = utf8;
    
    if (*inbuf == 0xFFFE) {
        Ucs2BeToUcs2Le(inbuf, ucs2_size);
    }
    
    if (!utf8) {
        unsigned int insize = ucs2_size;
        
        while (*inbuf && insize) {
            insize--;
            
            if (0x0080 > *inbuf) {
                length++;
            } else if (0x0800 > *inbuf) {
                length += 2;                
            } else {
                length += 3;
            }
            
            inbuf++;
        }
        return length;
        
    } else {        
        unsigned int insize = ucs2_size;
        
        while (*inbuf && insize && length < utf8_size) {            
            insize--;
            
            if (*inbuf == 0xFFFE) {
                inbuf++;
                continue;
            }
            
            if (0x0080 > *inbuf) {
                /* 1 byte UTF-8 Character.*/
                *outbuf++ = (unsigned char)(*inbuf);
                length++;
            } else if (0x0800 > *inbuf) {
                /*2 bytes UTF-8 Character.*/
                *outbuf++ = 0xc0 | ((unsigned char)(*inbuf >> 6));
                *outbuf++ = 0x80 | ((unsigned char)(*inbuf & 0x3F));
                length += 2;
                
            } else {
                /* 3 bytes UTF-8 Character .*/
                *outbuf++ = 0xE0 | ((unsigned char)(*inbuf >> 12));
                *outbuf++ = 0x80 | ((unsigned char)((*inbuf >> 6) & 0x3F));
                *outbuf++ = 0x80 | ((unsigned char)(*inbuf & 0x3F));
                length += 3; 
            }
            
            inbuf++;
        }
        
        return length;
    }
}

//// Convert Ucs-2 to Utf-8
static unsigned int Utf8ToUcs2(unsigned char *utf8, unsigned int utf8_size, 
                        unsigned short *ucs2, unsigned int ucs2_size)
{
    int length = 0;
    unsigned int insize = utf8_size;
    unsigned char *inbuf = utf8;
    
    if(!utf8)
        return 0;
    
    if(!ucs2) {
        while(*inbuf && insize) {
            unsigned char c = *inbuf;
            if((c & 0x80) == 0) {
                length += 1;
                insize -= 1;
                inbuf++;
            }
            else if((c & 0xE0) == 0xC0) {
                length += 1;
                insize -= 2;
                inbuf += 2;
            } else if((c & 0xF0) == 0xE0) {
                length += 1;
                insize -= 3;
                inbuf += 3;
            }
        }
        return length;
        
    } else {
        unsigned short *outbuf = ucs2;
        unsigned int outsize = ucs2_size;
        
        while(*inbuf && insize && length < outsize) {
            unsigned char c = *inbuf;
            if((c & 0x80) == 0) {
                *outbuf++ = c;
                inbuf++;
                length++;
                insize--;
            } else if((c & 0xE0) == 0xC0) {
                unsigned short val;
                
                val = (c & 0x3F) << 6;
                inbuf++;
                c = *inbuf;
                val |= (c & 0x3F);
                inbuf++;
                
                length++;
                insize -= 2;
                
                *outbuf++ = val;
            } else if((c & 0xF0) == 0xE0) {
                unsigned short val;
                
                val = (c & 0x1F) << 12;
                inbuf++;
                c = *inbuf;
                val |= (c & 0x3F) << 6;
                inbuf++;
                c = *inbuf;
                val |= (c & 0x3F);
                inbuf++;
                
                insize -= 3;
                length++;
                
                *outbuf++ = val;
            }
        }
        return length;
    }
    return 0;
}

IniParser::IniParser()
: m_strIni("")
, m_fileBuff("")
, m_offset(0)
, m_encode(Unknow_Encode)
{
}

IniParser::~IniParser()
{
}

bool IniParser::Open(const std::string &szIni)
{
    m_strIni = szIni;
    
    if (m_strIni.empty()) {
        return false;
    }
    
    std::ifstream infile(m_strIni.c_str());
    if (!infile) {
        return false;
    }
    
    infile.seekg(0, std::ios::end);
    unsigned length = infile.tellg();
    infile.seekg(0, std::ios::beg);
    
    if (length < 3) {
        return false;
    }
    
    unsigned int buff_size = length / sizeof(unsigned short) + 1;
    unsigned short *buff = new unsigned short[buff_size];
    infile.read((char *)buff, length);
    buff[buff_size] = '\0';
    
    unsigned char *utf8 = NULL;
    
    // support unicode & utf-8 encode
    if (*buff == 0xFEFF || *buff == 0xFFFE) {

        if (*buff == 0xFEFF) {
            m_encode = Unicode_LE;
        } else {
            m_encode = Unicode_BE;
        }

        unsigned int utf8_size = Ucs2ToUtf8(buff, buff_size, utf8, 0);
        utf8 = new unsigned char [utf8_size + 1];
        Ucs2ToUtf8(buff, buff_size, utf8, utf8_size);

        delete [] buff;

    } else if (*(unsigned char *)buff == 0xEF && *((unsigned char *)buff + 1) == 0xBB 
               && *((unsigned char *)buff + 2) == 0xBF) {

        utf8 = (unsigned char *)buff;
        m_encode = Utf8_Encode;

    } else {

        delete [] buff;
        return false;
    }
    
    m_fileBuff = (char *)utf8;
    
    delete [] utf8;
    infile.close();
    
    return Parser(m_fileBuff);    
}

bool IniParser::IsSection(const std::string &line)
{
    std::string::size_type stLeft = line.find("[");
    std::string::size_type stRight = line.find("]");
    
    if (!line.empty() && stLeft != std::string::npos && 
            stRight != std::string::npos && stRight > stLeft) {
        return true;
    }
    
    return false;
}

std::string IniParser::GetSectionNameFromLine(const std::string &line)
{
    std::string::size_type stLeft = line.find("[");
    std::string::size_type stRight = line.find("]");
    
    if (!line.empty() && stLeft != std::string::npos && 
            stRight != std::string::npos && stRight > stLeft) {
        std::string section(line, stLeft + 1, stRight - stLeft - 1);
        return RemoveSpace(section);
    }
    
    return std::string();
}

std::string IniParser::RemoveSpace(const std::string &strbuf)
{
    std::string stReturn = strbuf;

    if(strbuf.empty())
        return stReturn;

    std::string::size_type stLeft = 0;
    std::string::size_type stRight = 0;
    stLeft = strbuf.find_first_not_of(' ');
    stRight = strbuf.find_last_not_of(' ');

    if(stLeft == std::string::npos || stRight == std::string::npos)
        return stReturn;

    std::string st(strbuf, stLeft, stRight - stLeft + 1);
    return st;
}

std::string IniParser::GetKeyNameFromLine(const std::string &line)
{
    std::string::size_type stpos = line.find("=");
    if (stpos == 0) {
        return std::string();
    }
    
    std::string strbuf;
    if (stpos == std::string::npos) {
        strbuf = line;
    } else {
        strbuf.clear();
        strbuf.insert(0, line, 0, stpos);
    }
    
    return RemoveSpace(strbuf);
}

std::string IniParser::GetKeyValueFromLine(const std::string &line)
{
    std::string::size_type stpos = line.find("=");
    if (stpos == std::string::npos) {
        return std::string();
    }
    
    std::string strbuf;
    strbuf.clear();
    strbuf.insert(0, line, stpos + 1, line.size());
    
    return RemoveSpace(strbuf);
}

bool IniParser::Parser(const std::string &strbuf)
{
    ResetOffset();
    
    KeyVector mpKey;
    std::string section;
    
    while (true) {
        std::string line = GetLine();
        if (line.empty() || IsComment(line)) {
            if (IsOffsetEnd()) {
                break;
            } else {
                continue;
            }
        }
        
        if (IsSection(line)) {
            if (section.empty()) {
                section = GetSectionNameFromLine(line);
                continue;
            } 
            
            m_mpValue.insert(std::make_pair(section, mpKey));
            section = GetSectionNameFromLine(line);
            mpKey.clear();
        } else {
            if (section.empty()) {
                continue;
            }
            std::string strKey = GetKeyNameFromLine(line);
            if (!strKey.empty()) {
                mpKey.insert(std::make_pair(strKey, GetKeyValueFromLine(line)));
            }
        }
    }
    
    if (!section.empty()) {
        m_mpValue.insert(std::make_pair(section, mpKey));
    }

    return true;
}

std::string IniParser::GetLine()
{
    std::string line;
    if (m_offset >= m_fileBuff.size()) {
        return std::string();
    }
    
    std::string::size_type stPos = m_fileBuff.find("\r\n", m_offset);
    if (stPos == std::string::npos) {
        line.insert(0, m_fileBuff, m_offset, m_fileBuff.size() - m_offset + 1);
        m_offset = m_fileBuff.size() + 1;
    } else {
        line.insert(0, m_fileBuff, m_offset, stPos - m_offset);
        m_offset = stPos + 2;
    }
    
    return line;
}

void IniParser::ResetOffset()
{
    m_offset = 0;
}

bool IniParser::IsOffsetEnd()
{
    if (m_offset >= m_fileBuff.size()) {
        return true;
    }
    return false;
}

bool IniParser::IsComment(const std::string &line)
{
    if (line.empty() || line[0] == ';') {
        return true;
    }
    
    return false;
}

/*
std::string IniParser::ConvertToLowercase(const std::string &strBuf)
{
    std::string str = strBuf;
    std::transform(str.begin(), str.end(), str.begin(), tolower);
    return str;
}
*/

std::string IniParser::GetPrivateProfileString(const std::string &section, 
        const std::string &key)
{
    if (m_mpValue.empty() || section.empty() || key.empty()) {
        return std::string();
    }
    
    for (SectionVector::iterator iter_section = m_mpValue.begin(); 
            iter_section != m_mpValue.end(); iter_section++) {
        if (section == iter_section->first) {
            for (KeyVector::iterator iter_key = iter_section->second.begin(); 
                 iter_key != iter_section->second.end(); iter_key++) {
                if (key == iter_key->first) {
                    return iter_key->second;
                }
            }
        }
    }

    return std::string();
}

bool IniParser::SetPrivateProfileString(const std::string &section, 
        const std::string &key, const std::string &value)
{
    for (SectionVector::iterator iter_section = m_mpValue.begin(); 
            iter_section != m_mpValue.end(); iter_section++) {
        if (section == iter_section->first) {
            //find exist section
            for (KeyVector::iterator iter_key = iter_section->second.begin(); 
                    iter_key != iter_section->second.end(); iter_key++) {
                if (key == iter_key->first) {
                    // find exist key
                    iter_key->second = value;
                    return true;
                }
            }
            
            // add new key
            std::cout << "new key " << key << " in" << std::endl;
            iter_section->second.insert(std::make_pair(key, value));
            return true;
        }
    }
    
    //add new section
    KeyVector mpKey;
    mpKey.insert(std::make_pair(key, value));
    m_mpValue.insert(std::make_pair(section, mpKey));
    return true;
}

bool IniParser::SetPrivateProfileInt(const std::string &section, 
        const std::string &key, int value)
{
    std::stringstream ss;
    ss << value;
    
    std::string str_value;
    ss >> str_value;
    
    return SetPrivateProfileString(section, key, str_value);
}

int IniParser::GetPrivateProfileInt(const std::string &section, 
        const std::string &key)
{
    return atoi(GetPrivateProfileString(section, key).c_str());
}

bool IniParser::Flush()
{
    if (m_encode == Unknow_Encode) {
        return false;
    }
    
    std::ofstream outfile(m_strIni.c_str(), 
            std::ofstream::binary | std::ofstream::trunc);
    if (!outfile) {
        std::cout << "Open file " << m_strIni << " failed." << std::endl;
        return false;
    }
    
    m_fileBuff.clear();
    for (SectionVector::iterator iter_section = m_mpValue.begin(); 
            iter_section != m_mpValue.end(); iter_section++) {
        m_fileBuff += "[";
        m_fileBuff += iter_section->first;
        m_fileBuff += "]\r\n";
        
        for (KeyVector::iterator iter_key = iter_section->second.begin(); 
                iter_key != iter_section->second.end(); iter_key++) {
            m_fileBuff += iter_key->first;
            m_fileBuff += "=";
            m_fileBuff += iter_key->second;
            m_fileBuff += "\r\n";
        }
        m_fileBuff += "\r\n";
    }
    
    unsigned char file_head[3];
    
    if (m_encode == Utf8_Encode) {
        file_head[0] = 0xEF; file_head[1] = 0xBB; file_head[2] = 0xBF;
        
        outfile.write((char *)file_head, 3);
        outfile.write(m_fileBuff.c_str(), m_fileBuff.size());
        
    } else if (m_encode == Unicode_BE) {
        unsigned short *ucs2buf = NULL;
        unsigned int ucs2_size = Utf8ToUcs2((unsigned char *)m_fileBuff.c_str(), 
                m_fileBuff.size(), ucs2buf, 0);
        ucs2buf = new unsigned short [ucs2_size];
        Utf8ToUcs2((unsigned char *)m_fileBuff.c_str(), m_fileBuff.size(), 
                ucs2buf, ucs2_size);
        Ucs2LeToUcs2Be(ucs2buf, ucs2_size);
        
        file_head[0] = 0xFE; file_head[1] = 0xFF;
        
        outfile.write((char *)file_head, 2);
        outfile.write((char *)ucs2buf, ucs2_size * sizeof(unsigned short));
        
        delete ucs2buf;
    } else if (m_encode == Unicode_LE) {
        unsigned short *ucs2buf = NULL;
        unsigned int ucs2_size = Utf8ToUcs2((unsigned char *)m_fileBuff.c_str(), 
                m_fileBuff.size(), ucs2buf, 0);
        ucs2buf = new unsigned short [ucs2_size];
        Utf8ToUcs2((unsigned char *)m_fileBuff.c_str(), m_fileBuff.size(), 
                ucs2buf, ucs2_size);
                
        file_head[0] = 0xFF; file_head[1] = 0xFE;
        
        outfile.write((char *)file_head, 2);
        outfile.write((char *)ucs2buf, ucs2_size * sizeof(unsigned short));
        
        delete ucs2buf;
    }
    
    outfile.close();
    return true;
}