Was ist der richtige Weg, um eine sehr große Struktur zu initialisieren?

In unserem Code hatten wir früher so etwas:

   *(controller->bigstruct) = ( struct bigstruct ){ 0 };

Früher hat dies hervorragend funktioniert, und dann haben wir Versionen von GCC aktualisiert und plötzlich angefangen, Stapelüberläufe zu sehen. Wenn man sich die Assembly ansieht, hat der alte GCC-Code (2.x) im Grunde Folgendes getan:

memset(controller->bigstruct, 0, sizeof(struct bigstruct));

Das neue GCC (3.4.x) tat dies

   struct bigstruct temp = { 0 };
   controller->bigstruct = temp;

Nachdem ich die C99-Spezifikation überprüft hatte, konnte ich sehen, warum; C99 erfordert grundsätzlich, dass anonyme Strukturen auf dem Stack vorhanden sind. Es ist ein gutes Konzept, aber diese Struktur war 4 Megabyte groß und sollte immer nur auf dem Haufen existieren!

Wir haben darauf zurückgegriffen, unsere eigene „Initialize“-Funktion zu erstellen, die die Mitglieder explizit festlegt, aber das ist hässlich und verursacht Kopfschmerzen bei der Wartung. Ich halte memset nicht für eine geeignete Lösung, da ich nicht wissen kann, dass ein Bitwert von 0 ein geeigneter Nullwert für den Typ ist (Spitzensucht, ich weiß, aber da sind Sie; das macht mir nichts aus der Compiler macht es, weil es kann kennt )

Was ist der “richtige” oder zumindest beste Weg, um eine große Struktur wie diese zu initialisieren?

Um weiter zu verdeutlichen, warum memset meiner Meinung nach keine Lösung ist: Die Initialisierungsregeln für nicht explizit initialisierte Member sind die gleichen wie bei der statischen Initialisierung und lauten wie folgt: – Wenn es einen Zeigertyp hat, wird es mit einem Nullzeiger initialisiert; – Wenn es vom arithmetischen Typ ist, wird es auf (positiv oder vorzeichenlos) Null initialisiert; …

‘memset’ setzt den Speicher auf das Bitmuster Null, was nicht unbedingt dasselbe ist. Stellen Sie sich ein System vor, das keine IEEE-Gleitkommazahlen verwendet. Ungewöhnlich, aber von C unterstützt. Die Darstellung von 0.0 muss nicht “alle Bits Null” bedeuten, es könnte alles sein, was für den Prozessor bequem ist.

memset ist der richtige Weg. Sie haben nicht viele Alternativen.

Mach so etwas wie:

#define InitStruct(var, type) type var; memset(&var, 0, sizeof(type))

Damit Sie nur noch:

InitStruct(st, BigStruct);

Und dann st wie gewohnt verwenden …

Ich verstehe nicht, dass “0” kein gültiger “0”-Typ für eine Struktur ist. Die einzige Möglichkeit, eine Struktur “massenweise zu initialisieren”, besteht darin, ihren gesamten Speicher auf einen Wert zu setzen; Andernfalls müssten Sie zusätzliche Logik erstellen, um ihm mitzuteilen, dass er ein bestimmtes Bitmuster pro Mitglied verwenden soll. Das beste “generische” Bitmuster ist 0.

Außerdem – das ist die gleiche Logik, die Sie dabei verwendet haben

*(controller->bigstruct) = *( struct bigstruct ){ 0 };

Daher verstehe ich deine Zurückhaltung nicht, es zu benutzen 🙂

Der erste Kommentar zu diesem Beitrag veranlasste mich, einige Nachforschungen anzustellen, bevor ich ihn und Idioten anrief, und ich fand Folgendes:

http://www.lysator.liu.se/c/c-faq/c-1.html

Sehr interessant; Wenn ich einen Kommentar abstimmen könnte, würde ich es tun 🙂

