¿Hay alguna manera de crear una matriz con una longitud variable en c?

Question

¿Hay alguna forma (aparte de malloc) para crear una matriz con un tamaño que el usuario ingrese?

Answer 1

Una forma es usar un VLA (C99 define lo que se denomina 'Arrays de longitud variable').

Aquí se muestra un ejemplo:

#include <stdio.h> 

int use_a_vla (int n) 
{ 
    int vla[n]; /* Array length is derived from function argument. */ 

    vla[0] = 10; 
    vla[n-1] = 10; 

    return 0; 
} 

int main (void) 
{ 
    int i; 

    scanf ("%d", &i); /* User input. */ 

    use_a_vla (i); 
} 

Answer 2

Todo depende del compilador.

de longitud variable arrays automáticos están permitidos en ISO C99, y como una extensión GCC los acepta en el modo de C90 y en C++. Estas matrices se declaran como cualquier otra matriz automática, pero con una longitud que no es una expresión constante. El almacenamiento se asigna en el punto de la declaración y se desasigna cuando se cierra el nivel de llave. Por ejemplo :

FILE * 
concat_fopen (char *s1, char *s2, char *mode) 
{ 
    char str[strlen (s1) + strlen (s2) + 1]; 
    strcpy (str, s1); 
    strcat (str, s2); 
    return fopen (str, mode); 
} 

Ver this para más información.

Answer 3

Bueno, esto es pedante, pero puede escribir su propio código de gestión de montón y llamar a su función de asignación de memoria algo distinto de malloc(). Espero que esta respuesta sea divertida en lugar de molesta.

Answer 4

Si usted no tiene VLA o alloca(), aquí es una, técnica extremadamente kludgy, pero portátil basado en la pila:

int foo(int size) 
{ 
    if (size <= 64*1024) 
    { 
     unsigned char arr[64*1024]; 
     return bar(arr, size); 
    } 
    else if (size <= 1*1024*1024) 
    { 
     unsigned char arr[1*1024*1024]; 
     return bar(arr, size); 
    } 
    else if (size <= 64*1024*1024) 
    { 
     unsigned char arr[64*1024*1024]; 
     return bar(arr, size); 
    } 
    else 
     return -1;  // Assume it's too big 
} 

int bar(unsigned char arr[], int size) 
{ 
    ...your code goes here... 
} 

int maincode(int size) 
{ 
    // Invoke bar() indirectly, allocating an array 
    // on the stack of at least 'size' bytes 
    return foo(size); 
} 

Yo particularmente no recomiendo esta técnica, pero se le dará de manera diferente bloques de memoria de tamaño grande asignados en la pila en lugar del montón.

Answer 5

Supongo que está intentando evitar malloc porque no sabe acerca de realloc.

Básicamente, deberías tratar de hacer más o menos lo que hace el vector C++. Una vez que su matriz crece a un cierto tamaño, realloc al doble de su tamaño.

realloc hará crecer su bloque de memoria si es posible, y si no es posible malloc uno nuevo y copiará el contenido.