Wie werden alle Mitglieder eines Arrays auf denselben Wert initialisiert?

Question 1

Ich habe ein großes Array drin C (nicht C++ falls das einen Unterschied macht). Ich möchte alle Mitglieder mit demselben Wert initialisieren.

Ich könnte schwören, dass ich einmal einen einfachen Weg kannte, dies zu tun. ich könnte benutzen memset() in meinem Fall, aber gibt es dafür keine Möglichkeit, die direkt in die C-Syntax integriert ist?

Question 2

Wenn dieser Wert nicht 0 ist (in diesem Fall können Sie einen Teil des Initialisierers weglassen und die entsprechenden Elemente werden auf 0 initialisiert), gibt es keinen einfachen Weg.

Übersehen Sie jedoch nicht die offensichtliche Lösung:

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };

Elemente mit fehlenden Werten werden auf 0 initialisiert:

int myArray[10] = { 1, 2 }; // initialize to 1,2,0,0,0...

Dadurch werden also alle Elemente auf 0 initialisiert:

int myArray[10] = { 0 }; // all elements 0

In C++ initialisiert eine leere Initialisierungsliste auch jedes Element auf 0. Dies ist bei C bis C23 nicht erlaubt:

int myArray[10] = {}; // all elements 0 in C++ and C23

Denken Sie daran, dass Objekte mit statischer Speicherdauer auf 0 initialisiert werden, wenn kein Initialisierer angegeben ist:

static int myArray[10]; // all elements 0

Und dass “0” nicht unbedingt “alle Bits-Null” bedeutet, also ist die Verwendung des oben Genannten besser und portabler als memset(). (Gleitkommawerte werden auf +0 initialisiert, Zeiger auf Nullwerte usw.)

Question 3

Wenn Ihr Compiler GCC ist, können Sie die folgende “GNU-Erweiterungssyntax” verwenden:

int array[1024] = {[0 ... 1023] = 5};

Sehen Sie sich die detaillierte Beschreibung an:
http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Designated-Inits.html

Question 4

Um ein großes Array mit demselben Wert ohne mehrfaches Kopieren und Einfügen statisch zu initialisieren, können Sie Makros verwenden:

#define VAL_1X     42
#define VAL_2X     VAL_1X,  VAL_1X
#define VAL_4X     VAL_2X,  VAL_2X
#define VAL_8X     VAL_4X,  VAL_4X
#define VAL_16X    VAL_8X,  VAL_8X
#define VAL_32X    VAL_16X, VAL_16X
#define VAL_64X    VAL_32X, VAL_32X

int myArray[53] = { VAL_32X, VAL_16X, VAL_4X, VAL_1X };

Wenn Sie den Wert ändern müssen, müssen Sie die Ersetzung nur an einer Stelle vornehmen.

Bearbeiten: mögliche nützliche Erweiterungen

(mit freundlicher Genehmigung von Jonathan Leffler)

Sie können dies leicht verallgemeinern mit:

#define VAL_1(X) X
#define VAL_2(X) VAL_1(X), VAL_1(X)
/* etc. */

Eine Variante kann erstellt werden mit:

#define STRUCTVAL_1(...) { __VA_ARGS__ }
#define STRUCTVAL_2(...) STRUCTVAL_1(__VA_ARGS__), STRUCTVAL_1(__VA_ARGS__)
/*etc */

das funktioniert mit Strukturen oder zusammengesetzten Arrays.

#define STRUCTVAL_48(...) STRUCTVAL_32(__VA_ARGS__), STRUCTVAL_16(__VA_ARGS__)

struct Pair { char key[16]; char val[32]; };
struct Pair p_data[] = { STRUCTVAL_48("Key", "Value") };
int a_data[][4] = { STRUCTVAL_48(12, 19, 23, 37) };

Makronamen sind verhandelbar.

Question 5

Wenn Sie sicherstellen möchten, dass jedes Mitglied des Arrays explizit initialisiert wird, lassen Sie einfach die Dimension aus der Deklaration weg:

int myArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

Der Compiler leitet die Dimension aus der Initialisiererliste ab. Leider darf bei mehrdimensionalen Arrays nur die äußerste Dimension weggelassen werden:

int myPoints[][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

ist ok, aber

int myPoints[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

ist nicht.

Question 6

Ich habe einen Code gesehen, der diese Syntax verwendet:

char* array[] = 
{
    [0] = "Hello",
    [1] = "World"
};

Besonders nützlich wird es, wenn Sie ein Array erstellen, das Enums als Index verwendet:

enum
{
    ERR_OK,
    ERR_FAIL,
    ERR_MEMORY
};

#define _ITEM(x) [x] = #x

char* array[] = 
{
    _ITEM(ERR_OK),
    _ITEM(ERR_FAIL),
    _ITEM(ERR_MEMORY)
};

Dies hält die Dinge in Ordnung, selbst wenn Sie zufällig einige der Enum-Werte in der falschen Reihenfolge schreiben.

Mehr zu dieser Technik finden Sie hier hier und hier.

Question 7

int i;
for (i = 0; i < ARRAY_SIZE; ++i)
{
  myArray[i] = VALUE;
}

Ich denke, das ist besser als

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5...

falls sich die Größe des Arrays ändert.

Question 8

Sie können das ganze statische Initialisierungs-Ding wie oben beschrieben ausführen, aber es kann ein echter Mist sein, wenn sich Ihre Array-Größe ändert (wenn Ihr Array embiggens wird, erhalten Sie Müll, wenn Sie nicht die entsprechenden zusätzlichen Initialisierer hinzufügen).

memset gibt Ihnen einen Laufzeittreffer für die Arbeit, aber kein richtiger Codegrößentreffer ist immun gegen Änderungen der Arraygröße. Ich würde diese Lösung in fast allen Fällen verwenden, wenn das Array größer als beispielsweise ein paar Dutzend Elemente ist.

Wenn es wirklich wichtig wäre, dass das Array statisch deklariert wird, würde ich ein Programm schreiben, um das Programm für mich zu schreiben und es zu einem Teil des Build-Prozesses zu machen.