Abgesehen davon – Ihre einzige Option, wenn Sie auf archaische Architekturen mit Nicht-0-Nullwerten abzielen möchten, besteht immer noch darin, bestimmte Mitglieder manuell zu initialisieren.

Danke Thomas Padron-McCarthy! Ich habe heute etwas Neues gelernt 🙂

Wenn Sie memset nicht verwenden möchten, können Sie jederzeit eine statische Kopie Ihrer Struktur deklarieren und memcpy verwenden, was eine ähnliche Leistung bietet. Dies fügt Ihrem Programm 4 MB hinzu, ist aber wahrscheinlich besser als das Setzen einzelner Elemente.

Das heißt, wenn GCC Memset verwendet hat und es vorher gut genug war, würde ich vorschlagen, dass es jetzt gut genug ist.

Wie andere gesagt haben, ist Memset der richtige Weg. Jedoch, nicht Verwenden Sie memset für C++-Objekte, insbesondere solche mit virtuellen Methoden. Das sizeof( foo ) enthält die Tabelle der virtuellen Funktionszeiger, und ein Memset darauf zu erstellen, wird ernsthaften Kummer verursachen.

Wenn memset das Problem nicht von selbst löst, machen Sie einfach ein memset und dann Initialisieren Sie alle Mitglieder, die nicht Null sein sollten (dh Ihre Nicht-IEEE-Gleitkommawerte).

Die private Initialisierungsfunktion ist nicht hässlich, sondern eine gute OO-Methode zum Initialisieren von Objekten (Strukturen). Ich gehe davon aus, dass Ihre Struktur nicht aus 4 MB Zeigern besteht, also würde ich davon ausgehen, dass die Lösung so aussehen sollte:

void init_big_struct(struct bigstruct *s)  
{  
    memset(s, 0, sizeof(struct bigstruct));  
    s->some_pointer = NULL; // Multiply this as needed  
}

Andererseits läuft unser Code auf mehr als 20 eingebetteten Betriebssystemen und einer großen Anzahl unterschiedlicher Hardware. Niemals ein Problem mit nur dem Memset der Struktur.

Viele sprechen über Memset, ohne darüber zu sprechen calloc. Ich würde lieber calloc verwenden, das für diesen Anwendungsfall entwickelt wurde (bitte kommentieren, wenn ich falsch liege):

Die Funktion calloc() weist Speicher für ein Array von nmemb-Elementen mit der Größe von Bytes zu und gibt einen Zeiger auf den zugeordneten Speicher zurück. Der Speicher wird auf Null gesetzt. Wenn nmemb oder size 0 ist, gibt calloc() entweder NULL oder einen eindeutigen Zeigerwert zurück, der später erfolgreich an free() übergeben werden kann.

Beispiel:

#include <stdlib.h> // calloc header
#include <stdio.h> // printf header

void    *init_heap_array(int elem_nb, int elem_size) {
    void *ptr;

    if (!(ptr = calloc(elem_nb, elem_size)))
        return NULL;

    return ptr;
}

void    set_int_value_at_index(int *ptr, int value, int i) {
    ptr[i] = value;
}

void    print_int_array_until(int *ptr, const int until) {
    for (int i = 0; i < until; i++)
        printf("%02d ", ptr[i]);
    putchar('\n');
}

int     main(void) {
    const int array_len = 300000;
    int *n;

    if (!(n = init_heap_array(array_len, sizeof(int))))
        return 1;    

    print_int_array_until(n, 5);
    set_int_value_at_index(n, 42, 1);
    print_int_array_until(n, 5);

    return 0;
}

hmm – zuerst einmal eine Init-Funktion zu erstellen und jedes Mitglied explizit zu setzen, IST DAS RICHTIGE – so arbeiten Konstruktoren in OO-Sprachen.

und zweitens – kennt jemand eine Hardware, die Nicht-IEEE-Gleitkommazahlen implementiert? – vielleicht Commodore 64 oder so 😉