Como converter um char
para um int
em C e C ++?
c
- chave e c++
, acho que as respostas que confrontam os dois idiomas são razoáveis.
char
realmente significa.
Como converter um char
para um int
em C e C ++?
c
- chave e c++
, acho que as respostas que confrontam os dois idiomas são razoáveis.
char
realmente significa.
Respostas:
Depende do que você quer fazer:
para ler o valor como um código ascii, você pode escrever
char a = 'a';
int ia = (int)a;
/* note that the int cast is not necessary -- int ia = a would suffice */
para converter o personagem '0' -> 0
, '1' -> 1
, etc, você pode escrever
char a = '4';
int ia = a - '0';
/* check here if ia is bounded by 0 and 9 */
Explicação :
a - '0'
é equivalente a ((int)a) - ((int)'0')
, o que significa que os valores ascii dos caracteres são subtraídos um do outro. Como 0
vem diretamente antes 1
na tabela ascii (e assim por diante até 9
), a diferença entre os dois fornece o número que o caractere a
representa.
&
-> -10) e números maiores que 10 (como x
-> 26)
'1'
fornece um número ASCII que não é 1
, você precisa remover o deslocamento '0'
para realinhar o número de 0 a 9. Os números consecutivos 1-9 são adjacentes no número inteiro ascii.
Bem, no código ASCII, os números (dígitos) começam em 48 . Tudo que você precisa fazer é:
int x = (int)character - 48;
'0'
C e C ++ sempre promovem tipos para pelo menos int
. Além disso, literais de caracteres são do tipo int
em C e char
em C ++.
Você pode converter um char
tipo simplesmente atribuindo a um int
.
char c = 'a'; // narrowing on C
int a = c;
operator+()
para esse fim.
int a = c;
) manterá quaisquer valores negativos, com os quais as funções da biblioteca padrão C não podem lidar. As funções da biblioteca padrão C definem o padrão para o que significa manipular char
valores como int
.
char é apenas um número inteiro de 1 byte. Não há nada mágico com o tipo de caractere! Assim como você pode atribuir um curto a um int, ou um int a um longo, também pode atribuir um char a um int.
Sim, o nome do tipo de dados primitivo passa a ser "char", o que insinua que ele deve conter apenas caracteres. Mas, na realidade, "char" é apenas uma má escolha para confundir todos que tentam aprender o idioma. Um nome melhor para ele é int8_t e você pode usá-lo, se o seu compilador seguir o padrão C mais recente.
Embora, é claro, você deva usar o tipo char ao manipular string, porque o índice da tabela ASCII clássica cabe em 1 byte. No entanto, você também pode manipular cordas com ints regulares, embora não exista uma razão prática no mundo real para fazer isso. Por exemplo, o código a seguir funcionará perfeitamente:
int str[] = {'h', 'e', 'l', 'l', 'o', '\0' };
for(i=0; i<6; i++)
{
printf("%c", str[i]);
}
Você precisa entender que caracteres e seqüências de caracteres são apenas números, como tudo o mais no computador. Quando você escreve 'a' no código-fonte, ele é pré-processado no número 97, que é uma constante inteira.
Então, se você escrever uma expressão como
char ch = '5';
ch = ch - '0';
isso é realmente equivalente a
char ch = (int)53;
ch = ch - (int)48;
que passa pelas promoções de números inteiros da linguagem C
ch = (int)ch - (int)48;
e, em seguida, truncado para um caractere para caber no tipo de resultado
ch = (char)( (int)ch - (int)48 );
Há muitas coisas sutis como essas acontecendo nas entrelinhas, onde char é implicitamente tratado como int.
ascii
, você não deve assumir nenhuma codificação específica. Definir char
igual a int8_t
está errado porque poderia igualmente ser uint8_t
ou uint24_t
.
char
é sempre 1 byte e se os tipos int8_t
/ uint8_t
existirem no sistema fornecido (o que é muito provável), eles poderão ajustar o resultado de a char
, porque serão 8 bits. Em sistemas altamente exóticos, como vários DSPs obsoletos, char
haverá 16 bits e uint8_t
eles não existirão. Escrever código para compatibilidade com DSPs obsoletos não faz sentido, assim como escrever para compatibilidade com os sistemas de complemento ou sinal e magnitude. Enorme perda de tempo, uma vez que tais sistemas mal existem no mundo real.
(Esta resposta aborda o lado C ++, mas o problema de extensão de sinal também existe em C).
O manuseio dos três char
tipos ( signed
, unsigned
e char
) é mais delicado do que parece à primeira vista. Os valores no intervalo de 0 a SCHAR_MAX
(que é 127 para um de 8 bits char
) são fáceis:
char c = somevalue;
signed char sc = c;
unsigned char uc = c;
int n = c;
Mas, quando somevalue
está fora desse intervalo, apenas a unsigned char
execução fornece resultados consistentes para os "mesmos" char
valores nos três tipos:
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.
Isso é importante ao usar funções de ctype.h , como isupper
ou toupper
, devido à extensão de sinal:
char c = negative_char; // Assuming CHAR_MIN < 0.
int n = c;
bool b = isupper(n); // Undefined behavior.
Observe que a conversão através de int está implícita; isso tem o mesmo UB:
char c = negative_char;
bool b = isupper(c);
Para corrigir isso, prossiga unsigned char
, o que é feito facilmente, envolvendo as funções ctype.h por safe_ctype :
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.
Isso funciona porque qualquer função que aceite um dos três tipos de caracteres também pode aceitar os outros dois tipos de caracteres. Isso leva a duas funções que podem lidar com qualquer um dos tipos:
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)
sempre fornece um valor não negativo - mesmo quando passado como negativo char
ou negativo signed char
- e chr
aceita qualquer valor que ord
produz e devolve exatamente o mesmo char
.
Na prática, eu provavelmente apenas transmiti-lo em unsigned char
vez de usá-los, mas eles encapsulam sucintamente o elenco, fornecem um local conveniente para adicionar verificação de erros para - e - e int
fica char
mais curto e mais claro quando você precisa usá-los várias vezes nas proximidades.
Use static_cast<int>
:
int num = static_cast<int>(letter); // if letter='a', num=97
Edit: Você provavelmente deve tentar evitar o uso(int)
int num = (int) letra;
confira Por que usar static_cast <int> (x) em vez de (int) x? para mais informações.
Depende do que você quer dizer com "converter".
Se você possui uma série de caracteres que representam um número inteiro, como "123456", existem duas maneiras comuns de fazer isso em C: Use uma conversão de finalidade especial como atoi () ou strtol () ou sscanf de uso geral () . O C ++ (que é realmente uma linguagem diferente que se disfarça de atualização) adiciona uma terceira sequência de strings.
Se você quer que o padrão de bits exato em uma de suas int
variáveis seja tratado como um char
, é mais fácil. Em C, os diferentes tipos de números inteiros são realmente mais um estado de espírito do que os "tipos" reais separados. Basta começar a usá-lo onde char
for solicitado e você deve estar bem. Você pode precisar de uma conversão explícita para fazer com que o compilador pare de choramingar de vez em quando, mas tudo o que você deve fazer é eliminar quaisquer bits extras além de 256.
Eu tenho absolutamente null
habilidades em C, mas para uma análise simples:
char* something = "123456";
int number = parseInt(something);
... isso funcionou para mim:
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;
}
Presumivelmente, você deseja essa conversão para usar funções da biblioteca padrão C.
Nesse caso, faça (sintaxe C ++)
typedef unsigned char UChar;
char myCppFunc( char c )
{
return char( someCFunc( UChar( c ) ) );
}
A expressão é UChar( c )
convertida unsigned char
em para se livrar de valores negativos, que, exceto o EOF, não são suportados pelas funções C.
Em seguida, o resultado dessa expressão é usado como argumento real para um int
argumento formal. Para onde você recebe a promoção automática int
. Como alternativa, você pode escrever explicitamente esse último passo int( UChar( c ) )
, mas pessoalmente acho isso muito detalhado.
Cheers & hth.,
Eu estava tendo problemas para converter uma matriz de caracteres "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e"
em seu valor inteiro real que poderia ser representado por `7C 'como um valor hexadecimal. Então, depois de procurar ajuda, criei isso e achei que seria legal compartilhar.
Isso separa a sequência de caracteres char em seus números inteiros certos e pode ser útil para mais pessoas do que apenas para mim;)
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;
}
Espero que ajude!
int charToint(char a){
char *p = &a;
int k = atoi(p);
return k;
}
Você pode usar esse método atoi para converter char para int. Para obter mais informações, você pode consultar este http://www.cplusplus.com/reference/cstdlib/atoi/ , http://www.cplusplus.com/reference/string/stoi/ .