字符转数值，转十六进制，十六进制字符直接转十进制数值

/将字符转为数值

int char_to_int(char ch)
{
 // 如果是数字，则用数字的ASCII码减去48, 如果ch = '2' ,则 '2' - 48 = 2  
    if(isdigit(ch))  
            return ch - 48;  

    // 如果是字母，但不是A~F,a~f则返回  
    if( ch < 'A' || (ch > 'F' && ch < 'a') || ch > 'z' )  
            return -1;  

    // 如果是大写字母，则用数字的ASCII码减去55, 如果ch = 'A' ,则 'A' - 55 = 10  
    // 如果是小写字母，则用数字的ASCII码减去87, 如果ch = 'a' ,则 'a' - 87 = 10  
    if(isalpha(ch))  
            return isupper(ch) ? ch - 55 : ch - 87;  

    return -1;  
}


//将两个十进制数值合并成十六进制
int int_to_hex(char a,char b)
{   
    int hex=0x00;
    if(isdigit(a))
    {
        if(isdigit(b))   //字符B是数字
            {
            hex = (a -48)<<4;
            hex |=(b-48);
            }
        else
            {
                switch (b)
                    {
                        case 'A':
                            hex = (a -48)<<4;
                            hex |=0xA;
                            break;
                        case 'B':
                            hex = (a -48)<<4;
                            hex |=0xB;
                            break;
                        case 'C':
                            hex = (a -48)<<4;
                            hex |=0xC;
                            break;
                        case 'D':
                            hex = (a -48)<<4;
                            hex |=0xD;
                            break;
                        case 'E':
                            hex = (a -48)<<4;
                            hex |=0xE;
                            break;
                        case 'F':
                            hex = (a -48)<<4;
                            hex |=0xF;
                            break;
                        default:
                            return -1;
                            break;
                    }
            }
    }

    else
        {
            if(isdigit(b))   //字符B是数字
                {
                    switch (a)
                    {
                        case 'A':
                            hex = 0xA<<4;
                            hex |=(b-48);
                            break;
                        case 'B':
                            hex = 0xB<<4;
                            hex |=(b-48);
                            break;
                        case 'C':
                            hex = 0xC<<4;
                            hex |=(b-48);
                            break;
                        case 'D':
                            hex = 0xD<<4;
                            hex |=(b-48);
                            break;
                        case 'E':
                            hex = 0xE<<4;
                            hex |=(b-48);
                            break;
                        case 'F':
                            hex = 0xF<<4;
                            hex |=(b-48);
                            break;
                        default:
                            return -1;
                            break;
                    }
                }


            //字符 a,b都是字母
            else
                {
                    switch (a)
                    {
                        case 'A':
                            switch (b)
                                {
                                    case 'A':
                                        hex = 0xA<<4;
                                        hex |=0xA;
                                        break;
                                    case 'B':
                                        hex = 0xA<<4;
                                        hex |=0xB;
                                        break;
                                    case 'C':
                                        hex = 0xA<<4;
                                        hex |=0xC;
                                        break;
                                    case 'D':
                                        hex = 0xA<<4;
                                        hex |=0xD;
                                        break;
                                    case 'E':
                                        hex = 0xA<<4;
                                        hex |=0xE;
                                        break;
                                    case 'F':
                                        hex = 0xA<<4;
                                        hex |=0xF;
                                        break;
                                    default:
                                        return -1;
                                        break;
                                }
                            break;
                            
                        case 'B':
                            switch (b)
                                {
                                    case 'A':
                                        hex = 0xB<<4;
                                        hex |=0xA;
                                        break;
                                    case 'B':
                                        hex = 0xB<<4;
                                        hex |=0xB;
                                        break;
                                    case 'C':
                                        hex = 0xB<<4;
                                        hex |=0xC;
                                        break;
                                    case 'D':
                                        hex = 0xB<<4;
                                        hex |=0xD;
                                        break;
                                    case 'E':
                                        hex = 0xB<<4;
                                        hex |=0xE;
                                        break;
                                    case 'F':
                                        hex = 0xB<<4;
                                        hex |=0xF;
                                        break;
                                    default:
                                        return -1;
                                        break;
                                }
                            
                            break;

                            
                        case 'C':
                            switch (b)
                                {
                                    case 'A':
                                        hex = 0xC<<4;
                                        hex |=0xA;
                                        break;
                                    case 'B':
                                        hex = 0xC<<4;
                                        hex |=0xB;
                                        break;
                                    case 'C':
                                        hex = 0xC<<4;
                                        hex |=0xC;
                                        break;
                                    case 'D':
                                        hex = 0xC<<4;
                                        hex |=0xD;
                                        break;
                                    case 'E':
                                        hex = 0xC<<4;
                                        hex |=0xE;
                                        break;
                                    case 'F':
                                        hex = 0xC<<4;
                                        hex |=0xF;
                                        break;
                                    default:
                                        return -1;
                                        break;
                                }
                            
                            break;
                        case 'D':
                            switch (b)
                                {
                                    case 'A':
                                        hex = 0xD<<4;
                                        hex |=0xA;
                                        break;
                                    case 'B':
                                        hex = 0xD<<4;
                                        hex |=0xB;
                                        break;
                                    case 'C':
                                        hex = 0xD<<4;
                                        hex |=0xC;
                                        break;
                                    case 'D':
                                        hex = 0xD<<4;
                                        hex |=0xD;
                                        break;
                                    case 'E':
                                        hex = 0xD<<4;
                                        hex |=0xE;
                                        break;
                                    case 'F':
                                        hex = 0xD<<4;
                                        hex |=0xF;
                                        break;
                                    default:
                                        return -1;
                                        break;
                                }
                            
                            break;
                        case 'E':
                                switch (b)
                                {
                                    case 'A':
                                        hex = 0xE<<4;
                                        hex |=0xA;
                                        break;
                                    case 'B':
                                        hex = 0xE<<4;
                                        hex |=0xB;
                                        break;
                                    case 'C':
                                        hex = 0xE<<4;
                                        hex |=0xC;
                                        break;
                                    case 'D':
                                        hex = 0xE<<4;
                                        hex |=0xD;
                                        break;
                                    case 'E':
                                        hex = 0xE<<4;
                                        hex |=0xE;
                                        break;
                                    case 'F':
                                        hex = 0xE<<4;
                                        hex |=0xF;
                                        break;
                                    default:
                                        return -1;
                                        break;
                                }
                            
                            break;
                        case 'F':
                                switch (b)
                                {
                                    case 'A':
                                        hex = 0xF<<4;
                                        hex |=0xA;
                                        break;
                                    case 'B':
                                        hex = 0xF<<4;
                                        hex |=0xB;
                                        break;
                                    case 'C':
                                        hex = 0xF<<4;
                                        hex |=0xC;
                                        break;
                                    case 'D':
                                        hex = 0xF<<4;
                                        hex |=0xD;
                                        break;
                                    case 'E':
                                        hex = 0xF<<4;
                                        hex |=0xE;
                                        break;
                                    case 'F':
                                        hex = 0xF<<4;
                                        hex |=0xF;
                                        break;
                                    default:
                                        return -1;
                                        break;
                                }
                            break;
                        default:
                            return -1;
                            break;
                    }


                }
        }
    return hex==0 ? 0x00 : hex;
}



//将十六进制字符串转为数值
int hextoint(char *hex)
{
    int len;  
    int num = 0;  
    int temp;  
    int bits;  
    int i;  
    len=strlen(hex);
    // 第一次：i=0, *(hex + i) = *(hex + 0) = '1', 即temp = 1  
    // 第二次：i=1, *(hex + i) = *(hex + 1) = 'd', 即temp = 13  
    // 第三次：i=2, *(hex + i) = *(hex + 2) = 'd', 即temp = 14 
    for (i=0, temp=0; i<len; i++, temp=0)  
        {
            temp=char_to_int(*(hex+i));
    // 总共3位，一个16进制位用 4 bit保存  
    // 第一次：'1'为最高位，所以temp左移 (len - i -1) * 4 = 2 * 4 = 8 位  
    // 第二次：'d'为次高位，所以temp左移 (len - i -1) * 4 = 1 * 4 = 4 位  
    // 第三次：'e'为最低位，所以temp左移 (len - i -1) * 4 = 0 * 4 = 0 位  
    bits=(len-i-1)*4;
    temp=temp<<bits;

    //此处也可以用num+=temp进行累加
    num=num|temp;
        }
    //返回结果
    return num;
}