進ターンEXのC / C ++では、16 rpmでの16進文字列

 

{

INT暗号:: HexToStr（CHAR * ヘキサン）
{ 
    int型 _0 = 0 。
    int型 _1 = 0 ;
    チャー BUF [ 2 ] = { 0 }。
    もし（16進数[ 0 ]> = ' 0 ' &&ヘックス[ 0 ] <= ' 9 ' ）
    { 
        BUF [ 0 ] =ヘックス[ 0 ]。
        _0 = ATOI（BUF）。
    } 
    他
    { 
        スイッチ（16進数[ 0]）
        { 
        ケース ' A ' ：
        { 
            _0 = 10 。
        }。休憩;
        ケース ' B ' ：
        { 
            _0 = 11 。
        }。休憩;
        ケース ' C ' ：
        { 
            _0 = 12 。
        }。休憩;
        ケース ' D ' ：
        { 
            _0 = 13 。
        }。休憩;
        ケース ' E ' ：
        { 
            _0 = 14 。
        }。休憩;
        ケース ' F ' ：
        { 
            _0 = 15 。
        }。休憩; 
        } 

    } 
    もし（16進数[ 1 ]> = ' 0 ' &&ヘックス[ 1 ] <= ' 9 ' ）
    { 
        BUF [ 0 ] =ヘキサ[ 1 ]。
        _1 = ATOI（BUF）。
    } 
    他
    { 
        スイッチ（16進数[ 1 ]）
        { 
        ケース ' A ' ：
        { 
            _1 = 10 。
        }。休憩;
        ケース ' B ' ：
        { 
            _1 = 11 。
        }。休憩;
        ケース ' C ' ：
        { 
            _1 = ;12 ; 
        }。休憩;
        ケース ' D ' ：
        { 
            _1 = 13 。
        }。休憩;
        ケース ' E ' ：
        { 
            _1 = 14 。
        }。休憩;
        ケース ' F ' ：
        { 
            _1 = 15 。
        }。休憩
        } 

    } 

    リターン _0 *16 + _1。
} 

のchar *暗号化:: StringToHex_s（CHAR *文字列、INT Inlen）
{ 
    場合（文字列== NULL ||文字列== nullptr）{ 戻りnullptr。} 

    INT BUFLEN = Inlen * 2 + 1 。

    char * bufに= 新しい のchar [BUFLEN]。
    memset（BUF、0 、BUFLEN）。

    チャー BUF [ 3 ] = { 0 }。

    用（INTは iは= 0 ; I <Inlen I ++） 
    {
        sprintf_s（BUF、" ％02X "、（符号なし文字）の文字列[I]）。
        （BUF +（i *が2））[ 0 ] = BUF [ 0 ]。
        （BUF +（i *が2））[ 1 ] = BUF [ 1 ]。
    } 
    戻りBUFと、
} 

のchar *暗号化:: StringToHex_s（CONST  のchar *文字列、INT Inlen）
{ 
    戻り暗号:: StringToHex_s（（CHAR * ）文字列、Inlen）。
} 

チャー*暗号化:: HexToString_s（CHAR * HEX、INT * outlenは）
{ 
    場合（16進数== NULL ||六角== nullptr）{ 戻りnullptr。} 

    INT HexLen =（INT ）STRLEN（16進数）。

    もし（HexLen％2 == 0 ）
    { 
        int型のインデックス= 0 。
        int型のlen = HexLen / 2 ;
        CHAR * BUF = 新しい 文字 [LEN + 1 ]。
        memset（BUF、0、LEN + 1 ）。
        * outlenは=LEN;
        以下のために（INT iが= 0 ; I <LEN; I ++ ）
        { 
            符号なしチャー VAR =暗号化:: HexToStr（16進数+の指標）
            [i]はBUF = VAR 。
            インデックス + = 2 ; 
        } 
        戻りBUF。
    } 
    戻りNULL。
} 

のchar *暗号化:: HexToString_s（CONST  のchar * HEX、INT * outlenは）
{ 
    戻り暗号:: HexToString_s（（CHAR *）HEX、outlenは）。
}

 

}