Wie initialisiere ich alle Mitglieder eines Arrays mit demselben Wert?

Ich habe ein großes Array in C (nicht C ++, wenn 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 es memset()in meinem Fall verwenden, aber gibt es keine Möglichkeit, dies zu tun, die direkt in die C-Syntax integriert ist?

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

Dies initialisiert also alle Elemente auf 0:

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

In C ++ initialisiert eine leere Initialisierungsliste auch jedes Element auf 0. Dies ist mit C nicht zulässig :

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

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 diese "0" bedeutet nicht unbedingt "All-Bits-Null", daher ist die Verwendung der oben genannten Punkte besser und portabler als memset (). (Gleitkommawerte werden auf +0 initialisiert, Zeiger auf Nullwert usw.)

Wenn Ihr Compiler GCC ist, können Sie die folgende Syntax verwenden:

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

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

Zum statischen Initialisieren eines großen Arrays mit demselben Wert 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 müssen, müssen Sie den Austausch nur an einer Stelle durchführen.

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.

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

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

Der Compiler leitet die Dimension aus der Initialisierungsliste ab. 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 OK, aber

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

ist nicht.

Ich habe Code gesehen, der diese Syntax verwendet:

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

Besonders nützlich ist es, wenn Sie ein Array erstellen, das Aufzählungen 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, auch wenn Sie einige der Enum-Werte nicht in der richtigen Reihenfolge schreiben.

Mehr über diese Technik finden Sie hier und hier .

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.

Sie können den gesamten statischen Initialisierer wie oben beschrieben ausführen, aber es kann eine echte Enttäuschung sein, wenn sich Ihre Arraygröße ändert (wenn sich Ihr Array ändert, wenn Sie nicht die entsprechenden zusätzlichen Initialisierer hinzufügen, erhalten Sie Müll).

memset gibt Ihnen einen Laufzeit-Treffer für die Ausführung der Arbeit, aber kein richtig ausgeführter Code-Größen-Treffer ist immun gegen Änderungen der Array-Größe. Ich würde diese Lösung in fast allen Fällen verwenden, wenn das Array größer als beispielsweise ein paar Dutzend Elemente war.

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 Teil des Erstellungsprozesses zu machen.

Hier ist ein anderer Weg:

static void
unhandled_interrupt(struct trap_frame *frame, int irq, void *arg)
{
    //this code intentionally left blank
}

static struct irqtbl_s vector_tbl[XCHAL_NUM_INTERRUPTS] = {
    [0 ... XCHAL_NUM_INTERRUPTS-1] {unhandled_interrupt, NULL},
};

Sehen:

C-Erweiterungen

Designated inits

Stellen Sie dann die Frage: Wann kann man C-Erweiterungen verwenden?

Das obige Codebeispiel befindet sich in einem eingebetteten System und wird niemals das Licht eines anderen Compilers sehen.

Zum Initialisieren von 'normalen' Datentypen (wie Int-Arrays) können Sie die Klammer-Notation verwenden, die Werte werden jedoch nach dem letzten auf Null gesetzt, wenn noch Platz im Array vorhanden ist:

// put values 1-8, then two zeroes
int list[10] = {1,2,3,4,5,6,7,8};

Wenn das Array int oder irgendetwas mit der Größe von int ist oder die Größe Ihres Mem-Musters genau zu einem int passt (dh alle Nullen oder 0xA5A5A5A5), ist es am besten, memset () zu verwenden .

Andernfalls rufen Sie memcpy () in einer Schleife auf, die den Index verschiebt.

Eine leicht ironische Antwort; Schreiben Sie die Erklärung

array = initial_value

in Ihrer bevorzugten Array-fähigen Sprache (meine ist Fortran, aber es gibt viele andere) und verknüpfen Sie sie mit Ihrem C-Code. Sie möchten es wahrscheinlich als externe Funktion zusammenfassen.

Es gibt eine schnelle Möglichkeit, ein Array eines beliebigen Typs mit einem bestimmten Wert zu initialisieren. Es funktioniert sehr gut mit großen Arrays. Der Algorithmus ist wie folgt:

• initialisiere erstes Element des Arrays (üblicher Weg)
• Kopieren Sie einen Teil, der in einen Teil gesetzt wurde, der nicht gesetzt wurde, und verdoppeln Sie die Größe bei jedem nächsten Kopiervorgang

Für 1 000 000Elemente intArray ist es 4 mal schneller als normale Schleifeninitialisierung (I5, 2 Kerne, 2,3 GHz, 4GiB Speicher, 64 Bits):

loop runtime 0.004248 [seconds]

memfill() runtime 0.001085 [seconds]

#include <stdio.h>
#include <time.h>
#include <string.h>
#define ARR_SIZE 1000000

void memfill(void *dest, size_t destsize, size_t elemsize) {
   char   *nextdest = (char *) dest + elemsize;
   size_t movesize, donesize = elemsize;

   destsize -= elemsize;
   while (destsize) {
      movesize = (donesize < destsize) ? donesize : destsize;
      memcpy(nextdest, dest, movesize);
      nextdest += movesize; destsize -= movesize; donesize += movesize;
   }
}    
int main() {
    clock_t timeStart;
    double  runTime;
    int     i, a[ARR_SIZE];

    timeStart = clock();
    for (i = 0; i < ARR_SIZE; i++)
        a[i] = 9;    
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("loop runtime %f [seconds]\n",runTime);

    timeStart = clock();
    a[0] = 10;
    memfill(a, sizeof(a), sizeof(a[0]));
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("memfill() runtime %f [seconds]\n",runTime);
    return 0;
}

Niemand hat die Indexreihenfolge für den Zugriff auf die Elemente des initialisierten Arrays erwähnt. Mein Beispielcode gibt ein anschauliches Beispiel dafür.

#include <iostream>

void PrintArray(int a[3][3])
{
    std::cout << "a11 = " << a[0][0] << "\t\t" << "a12 = " << a[0][1] << "\t\t" << "a13 = " << a[0][2] << std::endl;
    std::cout << "a21 = " << a[1][0] << "\t\t" << "a22 = " << a[1][1] << "\t\t" << "a23 = " << a[1][2] << std::endl;
    std::cout << "a31 = " << a[2][0] << "\t\t" << "a32 = " << a[2][1] << "\t\t" << "a33 = " << a[2][2] << std::endl;
    std::cout << std::endl;
}

int wmain(int argc, wchar_t * argv[])
{
    int a1[3][3] =  {   11,     12,     13,     // The most
                        21,     22,     23,     // basic
                        31,     32,     33  };  // format.

    int a2[][3] =   {   11,     12,     13,     // The first (outer) dimension
                        21,     22,     23,     // may be omitted. The compiler
                        31,     32,     33  };  // will automatically deduce it.

    int a3[3][3] =  {   {11,    12,     13},    // The elements of each
                        {21,    22,     23},    // second (inner) dimension
                        {31,    32,     33} };  // can be grouped together.

    int a4[][3] =   {   {11,    12,     13},    // Again, the first dimension
                        {21,    22,     23},    // can be omitted when the 
                        {31,    32,     33} };  // inner elements are grouped.

    PrintArray(a1);
    PrintArray(a2);
    PrintArray(a3);
    PrintArray(a4);

    // This part shows in which order the elements are stored in the memory.
    int * b = (int *) a1;   // The output is the same for the all four arrays.
    for (int i=0; i<9; i++)
    {
        std::cout << b[i] << '\t';
    }

    return 0;
}

Die Ausgabe ist:

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

11      12      13      21      22      23      31      32      33

Die kurze Antwort lautet: Wenn Sie die Optimierung zur Kompilierungszeit aktivieren, werden Sie nichts Besseres tun:

int i,value=5,array[1000]; 
for(i=0;i<1000;i++) array[i]=value; 

Zusätzlicher Bonus: Der Code ist tatsächlich lesbar :)

