void StrDec2BufDec(const StrVal& strDec, BYTE* bufDec) {
    for (size_t i = 0; i < strDec.length(); ++i) {
        bufDec[i] = 0;
        if (strDec[i] >= L'0' && strDec[i] <= L'9')
            bufDec[i] = strDec[i] - L'0';
    }
}

int StrDec2HexBuf( const StrVal& strDec, BYTE* destBuf ) {
    size_t nIndex = 0;
    while (nIndex < strDec.length() && (strDec[nIndex] <= '0' || strDec[nIndex] > '9'))
        ++nIndex;
    if (nIndex >= strDec.length())
        return 0;

    size_t nDecLen = strDec.length() - nIndex;
    BYTE* decBuf = new BYTE[nDecLen+1];
    memset(decBuf, 0, nDecLen+1);
    StrDec2BufDec(StrVal(strDec, nIndex), decBuf);

    BYTE* hexBuf = new BYTE[nDecLen];
    memset(hexBuf, 0, nDecLen);
    BYTE nTemp = 0;
    for (size_t nDecIndex = 0; nDecIndex < nDecLen; ++nDecIndex) {
        nTemp = 0;
        for (int nBitIndex = 0; nBitIndex < 8; ++nBitIndex) {
            for (size_t nStartIndex = nDecIndex; nStartIndex < nDecLen; ++nStartIndex) {
                decBuf[nStartIndex+1] += (decBuf[nStartIndex]&0x01) == 1?10:0;
                decBuf[nStartIndex] >>= 1;
            }
            nTemp |= decBuf[nDecLen] > 0? (1 << nBitIndex):0;
            decBuf[nDecLen] = 0;
        }
        hexBuf[nDecIndex] = nTemp;
    }

    while (nDecLen > 0) {
        if (hexBuf[--nDecLen] > 0)
            break;
    }

    if (destBuf != NULL)
        memcpy(destBuf, hexBuf, nDecLen+1);

    delete [] decBuf;
    delete [] hexBuf;

    return nDecLen + 1;
}

View Code

以上是10進制轉16進制的代碼，可以調用int StrDec2HexBuf( const StrVal& strDec, BYTE* destBuf )，將strDec的十進制數據轉換成16進制的destBuf字符串，并返回destBuf的有效長度

關于10進制轉16進制的方法：

1、我這里先將strDec轉換成以每個字節代表一個數字的方法表示的方式。然后再進行相應的轉換。void StrDec2BufDec(const StrVal& strDec, BYTE* bufDec)

2、關于十進制轉16進制，我是將十進制轉換成2進制的方式。即對每個數字進行除2取余的方式。具體關于十進制轉16進制方法很多，我用轉換成2進制只是其中一種方法。

#include <string>
typedef std::wstring StrVal;

int CalcStep(byte* cur, int nCurLen) {
    int nTemp = 0;
    for (int nIndex = 0; nIndex < nCurLen; ++nIndex) {
        nTemp += cur[nIndex] * 256;
        cur[nIndex] = nTemp % 10;
        nTemp /= 10;
    }

    while (nTemp > 0) {
        cur[nCurLen++] = nTemp % 10;
        nTemp /= 10;
    }

    return nCurLen;
}

void MulOneByte(byte* dec, int data, byte* base, int nBaseLen) {
    for (int nBaseIndex = 0; nBaseIndex < nBaseLen; ++nBaseIndex) {
        int nTemp = data * base[nBaseIndex];
        for (int nDecIndex = nBaseIndex; nTemp > 0; ++nDecIndex) {
            nTemp += dec[nDecIndex];
            dec[nDecIndex] = nTemp % 10;
            nTemp /= 10;
        }
    }
}

void Hex2Dec(byte* hexBuf, int nHexLen, byte* decBuf) {
    byte* base = new byte[nHexLen*4];
    memset(base, 0, nHexLen*4);
    base[0] = 1;
    int nCurBaseLen = 1;

    for (int nHexIndex = 0; nHexIndex < nHexLen; ++nHexIndex) {
        MulOneByte (decBuf, hexBuf[nHexIndex], base, nCurBaseLen);
        nCurBaseLen = CalcStep(base, nCurBaseLen);
    }
}

//////////////////////////////////////////////////////////////////////////
StrVal Convert2DecData(BYTE* srcData, int nLen) {
    StrVal destStr;

    int nDecLen = nLen*4;
    BYTE* decData = new BYTE[nDecLen];
    memset(decData, 0, nDecLen);
    Hex2Dec(srcData, nLen, decData);

    while (nDecLen-- > 0) {
        if (decData[nDecLen] > 0)
            break;
    }
    wchar_t midBuf[MAX_PATH];
    while (nDecLen >= 0) {
        swprintf_s(midBuf, MAX_PATH, L"%d", decData[nDecLen--]);
        destStr.append(midBuf);
    }

    delete [] decData;

    return destStr;
}

View Code

上面代碼是將16進制轉成10進制的字符串

在void Hex2Dec(byte* hexBuf, int nHexLen, byte* decBuf)這里，我也是將結果以decBuf的每個字節代表一個0~9的數字，這里我new了一個比十六進制緩沖區大4倍的緩沖區來存放數據。（經計算3倍應該夠了）

首先調用void MulOneByte(byte* dec, int data, byte* base, int nBaseLen)

我的base[]初始值為1，然后再乘以hexBuf的每個字節。計算結果再加到dec[]

CalcStep則是為base緩沖區的值（以10進制表示）乘以256

因為Hex2Dec中，hexBuf每次以一個字節的進制從低位到高位進行計算，所以每次計算完成之后需要將base乘以256，然后將base調整成每個字節以10進制表示的形式。

最終

StrVal Convert2DecData(BYTE* srcData, int nLen)函數的顯示。因為我的電腦是小端模式，所以從后往前進行打印輸出。

額外添加自增的函數。具體自增方式可以再修改

void IncData( BYTE* val, INT64 nIncStep ) {
    BYTE* pIncStep = (BYTE*)&nIncStep;

    int nLeft = 0;
    for (int nIndex = 0; nIndex < sizeof(INT64); ++nIndex) {
        for (int nInner = 0; nInner < 8; ++nInner) {
            nLeft = nLeft + (val[nIndex] & (1<<nInner)) + (pIncStep[nIndex] & (1<<nInner));
            val[nIndex] &= ~(1 << nInner);
            val[nIndex] ^= (nLeft & (1<<nInner));
            nLeft &= 1 << (nInner+1);
        }
        nLeft >>= 8;
    }

    for (int nIndex = sizeof(INT64); nLeft > 0; ++nIndex) {
        for (int nInner = 0; nInner < 8 && nLeft > 0; ++nInner) {
            nLeft = nLeft + (val[nIndex] & (1 << nInner));
            val[nIndex] &= nLeft & (1 << nInner) & 0xff;
            nLeft &= 1 << (nInner+1);
        }
        nLeft >>= 8;
    }
}

View Code

總結

以上是生活随笔為你收集整理的十进制跟十六进制的字符串互转的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。