Zuweisung mehrerer Arrays des gleichen Typs

Question

Ich muss mehrere Arrays des gleichen Typs und Form zuweisen. Am Anfang habe ich so etwas wie:

void alloc_arrays_v1(size_t nmemb) 
{ 
    int *a1, *a2, *a3; 

    a1 = malloc(nmemb * sizeof int); 
    a2 = malloc(nmemb * sizeof int); 
    a3 = malloc(nmemb * sizeof int); 

    /* do some stuff with the arrays */ 

    free(a1); 
    free(a2); 
    free(a3); 
} 

zu vermeiden Um malloc und free mehrmals aufrufen, änderte ich die oben in:

void alloc_arrays_v2(size_t nmemb) 
{ 
    int *a, *a1, *a2, *a3; 

    a = malloc(3 * nmemb * sizeof int); 
    a1 = a; 
    a2 = a1 + nmemb; 
    a3 = a2 + nmemb; 

    /* do some stuff */ 

    free(a); 
} 

Dies scheint in Ordnung zu sein (in dem Sinne, dass die Funktionen Verhalten Sie sich im realen Fall genauso), aber ich frage mich, ob das immer noch C-Code ist (undefiniertes Verhalten?), und ob ich diese Methode auf komplexe Datenarten (Arrays von Strukturen usw.) erweitern kann.

Answer 1

Es ist in C völlig gültig. Aber denken Sie daran, nur den Zeiger a freizugeben. Ihr diese Methode ist ähnlich struct

hacken aber ich denke, ein logisches Problem in diesem Code ist, dass, wenn Sie außerhalb der Grenzen gehen für a1 oder a2 Sie nicht in der Lage sein, es zu bemerken, wie Sie gültigen Zugriff auf den Speicher wird Adressen, dh Sie erhalten keine Seg Fault.
Im ersten Fall können Sie jedoch "SegFault" erhalten und Ihren Fehler bemerken.

Answer 2

Beide sind gültig, da Sie malloc verwenden, um zusammenhängenden Speicher zuzuweisen. In der Tat ähnlicher Code in der Form des zweiten Fall wird häufig verwendet, wenn Matrizen in C

Modellierung Es ist erwähnenswert, dass

int a1, a2, a3, a4; 
int* a = &a1; 
int oops = *(a + 1); 

ist undefiniertes Verhalten, da Sie nicht der Stapel Zuordnung zusammenhängend sein erwarten .

Answer 3

Es ist vollkommen gültig.

Was Sie tun, ist im Wesentlichen die gleiche wie folgt aus:

void alloc_arrays_v1(size_t nmemb) 
{ 
    typedef int one_array[nmemb]; // this is one array 
    typedef one_array three_arrays[3]; // this are three arrays 

    one_array * a; 
    int *a1, *a2, *a3; 
    a = malloc(sizeof(three_arrays)); 

    a1 = a[0]; // a[0] is a one_array, which decays into an int * here. 
    a2 = a[1]; // the same 
    a3 = a[2]; // as above 

    /* do some stuff with the arrays */ 

    free(a); 
} 

mit dem Unterschied, dass die Berechnungen hier durch Zeiger und Array-Arithmetik durchgeführt werden.