Convierte char a int en C y C ++

¿Cómo convierto una chara una inten C y C ++?

Depende de lo que quieras hacer:

Para leer el valor como un código ASCII, puede escribir

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

para convertir el carácter '0' -> 0, '1' -> 1etc, se puede escribir

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

Explicación :
a - '0'es equivalente a ((int)a) - ((int)'0'), lo que significa que los valores ascii de los caracteres se restan entre sí. Como 0viene directamente antes 1en la tabla ascii (y así sucesivamente hasta 9), la diferencia entre los dos da el número que arepresenta el personaje .

Bueno, en el código ASCII, los números (dígitos) comienzan desde 48 . Todo lo que necesitas hacer es:

int x = (int)character - 48;

C y C ++ siempre promueven tipos al menos int. Además, los literales de caracteres son de tipo intC ychar en C ++.

Puede convertir un chartipo simplemente asignándolo a un int.

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

char es solo un entero de 1 byte. ¡No hay nada mágico con el tipo char! Así como puedes asignar un short a un int, o un int a un long, puedes asignar un char a un int.

Sí, el nombre del tipo de datos primitivo es "char", lo que insinúa que solo debe contener caracteres. Pero en realidad, "char" es solo una mala elección de nombre para confundir a todos los que intentan aprender el idioma. Un mejor nombre para él es int8_t, y puede usar ese nombre en su lugar, si su compilador sigue el último estándar de C.

Aunque, por supuesto, debe usar el tipo char al hacer el manejo de cadenas, porque el índice de la tabla ASCII clásica cabe en 1 byte. Usted podría sin embargo hacer manejo de cadenas de enteros normales, así, aunque no hay ninguna razón práctica en el mundo real por la que va a querer hacer eso. Por ejemplo, el siguiente código funcionará perfectamente:

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

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

Debes darte cuenta de que los caracteres y las cadenas son solo números, como todo lo demás en la computadora. Cuando escribe 'a' en el código fuente, se procesa previamente en el número 97, que es una constante entera.

Entonces, si escribes una expresión como

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

esto es realmente equivalente a

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

que luego pasa por las promociones de enteros en lenguaje C

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

y luego truncado a un carácter para ajustarse al tipo de resultado

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

Hay muchas cosas sutiles como esta sucediendo entre líneas, donde char se trata implícitamente como un int.

(Esta respuesta aborda el lado C ++ de las cosas, pero el problema de la extensión del signo también existe en C).

El manejo de los tres chartipos ( signed, unsignedy char) es más delicado de lo que parece. Los valores en el rango de 0 a SCHAR_MAX(que es 127 para un 8 bits char) son fáciles:

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

Pero, cuando somevalueestá fuera de ese rango, solo pasar unsigned charle da resultados consistentes para los "mismos" charvalores en los tres 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.

Esto es importante cuando se utilizan funciones de ctype.h , como isuppero toupper, debido a la extensión del signo:

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

Tenga en cuenta que la conversión a través de int es implícita; esto tiene el mismo UB:

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

Para solucionar esto, vaya unsigned char, lo que se hace fácilmente envolviendo las funciones ctype.h a través de 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.

Esto funciona porque cualquier función que tome cualquiera de los tres tipos de caracteres también puede tomar los otros dos tipos de caracteres. Lleva a dos funciones que pueden manejar cualquiera de los 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)siempre le da un valor no negativo, incluso cuando se pasa un valor negativo charo negativo signed char, y chrtoma cualquier valor que ordproduce y devuelve exactamente el mismochar .

En la práctica, probablemente solo transmitiría en unsigned charlugar de usar estos, pero lo hacen de forma sucinta, proporcionan un lugar conveniente para agregar la comprobación de errores para int-to- char, y sería más corto y más claro cuando necesite usarlos varias veces en estrecha proximidad.

Uso static_cast<int>:

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

Editar: Probablemente debería intentar evitar usar(int)

int num = (int) letra;

echa un vistazo a qué uso static_cast <int> (x) en lugar de (int) x? para más información.

Depende de lo que quieras decir con "convertir".

Si tiene una serie de caracteres que representa un número entero, como "123456", hay dos formas típicas de hacerlo en C: utilice una conversión de propósito especial como atoi () o strtol () , o el sscanf de propósito general () . C ++ (que es realmente un lenguaje diferente disfrazado de una actualización) agrega un tercer flujo de cadena.

Si quiere decir que desea que el patrón de bits exacto en una de sus intvariables sea tratado como unchar , eso es más fácil. En C, los diferentes tipos enteros son realmente más un estado mental que los "tipos" separados reales. Simplemente comience a usarlo donde charse le solicite, y debería estar bien. Es posible que necesite una conversión explícita para que el compilador deje de quejarse en ocasiones, pero todo lo que debería hacer es soltar cualquier bit adicional más allá de 256.

Tengo absolutamente nullhabilidades en C, pero para un análisis simple:

char* something = "123456";

int number = parseInt(something);

... esto funcionó para mí:

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;
}

Presumiblemente, desea esta conversión para usar funciones de la biblioteca estándar de C.

En ese caso, hacer (sintaxis de C ++)

typedef unsigned char UChar;

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

La expresión se UChar( c )convierte unsigned charen para deshacerse de los valores negativos, que, a excepción de EOF, no son compatibles con las funciones de C.

Luego, el resultado de esa expresión se usa como argumento real para un intargumento formal. Donde obtienes la promoción automática int. Alternativamente, puede escribir ese último paso explícitamente, comoint( UChar( c ) ) , pero personalmente me parece demasiado detallado.

Saludos y hth.

Estaba teniendo problemas para convertir una matriz de caracteres como "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e"en su valor entero real que podría ser representado por '7C' como un valor hexadecimal. Entonces, después de buscar ayuda, creé esto, y pensé que sería genial compartirlo.

Esto separa la cadena de caracteres en sus enteros correctos, y puede ser útil para más personas que solo yo;)

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 eso ayude!

Para char o short to int, solo necesita asignar el valor.

char ch = 16;
int in = ch;

Lo mismo para int64.

long long lo = ch;

Todos los valores serán 16.

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

Puede usar este método atoi para convertir char a int. Para obtener más información, puede consultar este http://www.cplusplus.com/reference/cstdlib/atoi/ , http://www.cplusplus.com/reference/string/stoi/ .