Converter char para int em C e C ++

Como converter um charpara um intem C e C ++?

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 0vem diretamente antes 1na tabela ascii (e assim por diante até 9), a diferença entre os dois fornece o número que o caractere arepresenta.

Bem, no código ASCII, os números (dígitos) começam em 48 . Tudo que você precisa fazer é:

int x = (int)character - 48;

C e C ++ sempre promovem tipos para pelo menos int. Além disso, literais de caracteres são do tipo intem C e charem C ++.

Você pode converter um chartipo simplesmente atribuindo a um int.

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

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.

(Esta resposta aborda o lado C ++, mas o problema de extensão de sinal também existe em C).

O manuseio dos três chartipos ( signed, unsignede 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 somevalueestá fora desse intervalo, apenas a unsigned charexecução fornece resultados consistentes para os "mesmos" charvalores 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 isupperou 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 charou negativo signed char- e chraceita qualquer valor que ordproduz e devolve exatamente o mesmo char.

Na prática, eu provavelmente apenas transmiti-lo em unsigned charvez de usá-los, mas eles encapsulam sucintamente o elenco, fornecem um local conveniente para adicionar verificação de erros para - e - e intfica charmais 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 intvariá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 charfor 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 nullhabilidades 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 charem 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 intargumento 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!

Para char ou short para int, você só precisa atribuir o valor.

char ch = 16;
int in = ch;

O mesmo que o int64.

long long lo = ch;

Todos os valores serão 16.

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/ .