1. Wenn Ihr Array als statisch oder global deklariert ist, haben alle Elemente im Array bereits den Standardwert 0.
2. Einige Compiler setzen Arrays im Debug-Modus standardmäßig auf 0.
3. Es ist einfach, den Standardwert auf 0 zu setzen: int array [10] = {0};
4. Für andere Werte haben Sie jedoch memset () oder loop verwendet.

Beispiel: int array [10]; Memset (Array, -1, 10 * sizeof (int));

#include<stdio.h>
int main(){
int i,a[50];
for (i=0;i<50;i++){
    a[i]=5;// set value 5 to all the array index
}
for (i=0;i<50;i++)
printf("%d\n",a[i]);
   return 0;
}

Es gibt die o / p 5 5 5 5 5 5 ...... bis zur Größe des gesamten Arrays

Ich weiß, dass der Benutzer Tarskidiese Frage auf ähnliche Weise beantwortet hat, aber ich habe einige weitere Details hinzugefügt. Verzeihen Sie etwas von meinem C, denn ich bin ein bisschen verrostet, da ich eher dazu neige, C ++ zu verwenden, aber hier ist es.

Wenn Sie die Größe des Arrays im Voraus kennen ...

#include <stdio.h>

typedef const unsigned int cUINT;
typedef unsigned int UINT;

