十六进制字符转十进制算法

十六进制与十进制对照

十六进制	十进制
0	0
1	1
2	2
3	3
4	4
5	5
6	6
7	7
8	8
9	9
A	10
B	11
C	12
D	13
E	14
F	15

十六进制与十进制区别

十六进制是满16进1，十进制是满10进1，这里要注意下区别，16进制的字符里面为什么是0-9没有10，这里面进了一位，表示16了。
十六进制转十进制的算法逻辑

处理转换过程分为正序和逆序
正序

从左到右加权累加，每次往右加一个数的时候，原来的数字必要向左变高位移动一位，就是乘以16。比如有一个“1A3”，result记载十进制累加值初始为0，
我们遍历第一次，是1进来：
result=result*16+1=0*16+1=1
第二次，A进来==10，1左移一位：
result=result*16+10=1*16+10=26
第三次，3进来，1A左移一位：
result=result*16+3=26*16+3=419
整体公式其实就是：
result=1*16^2+A*16^1+3*16^0
实现

2. int hexToDecimalManual(const std::string& hexStr) {
3.     int result = 0;
4.     size_t startIdx = (hexStr.substr(0, 2) == "0x" || hexStr.substr(0, 2) == "0X") ? 2 : 0;
5.    
6.     for (size_t i = startIdx; i < hexStr.size(); ++i) {
7.         char c = hexStr[i];
8.         int value;
9.         if (isdigit(c)) {
10.             value = c - '0';
11.         } else if (c >= 'A' && c <= 'F') {
12.             value = 10 + c - 'A';
13.         } else if (c >= 'a' && c <= 'f') {
14.             value = 10 + c - 'a';
15.         } else {
16.             break; // 非法字符终止转换
17.         }
18.         result = result * 16 + value; // 逆序权值累加
19.     }
20.     return result;
21. }

复制代码

逆序

逆序是从右到左遍历字符串，有一个base记载处理的权值，每次引入的字符都是更高位的字符，必要做一个权值处理，实现起来和正序差不多，注意方向就行
实现

2. long long hexToDecimal_Reverse(const string& hex) {
3.     long long result = 0;
4.     long long base = 1; // 初始权值为16^0=1
5.     for (int i = hex.length() - 1; i >= 0; i--) {
6.         char c = hex[i];
7.         int val;
8.         if (c >= '0' && c <= '9') {
9.             val = c - '0';
10.         } else if (c >= 'A' && c <= 'F') {
11.             val = 10 + c - 'A';
12.         } else if (c >= 'a' && c <= 'f') {
13.             val = 10 + c - 'a';
14.         } else {
15.             throw invalid_argument("非法十六进制字符");
16.         }
17.         // 动态调整权值
18.         result += val * base;
19.         base *= 16; // 权值左移（如1→16→256）
20.     }
21.     return result;
22. }
24. // 示例输入：hex = "1A3" → 输出419

复制代码

不建议使用math库的pow,复杂度高了