在C和c++中转换char到int

C和c++总是将类型提升到至少int。此外，字符字面量在C中是int类型，在c++中是char类型。

您可以简单地通过赋值给int来转换char类型。

char c = 'a'; // narrowing on C
int a = c;

这取决于你对“转换”的定义。

如果您有一系列表示整数的字符，如“123456”，那么在C中有两种典型的方法:使用特殊用途的转换，如atoi ()或strtol ()，或通用用途的sscanf ()。c++(实际上是一种伪装成升级版的不同语言)增加了第三种语言stringstreams。

如果您的意思是您希望将int变量中的一个精确的位模式视为char，那就更容易了。在C语言中，不同的整数类型实际上更多的是一种思想状态，而不是实际的独立“类型”。只要在需要# eyz1的地方开始使用它，你就可以了。你可能需要一个显式的转换，使编译器停止抱怨，但所有应该做的是删除超过256的任何额外比特。

想必您需要这种转换来使用C标准库中的函数。

在这种情况下，do (c++语法)

typedef unsigned char UChar;


char myCppFunc( char c )
{
return char( someCFunc( UChar( c ) ) );
}

表达式UChar( c )转换为unsigned char以消除负值，除EOF外，C函数不支持负值。

然后，该表达式的结果被用作int正式参数的实际参数。在这里你可以自动升级到int。您也可以显式地编写最后一步，如int( UChar( c ) )，但我个人认为这太啰嗦了。

干杯,hth。

这取决于你想做什么:

如果要以ASCII码的形式读取该值，可以写入

char a = 'a';
int ia = (int)a;
/* note that the int cast is not necessary -- int ia = a would suffice */

转换字符'0' -> 0， '1' -> 1等，你可以写

char a = '4';
int ia = a - '0';
/* check here if ia is bounded by 0 and 9 */

Char只是一个1字节的整数。char类型没有什么神奇之处!就像你可以将short类型赋值给int类型，或将int类型赋值给long类型一样，你也可以将char类型赋值给int类型。

是的，基本数据类型的名称恰好是"char"，这暗示它应该只包含字符。但实际上，“;char"只是一个糟糕的名字选择，让每个试图学习这门语言的人都感到困惑。更好的名称是int8_t，如果您的编译器遵循最新的C标准，则可以使用该名称。

当然，您应该在进行字符串处理时使用char类型，因为经典ASCII表的索引适合1个字节。然而，可以也使用常规int类型进行字符串处理，尽管在现实世界中没有任何实际原因可以解释为什么要这样做。例如，下面的代码将完美地工作:

  int str[] = {'h', 'e', 'l', 'l', 'o', '\0' };
  

for(i=0; i<6; i++)
{
printf("%c", str[i]);
}

你必须意识到字符和字符串只是数字，就像计算机中的其他东西一样。当您在源代码中写入'a'时，它会被预处理为数字97，这是一个整数常数。

如果你写一个表达式

char ch = '5';
ch = ch - '0';

这实际上等价于

char ch = (int)53;
ch = ch - (int)48;

然后通过C语言的整数提升

ch = (int)ch - (int)48;

然后截断为一个字符以适应结果类型

ch = (char)( (int)ch - (int)48 );

行与行之间有很多微妙的东西，其中char被隐式地当作int。

(这个答案解决了c++方面的问题，但C中也存在符号扩展问题。)

处理所有三个char类型(signed、unsigned和char)比它最初看起来更微妙。0到SCHAR_MAX(对于8位的char来说是127)范围内的值很容易:

char c = somevalue;
signed char sc = c;
unsigned char uc = c;
int n = c;

但是，当somevalue在这个范围之外时，只有通过unsigned char才能在所有三种类型中为“相同”的char值提供一致的结果:

char c = somevalue;
signed char sc = c;
unsigned char uc = c;
// Might not be true: int(c) == int(sc) and int(c) == int(uc).
int nc = (unsigned char)c;
int nsc = (unsigned char)sc;
int nuc = (unsigned char)uc;
// Always true: nc == nsc and nc == nuc.

当使用来自ctype.h的函数时，例如isupper或toupper，这很重要，因为符号扩展:

char c = negative_char;  // Assuming CHAR_MIN < 0.
int n = c;
bool b = isupper(n);  // Undefined behavior.

注意到int的转换是隐式的;这有相同的UB:

char c = negative_char;
bool b = isupper(c);

要解决这个问题，请执行unsigned char，这很容易通过safe_ctype包装ctype.h函数来完成:

template<int (&F)(int)>
int safe_ctype(unsigned char c) { return F(c); }


//...
char c = CHAR_MIN;
bool b = safe_ctype<isupper>(c);  // No UB.


