Malloc oder normale array-definition?

Wann werde ich dann benutzen Sie malloc-anstelle der normalen array-definition in C?

Kann ich nicht verstehen den Unterschied zwischen:

int a[3]={1,2,3}
int array[sizeof(a)/sizeof(int)]

und:

array=(int *)malloc(sizeof(int)*sizeof(a));
InformationsquelleAutor Antonio Ciccia | 2012-06-28
  1. 16

    Verwenden Sie im Allgemeinen malloc() wenn:

    • das array ist zu groß, um auf dem Stapel abgelegt
    • die Lebensdauer des Arrays müssen über den Umfang, wo es erstellt wird

    Verwenden Sie andernfalls einen stack reservierten Arrays.

    InformationsquelleAutor hmjd
  2. 5
    int a[3]={1,2,3}
int array[sizeof(a)/sizeof(int)]

    Wenn als lokale Variablen, die beide a und array wäre auf dem Stapel reserviert. Stack Allokation hat seine vor-und Nachteile:

    • pro: es ist sehr schnell - es dauert nur ein register Subtraktion zu schaffen stack-Speicher und einem register neben der Bedienung zu reklamieren, es wieder
    • con: stack-Größe ist in der Regel begrenzt (und auch festen Zeitpunkt link auf Windows)

    In beiden Fällen ist die Anzahl der Elemente in den beiden arrays ist eine compile-Zeit-Konstante: 3 ist offensichtlich eine Konstante, während sizeof(a)/sizeof(int) berechnet werden kann zur compile-Zeit, da sowohl die Größe der a und die Größe der int sind zu der Zeit bekannt, wenn array deklariert ist.

    Wenn die Anzahl der Elemente bekannt ist, nur bei der Laufzeit oder, wenn die array-Größe ist zu groß, um sicher zu passen in Platz auf dem stack, dann heap-Zuweisung verwendet wird:

    array=(int *)malloc(sizeof(int)*sizeof(a));

    Wie bereits erwähnt, sollte dies malloc(sizeof(a)) da die Größe der a ist bereits die Anzahl der bytes, die es braucht, und nicht die Anzahl der Elemente und damit zusätzliche Multiplikation mit sizeof(int) ist nicht notwendig.

    Heap allocaiton und-Freigabe ist eine relativ teure operation ist (im Vergleich zu stack-Allokation), und diese sollten sorgfältig gewichteten gegen die Vorteile, die es bietet, z.B. in code, der aufgerufen wird, Vielzahl von Zeiten in engen loops.

    Moderne C-Compiler unterstützen den C99-version der C-standard stellt die so genannte variable-length arrays (oder VLAs), die ähneln, ähnliche Funktionen in anderen Sprachen verfügbar. VLA ist eine Größe angegeben ist, zur Laufzeit, wie in diesem Fall:

    void func(int n)
{
   int array[n];
   ...
}

    array ist immer noch auf dem Stapel reserviert als wenn der Speicher für das array reserviert wurde durch einen Aufruf von alloca(3).

    • Ich denke, das ist die beste Antwort hier, weil es geht in solchen Details. Ich war erstaunt über die performance-Unterschiede.
    InformationsquelleAutor Hristo Iliev
  3. 2

    Du auf jeden Fall noch verwenden malloc() wenn Sie nicht möchten, dass Ihre Arrays eine Feste Größe haben. Je nachdem, was Sie versuchen zu tun, könnte man nicht im Voraus wissen, wie viel Speicherplatz Sie gehen zu müssen, für eine bestimmte Aufgabe oder müssen Sie möglicherweise dynamisch ändern Sie die Größe des array zur Laufzeit, zum Beispiel könnten Sie es zu vergrößern, wenn mehr Daten ankommen. Letzteres kann mit realloc() ohne Datenverlust.

    Anstatt "initialisieren" ein array wie in deinem ursprünglichen post sollten Sie nur initialisieren Sie einen Zeiger auf integer wie.

    int* array; //this variable will just contain the addresse of an integer sized block in memory
int length = 5; //how long do you want your array to be;

array = malloc(sizeof(int) * length); //this allocates the memory needed for your array and sets the pointer created above to first block of that region;

int newLength = 10;
array = realloc(array, sizeof(int) * newLength); //increase the size of the array while leaving its contents intact;
    InformationsquelleAutor inVader
  4. 1

    Dein code ist sehr seltsam.

    Die Antwort auf die Frage im Titel ist wahrscheinlich so etwas wie "verwenden Sie die automatisch zugeordneten arrays, wenn Sie Sie brauchen sehr kleine Mengen von Daten, die kurzlebig sind, heap-Zuweisungen mit malloc() für etwas anderes". Aber es ist schwer zu festzunageln eine genaue Antwort, es hängt viel von der situation.

    Nicht sicher, warum Sie sind, zeigen erste ein array, dann ein weiteres array, das versucht, zu berechnen, deren Länge von der ersten, und schließlich ein malloc() nennen, die versucht, das gleiche.

    Normalerweise haben Sie eine Vorstellung von der Anzahl der gewünschten Elemente, sondern als ein vorhandenes array, dessen Größe, die Sie wollen, zu imitieren.

    In der zweiten Zeile ist besser als:

    int array[sizeof a / sizeof *a];

    Keine Notwendigkeit zu wiederholen, die eine Abhängigkeit der Art der a, die oben definieren array als ein array von int mit der gleichen Anzahl von Elementen als array a. Beachten Sie, dass dies nur funktioniert, wenn a ist ja ein array.

    Auch, die Dritte Zeile sollte wohl sein:

    array = malloc(sizeof a);

    Keine Notwendigkeit, zu klug (vor allem, da du hast es falsch) über die sizeof argument, und keine Notwendigkeit zu werfen malloc()'s return Wert.

    • Ich schrieb nur ein Beispiel, dieser code ist nur für diesen Zweck. vielen Dank für Ihre Hilfe!
    InformationsquelleAutor unwind
Schreibe einen Kommentar