我有一个 char[]，其中包含诸如“0x1800785”之类的值，但我想要为其提供该值的函数需要一个 int，如何将其转换为 int？我四处搜寻但找不到答案。谢谢。
你试过吗
strtol()示例：
const char *hexstring = "abcdef0";
int number = (int)strtol(hexstring, NULL, 16);
如果数字的字符串表示形式以
0xconst char *hexstring = "0xabcdef0";
int number = (int)strtol(hexstring, NULL, 0);
（也可以指定显式基数，例如 16，但我不建议引入冗余。）
或者，如果您想拥有自己的实现，我编写了这个快速函数作为示例：
/**
* hex2int
* take a hex string and convert it to a 32bit number (max 8 hex digits)
*/
uint32_t hex2int(char *hex) {
uint32_t val = 0;
while (*hex) {
// get current character then increment
uint8_t byte = *hex++;
// transform hex character to the 4bit equivalent number, using the ascii table indexes
if (byte >= '0' && byte <= '9') byte = byte - '0';
else if (byte >= 'a' && byte <='f') byte = byte - 'a' + 10;
else if (byte >= 'A' && byte <='F') byte = byte - 'A' + 10;
// shift 4 to make space for new digit, and add the 4 bits of the new digit
val = (val << 4) | (byte & 0xF);
}
return val;
}
这样的东西可能会有用：
char str[] = "0x1800785";
int num;
sscanf(str, "%x", &num);
printf("0x%x %i\n", num, num);
如果您有可用的 libc（如最佳答案所示），请使用
strtol#include <inttypes.h>
/**
* xtou64
* Take a hex string and convert it to a 64bit number (max 16 hex digits).
* The string must only contain digits and valid hex characters.
*/
uint64_t xtou64(const char *str)
{
uint64_t res = 0;
char c;
while ((c = *str++)) {
char v = (c & 0xF) + (c >> 6) | ((c >> 3) & 0x8);
res = (res << 4) | (uint64_t) v;
}
return res;
}
位移魔法归结为：只需使用最后 4 位，但如果它是非数字，则还要添加 9。
假设你的意思是它是一个字符串，strtol怎么样？
一个快速但肮脏的解决方案：
// makes a number from two ascii hexa characters
int ahex2int(char a, char b){
a = (a <= '9') ? a - '0' : (a & 0x7) + 9;
b = (b <= '9') ? b - '0' : (b & 0x7) + 9;
return (a << 4) + b;
}
你必须确保你的输入是正确的，不包括验证（可以说是C）。好消息是它非常紧凑，它适用于“A”到“F”和“a”到“f”。
该方法依赖于 ASCII 表中字母字符的位置，让我们看看例如维基百科 (https://en.wikipedia.org/wiki/ASCII#/media/File:USASCII_code_chart.png)。长话短说，数字位于字符下方，因此数字字符（0 到 9）可以通过减去零代码轻松转换。字母字符（A 到 F）的读取方法是，将最后三位以外的其他位清零（有效地使其适用于大写或小写），减一（因为在位屏蔽之后，字母表从位置一开始）并加十（因为A到F代表十六进制代码中的第10到15个值）。最后，我们需要组合形成编码数字的低半字节和高半字节的两个数字。
这里我们采用相同的方法（有细微的变化）：
#include <stdio.h>
// takes a null-terminated string of hexa characters and tries to
// convert it to numbers
long ahex2num(unsigned char *in){
unsigned char *pin = in; // lets use pointer to loop through the string
long out = 0; // here we accumulate the result
while(*pin != 0){
out <<= 4; // we have one more input character, so
// we shift the accumulated interim-result one order up
out += (*pin < 'A') ? *pin & 0xF : (*pin & 0x7) + 9; // add the new nibble
pin++; // go ahead
}
return out;
}
// main function will test our conversion fn
int main(void) {
unsigned char str[] = "1800785"; // no 0x prefix, please
long num;
num = ahex2num(str); // call the function
printf("Input: %s\n",str); // print input string
printf("Output: %x\n",num); // print the converted number back as hexa
printf("Check: %ld = %ld \n",num,0x1800785); // check the numeric values matches
return 0;
}
尝试下面的代码块，它对我有用。
char p[] = "0x820";
uint16_t intVal;
sscanf(p, "%x", &intVal);
printf("value x: %x - %d", intVal, intVal);
输出是：
value x: 820 - 2080
所以，经过一段时间的搜索，发现 strtol 相当慢，我编写了自己的函数。它仅适用于字母上的大写字母，但添加小写字母功能不是问题。
int hexToInt(PCHAR _hex, int offset = 0, int size = 6)
{
int _result = 0;
DWORD _resultPtr = reinterpret_cast<DWORD>(&_result);
for(int i=0;i<size;i+=2)
{
int _multiplierFirstValue = 0, _addonSecondValue = 0;
char _firstChar = _hex[offset + i];
if(_firstChar >= 0x30 && _firstChar <= 0x39)
_multiplierFirstValue = _firstChar - 0x30;
else if(_firstChar >= 0x41 && _firstChar <= 0x46)
_multiplierFirstValue = 10 + (_firstChar - 0x41);
char _secndChar = _hex[offset + i + 1];
if(_secndChar >= 0x30 && _secndChar <= 0x39)
_addonSecondValue = _secndChar - 0x30;
else if(_secndChar >= 0x41 && _secndChar <= 0x46)
_addonSecondValue = 10 + (_secndChar - 0x41);
*(BYTE *)(_resultPtr + (size / 2) - (i / 2) - 1) = (BYTE)(_multiplierFirstValue * 16 + _addonSecondValue);
}
return _result;
}
用途：
char *someHex = "#CCFF00FF";
int hexDevalue = hexToInt(someHex, 1, 8);
1 是因为我们要转换的十六进制从偏移量 1 开始，8 是因为它是十六进制长度。
速度测试（1.000.000 次调用）：
strtol ~ 0.4400s
hexToInt ~ 0.1100s
这是一个直接将包含 char 数组的十六进制转换为整数的函数，不需要额外的库：
int hexadecimal2int(char *hdec) {
int finalval = 0;
while (*hdec) {
int onebyte = *hdec++;
if (onebyte >= '0' && onebyte <= '9'){onebyte = onebyte - '0';}
else if (onebyte >= 'a' && onebyte <='f') {onebyte = onebyte - 'a' + 10;}
else if (onebyte >= 'A' && onebyte <='F') {onebyte = onebyte - 'A' + 10;}
finalval = (finalval << 4) | (onebyte & 0xF);
}
finalval = finalval - 524288;
return finalval;
}
我以前做过类似的事情，我想这可能对你有帮助。
以下对我有用：
int main(){
int co[8];
char ch[8];
printf("please enter the string:");
scanf("%s", ch);
for (int i=0; i<=7; i++) {
if ((ch[i]>='A') && (ch[i]<='F')) {
co[i] = (unsigned int) ch[i]-'A'+10;
} else if ((ch[i]>='0') && (ch[i]<='9')) {
co[i] = (unsigned int) ch[i]-'0'+0;
}
}
这里我只取了8个字符的字符串。 如果您愿意，可以为“a”到“f”添加类似的逻辑，以给出它们等效的十六进制值。不过，我没有这样做，因为我不需要它。
我制作了一个库来进行十六进制/十进制转换，而不使用
stdio.hunsigned hexdec (const char *hex, const int s_hex);
在第一次转换之前，使用以下命令初始化用于转换的数组：
void init_hexdec ();
这里是 github 上的链接：https://github.com/kevmuret/libhex/
我喜欢@radhoo 解决方案，在小型系统上非常高效。人们可以修改将十六进制转换为 int32_t 的解决方案（因此，有符号值）。
/**
* hex2int
* take a hex string and convert it to a 32bit number (max 8 hex digits)
*/
int32_t hex2int(char *hex) {
uint32_t val = *hex > 56 ? 0xFFFFFFFF : 0;
while (*hex) {
// get current character then increment
uint8_t byte = *hex++;
// transform hex character to the 4bit equivalent number, using the ascii table indexes
if (byte >= '0' && byte <= '9') byte = byte - '0';
else if (byte >= 'a' && byte <='f') byte = byte - 'a' + 10;
else if (byte >= 'A' && byte <='F') byte = byte - 'A' + 10;
// shift 4 to make space for new digit, and add the 4 bits of the new digit
val = (val << 4) | (byte & 0xF);
}
return val;
}
注意返回值是int32_t，而val仍然是uint32_t以免溢出。
那个
uint32_t val = *hex > 56 ? 0xFFFFFFFF : 0;
无法防止格式错误的字符串。
这是一个基于“sairam singh”解决方案的解决方案。如果答案是一对一的解决方案，则该解决方案将两个 ASCII 半字节组合成一个字节。
// Assumes input is null terminated string.
//
// IN OUT
// -------------------- --------------------
// Offset Hex ASCII Offset Hex
// 0 0x31 1 0 0x13
// 1 0x33 3
// 2 0x61 A 1 0xA0
// 3 0x30 0
// 4 0x00 NULL 2 NULL
int convert_ascii_hex_to_hex2(char *szBufOut, char *szBufIn) {
int i = 0; // input buffer index
int j = 0; // output buffer index
char a_byte;
// Two hex digits are combined into one byte
while (0 != szBufIn[i]) {
// zero result
szBufOut[j] = 0;
// First hex digit
if ((szBufIn[i]>='A') && (szBufIn[i]<='F')) {
a_byte = (unsigned int) szBufIn[i]-'A'+10;
} else if ((szBufIn[i]>='a') && (szBufIn[i]<='f')) {
a_byte = (unsigned int) szBufIn[i]-'a'+10;
} else if ((szBufIn[i]>='0') && (szBufIn[i]<='9')) {
a_byte = (unsigned int) szBufIn[i]-'0';
} else {
return -1; // error with first digit
}
szBufOut[j] = a_byte << 4;
// second hex digit
i++;
if ((szBufIn[i]>='A') && (szBufIn[i]<='F')) {
a_byte = (unsigned int) szBufIn[i]-'A'+10;
} else if ((szBufIn[i]>='a') && (szBufIn[i]<='f')) {
a_byte = (unsigned int) szBufIn[i]-'a'+10;
} else if ((szBufIn[i]>='0') && (szBufIn[i]<='9')) {
a_byte = (unsigned int) szBufIn[i]-'0';
} else {
return -2; // error with second digit
}
szBufOut[j] |= a_byte;
i++;
j++;
}
szBufOut[j] = 0;
return 0; // normal exit
}
这是我将十六进制转换为整数的解决方案。很简单的！要处理十六进制数组，可以使用“for 循环”。
#include<stdio.h>
int main (void)
{
unsigned char t=0x8A;
int c = (t>>4 )*16 + (t & 0x0F);
printf("The integrate value of 0X8A is : %d\n", c);
}
该值应为 138。
我知道这确实很旧，但我认为解决方案看起来太复杂了。在 VB 中尝试一下：
Public Function HexToInt(sHEX as String) as long
Dim iLen as Integer
Dim i as Integer
Dim SumValue as Long
Dim iVal as long
Dim AscVal as long
iLen = Len(sHEX)
For i = 1 to Len(sHEX)
AscVal = Asc(UCase(Mid$(sHEX, i, 1)))
If AscVal >= 48 And AscVal <= 57 Then
iVal = AscVal - 48
ElseIf AscVal >= 65 And AscVal <= 70 Then
iVal = AscVal - 55
End If
SumValue = SumValue + iVal * 16 ^ (iLen- i)
Next i
HexToInt = SumValue
End Function