convertir convert array c++ c gcc

c++ - convert - itoa



Convertir char a int en C y C++ (11)

¿Cómo convierto un char a un int en C y C ++?

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

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

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

Pero, cuando somevalue está fuera de ese rango, solo pasar por un unsigned char le da resultados consistentes para los "mismos" valores de char 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 usan funciones de ctype.h , como isupper o toupper , debido a la extensión de 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 la misma UB:

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

Para solucionar este problema, ejecute el safe_ctype unsigned char , que se realiza fácilmente envolviendo las funciones safe_ctype mediante 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. Conduce 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 char negativo o un signed char negativo, y chr toma cualquier valor que ord produce y devuelve exactamente el mismo char .

En la práctica, es probable que simplemente lance a través de caracteres unsigned char lugar de usarlos, pero ellos envuelven sucintamente el modelo, proporcionan un lugar conveniente para agregar la comprobación de errores para int to- char , y serían más cortos y más claros cuando sea necesario. Úsalos varias veces en las proximidades.

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 a int . Además, los caracteres literales son de tipo int en C y char en C ++.

Puede convertir un tipo de char simplemente asignando a un int .

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

Depende de lo que quieras decir con "convertir".

Si tiene una serie de caracteres que representan un número entero, como "123456", entonces hay dos formas típicas de hacerlo en C: Use una conversión de propósito especial como atoi() o strtol() , o el sscanf() propósito general sscanf() . C ++ (que en realidad es un lenguaje diferente que se hace pasar por una actualización) agrega una tercera secuencia de cadenas.

Si quiere decir que quiere que el patrón de bits exacto en una de sus variables int sea ​​tratado como un char , eso es más fácil. En C, los diferentes tipos de enteros son realmente más un estado de ánimo que los "tipos" separados reales. Simplemente comience a usarlo donde se solicitan los caracteres, y debería estar bien. Es posible que necesite una conversión explícita para hacer que el compilador deje de gimotear ocasionalmente, pero todo lo que debería hacer es dejar caer cualquier bit adicional más allá de 256.

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'' -> 1 , etc., puede escribir

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

Es de suponer que desea esta conversión para utilizar funciones de la biblioteca estándar de C.

En ese caso, hacer (sintaxis C ++)

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

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

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

Salud y salud,

Estaba teniendo problemas para convertir una matriz de caracteres como "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e" Así que, después de buscar ayuda, creé esto y pensé que sería bueno 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;

Igual a int64.

long long lo = ch;

Todos los valores serán 16.

Tengo habilidades absolutamente null 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 + pow(n, x); } return sum; } int powInt(int x, int y) { for (int i = 0; i < y; i++) { x *= 10; } return x; }

char es sólo un entero de 1 byte. ¡No hay nada mágico con el tipo char! Del mismo modo que puede asignar un corto a un int, o un int a un largo, puede 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 para confundir a todos los que intentan aprender el idioma. Un nombre mejor para eso 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 cuando se maneja cadenas, porque el índice de la tabla ASCII clásica encaja en 1 byte. Sin embargo, también puede manejar cuerdas con entradas regulares, aunque no hay ninguna razón práctica en el mundo real por la que quiera 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]); }

Debe darse 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.

Así que si escribes una expresión como

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

esto es en realidad equivalente a

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

que luego pasa por las promociones enteras del lenguaje C

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

y luego truncado a un char para ajustar el tipo de resultado

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

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