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

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

#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

Answer 2

Die kurze Antwort lautet: Wenn Sie die Optimierung zur Kompilierzeit einschalten, werden Sie nicht besser abschneiden als so:

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

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

Answer 3

Ich weiß, dass Benutzer Tarski hat diese Frage in ähnlicher Weise beantwortet, aber ich habe noch ein paar Details hinzugefügt. Verzeihen Sie einige meiner C, denn ich bin ein wenig eingerostet, da ich eher dazu neige, C++ zu verwenden, aber hier geht es.

---

Wenn Sie die Größe des Feldes 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 Vorbehalte; einer davon ist, dass UINT myArray[size]; wird nicht direkt bei der Deklaration initialisiert, aber der nächste Codeblock oder Funktionsaufruf initialisiert jedes Element des Arrays auf denselben Wert, den Sie wünschen. Die andere Einschränkung ist, dass Sie eine initializing function für jede type die Sie unterstützen werden, und Sie müssten auch die printArray() Funktion zur Unterstützung dieser Typen.

---

Sie können diesen Code mit einem Online-Computer ausprobieren. aquí .

Answer 4

Für die verzögerte Initialisierung (d.h. die Initialisierung von Klassenmitgliedern im Konstruktor) ist folgendes zu beachten:

int a[4];

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

Answer 5

Wenn die Größe des Arrays im Voraus bekannt ist, könnte man ein Makro des Boost-Präprozessors C_ARRAY_INITIALIZE verwenden, um die schmutzige Arbeit für Sie zu erledigen:

#include <boost/preprocessor/repetition/enum.hpp>
#define C_ARRAY_ELEMENT(z, index, name) name[index]
#define C_ARRAY_EXPAND(name,size) BOOST_PP_ENUM(size,C_ARRAY_ELEMENT,name)
#define C_ARRAY_VALUE(z, index, value) value
#define C_ARRAY_INITIALIZE(value,size) BOOST_PP_ENUM(size,C_ARRAY_VALUE,value)