hex轉bin文件

最近工作中遇到了需要把hex文件轉換爲bin文件的需求，於是寫了程序實現轉換，至於hex文件解析什麼的網上都有，就不說了，直接貼代碼，流程是通過用結構體解析hex文件的每一行，然後根據地址去組裝數據

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

//hex文件解析的結構體
struct SHexFileData
{
    BYTE m_data_length_;                //數據長度
    DWORD m_data_start_address_;        //數據地址
    BYTE m_data_type_;                  //數據類型
    string m_data_;                     //數據
};
void CombinationHexFileData(const vector<SHexFileData> &vecHexFileData, map<DWORD, string> &mapAddressData);
size_t HexStrToHex(const std::string &strData)
{
    if (strData.size() > 8)
    {
        retrurn 0;
    }

    size_t sum = 0;
    for (size_t index = 0; index < strData.size(); ++index)
    {
        char ctmp = ::tolower(strData[index]);
        size_t tmp = 0;
        if (ctmp >= '0'
            && ctmp <= '9')
        {
            tmp = ctmp - 0x30;
        }
        else if (ctmp >= 'a'
            && ctmp <= 'f')
        {
            tmp = ctmp - 0x61 + 10;
        }

        sum *= 16;
        sum += tmp;
    }

    return sum;
}

DWORD SolveHexFile(const std::string & filePath)
{
    std::ifstream hexFile(filePath.c_str());
    if (!hexFile)
    {
        return -1;
    }
    
    std::string lineData = "";
    BYTE ucIndex = 0;
    SHexFileData shfd;
    DWORD dwTmp = 0;
    std::vector<SHexFileData> vecHexFileData;    //保存提取hex文件得到的數據
    
    while (getline(hexFile, lineData))
    {
        if (lineData.size() < 11
            || lineData[0] != ':')
        {
            continue;
        }
        lineData = lineData.substr(1);
        
        shfd.m_data_length_ = HexStrToHex(lineData.substr(0, 2));
        shfd.m_data_start_address_ = HexStrToHex(lineData.substr(2, 4));
        shfd.m_data_type_ = HexStrToHex(lineData.substr(6, 2));
        if (shfd.m_data_type_ == 0)
        {
            shfd.m_data_start_address_ += dwTmp;
        }
        
        shfd.m_data_ = "";
        if (shfd.m_data_length_ > 0)
        {
            shfd.m_data_.resize(shfd.m_data_length_, 0);
            for (ucIndex = 0; ucIndex < shfd.m_data_length_; ++ucIndex)
            {
                shfd.m_data_[ucIndex] = HexStrToHex(lineData.substr(8 + ucIndex * 2, 2));
            }
        }

        if (shfd.m_data_type_ == 4)
        {
            dwTmp = 0;
            for (ucIndex = 0; ucIndex < shfd.m_data_length_; ++ucIndex)
            {
                dwTmp <<= 8;
                dwTmp += static_cast<BYTE>(shfd.m_data_[ucIndex]);
            }
            dwTmp <<= 16;
            shfd.m_data_ = "";
        }
       
        vecHexFileData.push_back(shfd);
        if (shfd.m_data_type_ == 1)
        {
            break;
        }
    }
    
    hexFile.close();
    std::map<DWORD, string> mapAddressData;
    CombinationOriginalFileData(vecHexFileData, mapAddressData);
    vecHexFileData.clear();
}

void CombinationHexFileData(const vector<SHexFileData> &vecHexFileData, map<DWORD, string> &mapAddressData)
{
    size_t index = 0;
    while (index < vecHexFileData.size())
    {
        if (vecHexFileData[index].m_data_type_ == 0x04)
        {
            ++index;
            continue;
        }
        else if (vecHexFileData[index].m_data_type_ == 0x01)
        {
            break;
        }

        DWORD dwStartAddress = vecHexFileData[index].m_data_start_address_;
        DWORD dwEndAddress = dwStartAddress + vecHexFileData[index].m_data_.size();
        mapAddressData[dwStartAddress] = vecHexFileData[index].m_data_;
        ++index;
        while (index < vecHexFileData.size())
        {
            if (vecHexFileData[index].m_data_type_ == 0x00
                && vecHexFileData[index].m_data_start_address_ == dwEndAddress)
            {
                mapAddressData[dwStartAddress] += vecHexFileData[index].m_data_;
                dwEndAddress += vecHexFileData[index].m_data_.size();
            }
            else if (vecHexFileData[index].m_data_type_ == 0x04)
            {
                ++index;
                continue;
            }
            else if (vecHexFileData[index].m_data_start_address_ != dwEndAddress
                || vecHexFileData[index].m_data_type_ == 0x01)
            {
                break;
            }

            ++index;
        }
    }
}

最終得到的mapAddressData裏面存放着提取到的地址和數據