진수 턴 EX의 C는 / C ++ 16 RPM의 16 진수 문자열

 

{

INT 암호화 :: HexToStr ( 숯 * 16 진수) 
{ 
    INT _0 = 0 ;
    INT _1 = 0 ;
    숯 BUF [ 2 ] = { 0 };
    경우 (16 진수 [ 0 ]> = ' 0 ' && 진수 [ 0 ] <= ' 9 ' ) 
    { 
        BUF [ 0 ] = 진수 [ 0 ]; 
        _0 = atoi 함수 (BUF); 
    } 
    다른 
    { 
        스위치 (16 진수 [ 0]) 
        { 
        경우  ' ' : 
        { 
            _0 = 10 ; 
        }; 휴식 ;
        경우 ' B ' : 
        { 
            _0 = 11 ; 
        }; 휴식 ;
        경우는 ' C ' : 
        { 
            _0 = 12 ; 
        }; 휴식 ;
        경우 ' D ' : 
        {    
            _0 =(13) ; 
        }; 휴식 ;
        케이스  ' E ' : 
        { 
            _0 = 14 ; 
        }; 휴식 ;
        경우  ' F ' : 
        { 
            _0 = 15 ; 
        }; 휴식 ; 
        } 

    } 
    경우 (16 진수 [ 1 ]> = ' 0 ' && 진수 [ 1 ] <= ' 9 ' 0 )
    { 
        BUF [ ] = 진수 [ 1 ]; 
        _1 = atoi 함수 (BUF); 
    } 
    다른 
    { 
        스위치 (16 진수 [ 1 ]) 
        { 
        경우  ' ' : 
        { 
            _1 = 10 ; 
        }; 휴식 ;
        경우 ' B ' : 
        { 
            _1 = 11 ; 
        }; 휴식 ;
        경우 ' C ' :   
        { 
            _1 =(12) ; 
        }; 휴식 ;
        경우  ' D ' : 
        { 
            _1 = 13 ; 
        }; 휴식 ;
        케이스  ' E ' : 
        { 
            _1 = 14 ; 
        }; 휴식 ;
        경우  ' F ' : 
        { 
            _1 = 15 ; 
        }; 휴식  ;
        } 

    } 

    반환 _0 * 16 + _1 단계; 
} 

문자 * 암호화 :: StringToHex_s ( 문자 * 문자열, INT Inlen) 
{ 
    경우 (문자열 == NULL || 문자열 == nullptr) { 반환 nullptr; } 

    INT BufLen = Inlen * 2 + 1 ; 

    숯 *를 버퍼 = 새  문자 [BufLen]; 
    memset 함수 (를 버퍼, 0 , BufLen); 

    숯 BUF [ 3 ] = { 0 }; 

    위한 ( INT 난 = 0 ; I <Inlen; 나는 ++ ) 
    {
        sprintf_s (BUF, " % 02X " (부호 문자 ) 문자열 [I]); 
        (를 버퍼 +는 (i * 2 )) [ 0 ] = BUF [ 0 ]; 
        (를 버퍼 +는 (i * 2 )) [ 1 ] = buf에 [ 1 ]; 
    } 
    반환 버피; 
} 

문자 * 암호화 :: StringToHex_s ( const를  숯불 * 문자열, INT Inlen) 
{ 
    반환 암호화 :: StringToHex_s (( 문자 * ) 문자열, Inlen); 
} 

문자* 암호화 :: HexToString_s ( 문자 * 진수, INT * OutLen) 
{ 
    경우 (16 진수 == NULL || 진수 == nullptr) { 반환 nullptr; } 

    INT HexLen = ( INT )의 strlen (16 진수); 

    경우 (HexLen %의 2 == 0 ) 
    { 
        INT의 인덱스 = 0 ;
        INT LEN = HexLen / 2 ;
        숯 * BUF = 새  문자 [LEN + 1 ]; 
        memset 함수 (BUF, 0 렌 + 1 );
        * = OutLen렌;
        위한 ( INT 난 = 0 ; I <LEN; I ++ ) 
        { 
            부호 숯  VAR = 암호화 :: HexToStr (16 진수 +의 지표); 
            BUF [I] = VAR ; 
            인덱스 + = 2 ; 
        } 
        반환 buf를; 
    } 
    반환 NULL을; 
} 

문자 * 암호화 :: HexToString_s ( const를  문자 * 진수, INT * OutLen) 
{ 
    반환 암호화 :: HexToString_s (( 문자 *) 헥스 OutLen); 
}

 

}