cUINT size = 10;
cUINT initVal = 5;

void arrayInitializer( UINT* myArray, cUINT size, cUINT initVal );
void printArray( UINT* myArray ); 

int main() {        
    UINT myArray[size]; 
    /* Not initialized during declaration but can be
    initialized using a function for the appropriate TYPE*/
    arrayInitializer( myArray, size, initVal );

    printArray( myArray );

    return 0;
}

void arrayInitializer( UINT* myArray, cUINT size, cUINT initVal ) {
    for ( UINT n = 0; n < size; n++ ) {
        myArray[n] = initVal;
    }
}

void printArray( UINT* myArray ) {
    printf( "myArray = { " );
    for ( UINT n = 0; n < size; n++ ) {
        printf( "%u", myArray[n] );

        if ( n < size-1 )
            printf( ", " );
    }
    printf( " }\n" );
}

Es gibt ein paar Einschränkungen oben; Eine davon ist, dass sie UINT myArray[size];bei der Deklaration nicht direkt initialisiert wird. Der nächste Codeblock oder Funktionsaufruf initialisiert jedoch jedes Element des Arrays mit demselben gewünschten Wert. Die andere Einschränkung ist, dass Sie initializing functionfür jeden, den typeSie unterstützen , eine schreiben müssen, und Sie müssten auch die printArray()Funktion ändern , um diese Typen zu unterstützen.

Sie können diesen Code mit einem Online-Complier ausprobieren, den Sie hier finden .

Beachten Sie für die verzögerte Initialisierung (dh die Initialisierung des Klassenmitgliedskonstruktors) Folgendes:

int a[4];

unsigned int size = sizeof(a) / sizeof(a[0]);
for (unsigned int i = 0; i < size; i++)
  a[i] = 0;

Ich weiß, dass in der ursprünglichen Frage ausdrücklich C und nicht C ++ erwähnt wird, aber wenn Sie (wie ich) hierher gekommen sind, um nach einer Lösung für C ++ - Arrays zu suchen, ist hier ein guter Trick:

Wenn Ihr Compiler Fold-Ausdrücke unterstützt , können Sie Template Magic verwenden und std::index_sequenceeine Initialisierungsliste mit dem gewünschten Wert erstellen. Und Sie können es sogar constexprund fühlen sich wie ein Chef:

#include <array>

/// [3]
/// This functions's only purpose is to ignore the index given as the second
/// template argument and to always produce the value passed in.
template<class T, size_t /*ignored*/>
constexpr T identity_func(const T& value) {
    return value;
}

