Convertir int a string en estándar C

Soy nuevo en C.

Estoy buscando un ejemplo en el que pueda llamar a una función para convertir int en una cadena. Encontré itoa pero esto no es parte del estándar C.

También encontré sprintf(str, "%d", aInt); pero el problema es que no sé el tamaño de la str requerida. Por lo tanto, ¿cómo podría pasar el tamaño correcto para la cadena de salida?

Hay formas óptimas para dimensionar adecuadamente la matriz para tener en cuenta las variaciones en sizeof(int) , pero multiplicar por 4 es suficiente para la base 10. +1 es necesario para el caso de borde de sizeof(int)==1 .

 int x; // assign a value to x char buffer[sizeof(int) * 4 + 1]; sprintf(buffer, "%d", x); 

Si necesita devolver el puntero a la cadena desde la función, debe asignar el búfer en lugar de usar la memoria de stack:

 char* integer_to_string(int x) { char* buffer = malloc(sizeof(char) * sizeof(int) * 4 + 1); if (buffer) { sprintf(buffer, "%d", x); } return buffer; // caller is expected to invoke free() on this buffer to release memory } 

En C portátil, es más fácil usar snprintf para calcular el tamaño de la matriz requerida, y luego sprintf para la conversión real. Por ejemplo:

 char buffer[snprintf(NULL, 0, "%d", x) + 1]; sprintf(buffer, "%d", x); 

Vale la pena señalar que esto no funcionará antes de C99, y también hay una alternativa mejor que funciona antes de C99 y es de tipo genérico para todos los enteros . Eso se describe en otra respuesta a esta pregunta usando el truco de multiplicación , sin embargo, noté que el truco propuesto no es estrictamente portátil tampoco. En entornos donde CHAR_BIT no es 8 (por ejemplo, algunos DSP usan bytes de 16 o 32 bits), deberá cambiar el multiplicador.

Presenté un truco similar en respuesta a una pregunta diferente . Ese código utilizó CHAR_BIT para asegurar la portabilidad, incluso cuando CHAR_BIT cambia. Se presenta como una macro, y por eso se documenta internamente; te dice qué es la descripción de alto nivel, que una sola multiplicación no puede hacer.

 #include  #include  #include  #define digit_count(num) (1 /* sign */ \ + sizeof (num) * CHAR_BIT / 3 /* digits */ \ + (sizeof (num) * CHAR_BIT % 3 > 0)/* remaining digit */ \ + 1) /* NUL terminator */ int main(void) { short short_number = -32767; int int_number = 32767; char short_buffer[digit_count(short_number)] = { 0 }; char int_buffer[digit_count(int_number)]; sprintf(short_buffer, "%d", short_number); sprintf(int_buffer, "%d", int_number); } 

Utilice C99 snprintf() . Calcula cuánto espacio se necesitaría

 int needed = snprintf(NULL, 0, "%s", value); if (needed < 1) /* error */; char *representation = malloc(needed + 1); // add 1 for '\0' if (!representation) /* error */; sprintf(representation, "%d", value); // ... use representation ... free(representation); 

Hay una manera de hacerlo sin ninguna función, por ejemplo esto (puede ser un poco primitivo, pero aún así):

 char dec_rev[255]; dec_rev[0] = '\0'; int i = 0; while (val != 0) { int temp = val % 10; dec_rev[i] = temp + '0'; //printf("%c\n", dec_rev[i]); val /= 10; if (val == 0) { dec_rev[i + 1] = '\0'; break; } i++; } char dec[255]; i = 0; for (int j = strlen(dec_rev) - 1; j != -1; j--) { dec[i] = dec_rev[j]; i++; } 

Después de todo, tenemos nuestro int almacenado dentro de diciembre [255].

extraño que esto no se mencione, pero el tamaño de la representación de un int en base 10 es ceil (log10 (valor)); (o log10 versión entera si quieres escribirlo)

así ceil(log10(5)) => 1

y ceil(log10(555)) => 3

 ceil(log10(1000000000)) => 9 

Obviamente, necesita un espacio adicional para la señal si lo necesita y otro para el ‘\ 0’.