¿Es alloca completamente reemplazable?

Question

He leído bastantes lugares que alloca es obsoleto y no debe usarse y en su lugar se deben usar matrices de longitud variable.

Mi pregunta es esta: ¿Es alloca completamente reemplazable por matrices de longitud variable?

En mi caso particular tengo algo que se parece a esto:

typedef struct { 
    int *value; 
    size_t size; 
    } some_type; 

void SomeExternalFunction(some_type); 

... 

void foo(){ 
    //What I thought to do 
    some_type bar; 
    bar.value=alloca(sizeof(int)*10); 
    SomeExternalFunction(bar); 

    //what should be done without alloca 
    some_type fizz; 
    int tmp[10]; 
    fizz.value=tmp; 
    SoemExternalFunction(fizz); 
} 

Me estoy perdiendo algo o se trata de un buen uso real de alloca? Supongamos también para este ejemplo que por alguna razón deseo que el valor se asigne en la pila

Answer 1

Hay una diferencia importante entre los VLA y alloca: La memoria alloca() devuelve es válida mientras la función actual persista. La vida útil de la memoria ocupada por un VLA es válida siempre que el identificador del VLA permanezca en el alcance. Puede asignar memoria alloca() en un bucle, por ejemplo, y usar la memoria fuera del bucle, un VLA desaparecería porque el identificador queda fuera del alcance cuando termina el bucle. Esto significa, que usted puede hacer esto con alloca() y suficiente espacio de pila:

typedef struct node { int data; struct node *next; }; 
void fun() 
{ 
struct node *n=0; 
int d; 
/* Now we are building a single-linked list on the stack! */ 
while(d=get_something()) { 
    struct node *x=alloca(sizeof(*x)); 
    x->next=n; 
    x->data=d; 
    n=x; 
} 
do_something_with(n); 
} // and the whole thing is deleted here.. 

No se puede hacer esto con VLA.

Answer 2

alloca es completamente reemplazable por malloc y free. Es un poco más de trabajo, pero a menos que sea muy cuidadoso, es esencial. Casi todos los códigos que usan alloca o C99 vla son vulnerables a los ataques de desbordamiento de la pila, y en muchas implementaciones, pueden conducir a la elevación de privilegios. No existe una forma portátil de saber qué tan grande es la pila o cuánto espacio queda (o cuánto overhead más allá del tamaño requerido podría ser necesario para el uso interno del compilador o para llamadas a funciones adicionales), por lo que lo único razonable que puede hacer para make vla's/alloca safe es imponer límites artificiales extremadamente pequeños al tamaño de los datos que admite (por ejemplo, algunos kb). En este punto, también podría estar usando objetos automáticos simples de longitud no variable ...