Wie initialisiert man alle Mitglieder eines Arrays auf denselben Wert?

Question

Ich habe ein großes Array in 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 eine einfache Möglichkeit kannte, dies zu tun. Ich könnte verwenden memset() in meinem Fall, aber gibt es nicht eine Möglichkeit, dies zu tun, die direkt in die C-Syntax eingebaut ist?

Answer 1

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

Übersehen Sie aber nicht die offensichtliche Lösung:

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

Elemente mit fehlenden Werten werden mit 0 initialisiert:

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

Dadurch werden alle Elemente auf 0 initialisiert:

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

In C++ wird auch bei einer leeren Initialisierungsliste jedes Element mit 0 initialisiert. Dies ist nicht erlaubt mit C:

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

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

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

Und dass "0" nicht unbedingt "alle Bits-Null" bedeutet, so dass die obige Methode besser und portabler als memset(). (Fließkommawerte werden auf +0 initialisiert, Zeiger auf Null, usw.)

Answer 2

Wenn Ihr Compiler GCC ist, können Sie folgende "GNU-Erweiterungs"-Syntax verwenden:

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

Lesen Sie die ausführliche Beschreibung: http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Designated-Inits.html

Answer 3

Um ein großes Array statisch mit demselben Wert zu initialisieren, ohne mehrfaches Kopieren und Einfügen, 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 wollen, müssen Sie die Ersetzung nur an einer Stelle vornehmen.

Edit: mögliche nützliche Erweiterungen

(mit freundlicher Genehmigung von Jonathan Leffler )

Sie können dies leicht verallgemeinern:

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

Eine Variante kann mit erstellt werden:

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

die mit Strukturen oder zusammengesetzten Arrays arbeitet.

#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.

Answer 4

Wenn Sie sicherstellen wollen, dass jedes Element des Arrays explizit initialisiert wird, lassen Sie die Dimension in der Deklaration einfach weg:

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

Der Compiler wird die Dimension aus der Initialisierungsliste ableiten. Leider kann bei mehrdimensionalen Arrays nur die äußerste Dimension weggelassen werden:

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

ist in Ordnung, aber

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

ist nicht.

Answer 5

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)
};   

So bleibt die Reihenfolge gewahrt, auch wenn Sie einige der Enum-Werte durcheinander schreiben.

Mehr über diese Technik finden Sie unter aquí et aquí .