Dynamische Array-Erstellung in C mit Zeigern mit Antwort

Question

Hier ist der Beispielcode zum Erstellen dynamischer Array in C. Ich suchte nach einfachen dynamischen Array, konnte nicht die einfache zu finden. Implementiert meine eigene Version. Alle Vorschläge sind willkommen.

#include <stdio.h> 
#include <stdlib.h> 

const int MAX_LENGTH_INC=5; 

int main(void) 
{ 

    int *ptr,i; 
    int maximum_array_size = 1; 
    int index=0; 
    ptr = malloc(MAX_LENGTH_INC * sizeof(int)); 

    printf("Address of previously allocated memory: "); 
    for(i = 0; i < 8; i++) // incrementing upto maximum of size 8 
    { 
     //printf("\n Pointer is:%u\t",ptr + i); 
     //printf("\nindex is: %d",index); 
     ptr[index] = i*2; 
     //printf("\nValue :%d\t",ptr[index]); 

     index++; 
     if(index == maximum_array_size) 
     { 
      //printf("\n Array reached its limit"); 
      ptr= realloc(ptr,sizeof(int)*MAX_LENGTH_INC); 
      maximum_array_size = maximum_array_size + MAX_LENGTH_INC; 
     } 
    } 
    for(i=0;i<index;i++) 
     printf("\n Array Value is %d ",ptr[i]); 
    free(ptr); 

    return 0; 

}

Answer 1

Ok, Sie hier ein paar Probleme bekam, lassen Sie mich graben sie Schritt für Schritt.

Während es in C ein const-Schlüsselwort gibt, würde ich vorschlagen, es nicht zu verwenden, um solche Konstanten zu definieren. Verwenden Sie stattdessen nur ein #define etwa so:

#define MAX_LENGTH_INC 1 

jedoch const int MAX_LENGTH_INC = 1; nicht falsch ist, so können Sie es halten, wenn es Ihnen gefällt.

int main(void) 
{ 

Korrekt. Alternative: int main(int argc, char * argv[]) {. Auf diese Weise können Aufrufer Ihres Programms Befehlszeilenargumente übergeben. In seinem Programm, offensichtlich brauchen Sie es nicht, also void ist in Ordnung.

int *ptr,i; 
    int maximum_array_size = 1; 

Also, denken Sie daran: Dies ist Ihre aktuellen Größe des Arrays. Sie wollten eigentlich mit MAX_LENGTH_INC beginnen, glaube ich, so besser schreiben:

int maximum_array_size = MAX_LENGTH_INC; 

Auf diese Weise, wenn Sie MAX_LENGTH_INC erhöhen, können Sie auch die Größe der ersten Zuteilung erhöhen, nicht nur nachfolgenden.

Ein Kommentar bereits notiert: Nicht Rückgabewert von malloc. Außerdem: Sie sollten variable maximum_array_size hier verwenden, so:

ptr = malloc(maximum_array_size * sizeof(int)); 

mit sizeof(int) ist sehr verbreitet Stil in C , nur um es zu beachten hier: sizeof ist keine Funktion, sondern ein Operator. So wäre sizeof int auch gültig,./Edit: siehe

printf("Address of previously allocated memory: "); 
    for(i = 0; i < 8; ++i) 
    { 
     //printf("\n Pointer is:%u\t",ptr + i); 
     //printf("\nindex is: %d",index); 
     ptr[index] = i*2; 
     //printf("\nValue :%d\t",ptr[index]); 

     index++; 
     if(index == maximum_array_size) 
     { 
      //printf("\n Array reached its limit"); 

Kommentar Und hier kommt Ihre Logik Problem:

   ptr=(int *)realloc(ptr,sizeof(int)*MAX_LENGTH_INC); 
      maximum_array_size = maximum_array_size + MAX_LENGTH_INC; 

Sie immer realloc das Array MAX_LENGTH_INC Elemente zu halten. Du erinnerst dich daran, dass es gewachsen sein sollte, aber du entwickelst es nicht wirklich. Also, zuerst, tauschen Sie die zwei Zeilen und dann wie oben im malloc Aufruf, verwenden Sie die Variable in der realloc Aufruf.

   maximum_array_size = maximum_array_size + MAX_LENGTH_INC; 
      ptr = realloc(ptr, maximum_array_size * sizeof(int)); 

Der Zusatz maximum_array_size = maximum_array_size + MAX_LENGTH_INC; kann als maximum_array_size += MAX_LENGTH_INC; geschrieben werden. Dies hilft beim Lesen des Codes, denn jetzt ist es sofort klar, der Wert MAX_LENGTH_INC wird zu maximum_array_size hinzugefügt.

Und dann sollten Sie entscheiden, ob Sie sizeof(int) * num oder num * sizeof(int) schreiben möchten.Ich glaube, num * sizeof(int) ist logischer, weil Sie 20 Ints und nicht Int 20s haben;)

Nun der andere Vorschlag aus einem Kommentar war: Inkrement von 1 für jede Iteration wäre wirklich langsam für lange Schleifen. So verdoppeln besser die Puffergröße jeder Iteration:

   maximum_array_size *= 2; 
      ++maximum_array_size; // not exactly needed, I like it this way 

Nun, ihr ein wenig Puffer verschwenden kann, aber Sie werden in den meisten Abfall 50%. Natürlich sollten Sie eine neue Variable hinzufügen: num_array_elements, weil maximum_array_size die Anzahl der Elemente nicht mehr zählt.

 } 
    } 
    for(i=0;i<sizeof(ptr);i++) 
     printf("\n Array Value is %d ",ptr[i]); 

Wieder ein Kommentar schon gesagt, es: sizeof(ptr) hier definitiv falsch. Der Grund ist: ptr ist ein Zeiger. Und die Größe des Zeigers ist immer dieselbe (d. H. 8 Bytes), unabhängig von der Größe des Speicherblocks, auf den er zeigt. Sie möchten hier die neue Variable num_array_elements verwenden.

Dann, selbst für einen Liner Aussagen wie hier, sollten Sie geschweifte Klammern hinzufügen. Die Zeit kommt, Sie fügen eine weitere Zeile hinzu und vergessen Sie, die geschweiften Klammern hinzuzufügen, was wirklich sehr schwierig ist, Fehler zu finden. Also:

for (i = 0; i < num_array_elements; i++) { 
     printf("\n Array Value is %d ", ptr[i]); 
    } 

Auch, wie Sie sehen können, fügte ich einige Leerzeichen hinzu. Leerzeichen erleichtern das Lesen Ihres Codes. Kontrollflussschlüsselwörter wie for und if werden normalerweise mit einem folgenden Leerzeichen geschrieben, ohne dass Funktionen aufgerufen werden. Die Sprache ist nicht wichtig, aber es ist weit verbreitet Stil.

free(ptr); 

    return 0; 
} 

Rest scheint gut. Also, noch für Sie tun: Eigentlich hinzufügen und implementieren Sie die Variable num_array_elements und vielleicht umbenennen maximum_array_size entweder array_size oder maximum_array_elements. Auch das Schreiben von max anstelle von maximum ist weit verbreitet Stil, wie Schreiben num statt number.