Convertir un entero en una matriz

Estoy trabajando en un progtwig de C, y estoy encontrando un pequeño problema. No sé cómo convertir un entero (por ejemplo, 2007) en una matriz de caracteres. ¿Hay una función en las bibliotecas de C para hacer eso por mí?

Para aclarar, me gustaría tomar 2007 y almacenarlo en una matriz de caracteres [4] = {‘2’, ‘0’, ‘0’, ‘7’, ‘\ 0’};

Estaba pensando en algo así como sprintf, pero no estoy seguro. De todos modos, cualquier ayuda / consejos serían apreciados.

Gracias michael

Puedes hacer eso con sprintf , o con más seguridad snprintf .

Aquí hay un ejemplo artificial:

 #include  #define MAX_LEN 5 char str[MAX_LEN]; snprintf(str, MAX_LEN, "%d", 2007); 

Use snprintf() y asegúrese de asignar la cantidad adecuada de espacio para almacenar números de hasta 2 ^ (sizeof (int) * CHAR_BIT). En una máquina de 64 bits, serán 20 dígitos, más 1 para el terminador NULO.

 #include  #define MAX_DIGITS 20 int n = 2007; char str[MAX_DIGITS+1]; snprintf(str, MAX_DIGITS+1, "%d", n); 

Como han dicho otros, debes mirar a sprintf() o snprintf() . Suponiendo que está intentando convertir un tipo T integral en una matriz de este tipo, lo interesante es determinar el tamaño del búfer para la matriz.

Primero, el número de dígitos en la representación decimal de un número es ⌊log 10 n + 1⌋. El valor máximo posible de un tipo integral sin signo T se puede representar en nbits = CHAR_BIT*sizeof(T) bits binarios, que necesitarán ⌊log 10 2 nbits ⌋ + 1 dígitos decimales.

log 10 2 nbits = nbits × log 10 2 = nbits × log (2) / log (10).

28/93 es una muy buena aproximación racional de log(2)/log(10) (0.30107526881720431 vs 0.30102999566398114).

Entonces, usando lo anterior, obtenemos nuestra expresión para el número de dígitos:

 CHAR_BIT * sizeof(T) * 28 / 93 + 1 

Para los números firmados, necesitamos agregar 1 más para el signo - y necesitamos agregar 1 para el 0 termina. Así obtenemos:

 #include  /* Figure out the maximum number of characters including the terminating 0 to represent the numbers in integral type T */ #define SZ(T) (CHAR_BIT * sizeof(T) * 28 / 93 + 3) 

Así que podemos hacer:

 char array[SZ(int)]; sprintf(array, "%d", n); 

Y estamos seguros de que la array tiene suficiente espacio. Tampoco debemos preocuparnos por la combinación snprintf() o malloc() / realloc() y free() .

Aquí hay un progtwig completo usando lo anterior:

 #include  #include  /* Figure out the maximum number of characters including the terminating 0 to represent the numbers in integral type T */ #define SZ(T) (CHAR_BIT * sizeof(T) * 28 / 93 + 3) #define PRINT(x) do \ { \ printf("%s: %lu\n", #x, (unsigned long)SZ(x)); \ } while (0) int main(void) { PRINT(int); PRINT(long); PRINT(size_t); return 0; } 

1 o lo suficientemente bueno para este propósito.

 #include  char array[5]; sprintf(array, "%d", 2007); 

…hecho.

Tenga en cuenta que el sprintf no es seguro contra el desbordamiento, por lo que si tiene un número de 5 o más dígitos tendrá un problema. Tenga en cuenta también que el número convertido será seguido por una terminación \0 .

La forma clásica es itoa . O puede usar snprintf para obtener más control.

Hay una función no estándar, pero bien soportada, como la entiendo, itoa , lo opuesto a atoi .

Ejemplo:

 char *a = malloc(10 * sizeof(char)); itoa(2007, a, 2007); 

sprintf también funciona:

 char *a = malloc(10 * sizeof(char)); sprintf(a, "%d", 2007); 
 int n = 2007; char a[100]; sprintf( a, "%d", n ); 

Utilice snprintf :

 // value is int; // buf is char *; // length is space available in buf snprintf(buf, length, "%d", value) 

snprintf tiene la ventaja de ser estándar y ofrecerle más flexibilidad en cuanto al formateo y seguridad.

También puede usar itoa pero tenga en cuenta que no es parte de la norma. Aunque la mayoría de las implementaciones lo tienen.

Uso:

 // value is int; // buf is char *; itoa(value, buf, 10); 

Una pregunta interesante es: ¿cuánto espacio asigna para buf ? Tomamos nota de lo siguiente. Con sizeof(int) bytes por int y ocho bits por byte, el valor máximo es aproximadamente 2^(CHAR_BIT * sizeof(int) - 1) ( -1 es para el bit de signo). Por lo tanto necesitamos espacio para sostener

 floor(log_10(2^(CHAR_BIT * sizeof(int) - 1)) + 1 

dígitos Pero no olvides el signo y el terminador nulo! Así que la longitud máxima de un entero representable aquí es

 floor(log_10(2^(CHAR_BIT * sizeof(int) - 1)) + 3. 

Por supuesto, esto podría estar desperdiciando espacio si nuestros valores son pequeños. Para saber cuánto espacio necesita un valor específico:

 floor(log_10(abs(value))) + 1 + (value < 0 ? 1 : 0) + 1