std::string s = "value that may contain negative chars; e.g. user input";
std::transform(s.begin(), s.end(), s.begin(), &safe_ctype<toupper>);
// Must wrap toupper to eliminate UB in this case, you can't cast
// to unsigned char because the function is called inside transform.

这是可行的，因为任何接受三种char类型中的任何一种的函数也可以接受另外两种char类型。它导致两个可以处理任何类型的函数:

int ord(char c) { return (unsigned char)c; }
char chr(int n) {
assert(0 <= n);  // Or other error-/sanity-checking.
assert(n <= UCHAR_MAX);
return (unsigned char)n;
}


// Ord and chr are named to match similar functions in other languages
// and libraries.

ord(c)总是给你一个非负值-即使传递一个负的char或负的signed char -而chr取ord产生的任何值并返回完全相同的char。

在实践中，我可能只使用unsigned char而不是使用这些类型，但是它们简洁地包装了类型转换，提供了一个方便的地方来添加# eyz1到char的错误检查，并且当您需要在近距离使用它们几次时，它们会更短更清楚。

我有问题将"7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e"这样的字符数组转换为它的实际整数值，可以用“7C”表示为一个十六进制值。所以，在四处寻求帮助后，我创建了这个，并认为分享它会很酷。

这将字符字符串分离成正确的整数，可能对更多的人有帮助，而不仅仅是我;)

unsigned int* char2int(char *a, int len)
{
int i,u;
unsigned int *val = malloc(len*sizeof(unsigned long));


for(i=0,u=0;i<len;i++){
if(i%2==0){
if(a[i] <= 57)
val[u] = (a[i]-50)<<4;
else
val[u] = (a[i]-55)<<4;
}
else{
if(a[i] <= 57)
val[u] += (a[i]-50);
else
val[u] += (a[i]-55);
u++;
}
}
return val;
}

希望能有所帮助!

对于char或short to int，只需要赋值。

char ch = 16;
int in = ch;

与int64相同。

long long lo = ch;

所有值都是16。

使用# EYZ0:

int num = static_cast<int>(letter); // if letter='a', num=97

你可能应该尽量避免使用(int)

Int num = (Int)字母;

查看为什么使用static_cast<int>(x)而不是(int)x?获取更多信息。

在ASCII码中，数字(数字)从48开始。你所需要做的就是:

int x = (int)character - 48;

或者，因为字符' 0 '的ASCII码是48，你可以这样写:

int x = character - '0';  // The (int) cast is not necessary.

我有绝对的null技能在C，但一个简单的解析:

char* something = "123456";


int number = parseInt(something);

.．.这招对我很管用:

int parseInt(char* chars)
{
int sum = 0;
int len = strlen(chars);
for (int x = 0; x < len; x++)
{
int n = chars[len - (x + 1)] - '0';
sum = sum + powInt(n, x);
}
return sum;
}


int powInt(int x, int y)
{
for (int i = 0; i < y; i++)
{
x *= 10;
}
return x;
}

int charToint(char a){
char *p = &a;
int k = atoi(p);
return k;
}

您可以使用此atoi方法将char转换为int。有关更多信息，您可以参考http://www.cplusplus.com/reference/cstdlib/atoi/， http://www.cplusplus.com/reference/string/stoi/。

我建议使用以下函数:

/* chartoint: convert char simbols to unsigned int*/
int chartoint(char s[])
{


int i, n;
n = 0;
for (i = 0; isdigit(s[i]); ++i){
n = 10 * n + (s[i] - '0');
}
return n;
}

函数的结果可以通过以下方法检查:

printf("char 00: %d \r\n", chartoint("00"));
printf("char 01: %d \r\n", chartoint("01"));
printf("char 255: %d \r\n", chartoint("255"));

使用"long "取而代之的是"所以它适用于更大的数字。这里是优雅的解决方案。

long long ChardToint(char *arr, size_t len){
   

int toptenf=1;
long long toptenLf=10000000LL;
long long makeintf=3000000000000;
 

   

makeintf= 0LL;




int holdNumberf=0;
for(int i=len-1;i>=0 ;i--){
switch(arr[i]){
case '0':
holdNumberf=0;
break;
case '1':
holdNumberf=1;
break;
case '2':
holdNumberf=2;
break;
case '3':
holdNumberf=3;
break;
case '4':
holdNumberf=4;
break;
case '5':
holdNumberf=5;
break;
case '6':
holdNumberf=6;
break;
case '7':
holdNumberf=7;
break;
case '8':
holdNumberf=8;
break;
case '9':
holdNumberf=9;
break;


default:
holdNumberf=0;
}
if(toptenf>=10000000){
makeintf=makeintf+holdNumberf*toptenLf;
      

  

toptenLf=toptenLf*10;
}else{
makeintf=makeintf+holdNumberf*toptenf;
     



toptenf=toptenf*10;
}
}
return makeintf;


}