/// [2]
/// At this point, we have a list of indices that we can unfold
/// into an initializer list using the `identity_func` above.
template<class T, size_t... Indices>
constexpr std::array<T, sizeof...(Indices)>
make_array_of_impl(const T& value, std::index_sequence<Indices...>) {
    return {identity_func<T, Indices>(value)...};
}

/// [1]
/// This is the user-facing function.
/// The template arguments are swapped compared to the order used
/// for std::array, this way we can let the compiler infer the type
/// from the given value but still define it explicitly if we want to.
template<size_t Size, class T>
constexpr std::array<T, Size> 
make_array_of(const T& value) {
    using Indices = std::make_index_sequence<Size>;
    return make_array_of_impl(value, Indices{});
}

// std::array<int, 4>{42, 42, 42, 42}
constexpr auto test_array = make_array_of<4/*, int*/>(42);
static_assert(test_array[0] == 42);
static_assert(test_array[1] == 42);
static_assert(test_array[2] == 42);
static_assert(test_array[3] == 42);
// static_assert(test_array[4] == 42); out of bounds

Sie können sich den Code bei der Arbeit ansehen (bei Wandbox)

Ich sehe keine Anforderungen in der Frage, daher muss die Lösung generisch sein: Initialisierung eines nicht spezifizierten möglicherweise mehrdimensionalen Arrays, das aus nicht spezifizierten möglicherweise Strukturelementen mit einem anfänglichen Elementwert aufgebaut ist:

#include <string.h> 

void array_init( void *start, size_t element_size, size_t elements, void *initval ){
  memcpy(        start,              initval, element_size              );
  memcpy( (char*)start+element_size, start,   element_size*(elements-1) );
}

// testing
#include <stdio.h> 

struct s {
  int a;
  char b;
} array[2][3], init;

int main(){
  init = (struct s){.a = 3, .b = 'x'};
  array_init( array, sizeof(array[0][0]), 2*3, &init );

  for( int i=0; i<2; i++ )
    for( int j=0; j<3; j++ )
      printf("array[%i][%i].a = %i .b = '%c'\n",i,j,array[i][j].a,array[i][j].b);
}

Ergebnis:

array[0][0].a = 3 .b = 'x'
array[0][1].a = 3 .b = 'x'
array[0][2].a = 3 .b = 'x'
array[1][0].a = 3 .b = 'x'
array[1][1].a = 3 .b = 'x'
array[1][2].a = 3 .b = 'x'

EDIT: start+element_sizegeändert zu(char*)start+element_size

Früher (und ich sage nicht, dass es eine gute Idee ist) haben wir das erste Element gesetzt und dann:

memcpy (&element [1], &element [0], sizeof (element)-sizeof (element [0]);

Ich bin mir nicht einmal sicher, ob es nicht mehr funktionieren würde (das würde von der Implementierung von memcpy abhängen), aber es funktioniert, indem das ursprüngliche Element wiederholt in das nächste kopiert wird - funktioniert sogar für Arrays von Strukturen.

Wenn Sie parallel meinen, denke ich, dass der Komma-Operator in Verbindung mit einem Ausdruck dies tun kann:

a[1]=1, a[2]=2, ..., a[indexSize]; 

oder wenn Sie in einem einzelnen Konstrukt meinen, können Sie dies in einer for-Schleife tun:

for(int index = 0, value = 10; index < sizeof(array)/sizeof(array[0]); index++, value--)
  array[index] = index;

// Beachten Sie, dass der Kommaoperator in einer Argumentliste nicht der oben beschriebene Paralleloperator ist.

Sie können eine Array-Dekleration initialisieren:

array[] = {1, 2, 3, 4, 5};

Sie können malloc / calloc / sbrk / alloca / etc aufrufen, um einem Objekt einen festen Speicherbereich zuzuweisen:

int *array = malloc(sizeof(int)*numberOfListElements/Indexes);

und Zugriff auf die Mitglieder durch:

*(array + index)

Usw.