Wie initialisieren Sie ein array in C (nicht C++)?

Wie kann ich die initialisieren Sie ein array in C?

Sollte ich es definieren durch einen Zeiger: int *data[] oder kann ich einfach code: int data[] = {};?

Ich habe zum Beispiel definiert es wie:

int main(void) {
    int data[] = {44, 22, 1, 2, 3, 1000, 3};

Nun, wie kann ich die initialisieren Sie das array data?

  • Was genau meinst du mit "neu initialisieren"?
  • Meinst du frei den alten array und reservieren?
  • Ich meinte genau das, initialisieren, einmal habe ich Sie erstellt ein array , dann möchte ich erneut initialisieren es mit seiner Größe und Mitglieder
InformationsquelleAutor | 2012-03-20
  1. 11

    Initialisierung nur einmal vorkommt, wenn Sie das array erstellen:

    int foo[] = {0,1,2,3,4}; //creates a 5-element array of int and
                         //initializes it

    Einmal das array definiert wurde, können Sie zuweisen, um einzelne Elemente:

    foo[0] = 5;
foo[1] = 4;
foo[2] = 3;
foo[3] = 2;
foo[4] = 1;

    aber Sie können nicht zuweisen, das array selbst; anders ausgedrückt, Sie können nicht so etwas schreiben

    foo = {5,4,3,2,1};

    Sie können jedoch, verwenden Sie memcpy zu kopieren Inhalt von einem array zu einem anderen:

    int foo[5];
int bar[5] = {1,2,3,4,5};
int i;

memcpy(foo, bar, sizeof bar); //Copies *contents* of bar to foo

for (i = 0; i < sizeof foo / sizeof *foo; i++)
  printf("foo[%d] = %d\n", i, foo[i]);

    Ebenso ein array erstellt auf diese Weise kann nicht geändert werden; seine Größe ist fest auf der Deklaration. In C89 und früher, die array-Größe muss zur Kompilierzeit bekannt ist - entweder durch Angabe der Größe mit einer compile-Zeit-Konstante (fester Ausdruck oder einem makro, das erweitert, um einen integralen Ausdruck) oder durch eine Initialisierung wie oben, aus denen die array-Größe wird berechnet.

    C99 eingeführt variabler Länge arrays, das kann erklärt werden mit einer run-time-Wert, wie:

    void foo(int x)
{
  int arr[x];
  ...
}

    Beachten Sie, dass, wie bei normalen arrays, VLAs kann nicht geändert werden, nachdem Sie definiert wurden.

    Alternativ können Sie dynamisch alloziert ein array mit malloc, obwohl Sie nicht initialisieren es in der Art und Weise vor:

    int *foo = malloc(sizeof *foo * N); //where N is the number of elements

    Können Sie noch zuordnen zu den einzelnen Elementen:

    foo[0] = 5;
foo[1] = 4;
foo[2] = 3;
...

    oder verwenden Sie memcpy wie oben gezeigt. Beachten Sie, dass müssen Sie daran denken free array, wenn du fertig bist:

    free(foo);

    Arrays erstellt, in dieser Art und Weise kann in der Größe verändert werden, mit realloc:

    int *tmp = realloc(foo, sizeof *foo * NEW_NUMBER_OF_ELEMENTS);
if (tmp)
  foo = tmp;

    Warum nicht einfach zuweisen, das Ergebnis realloc zurück foo? Wenn die realloc operation fehl, wird NULL zurückgegeben. Wenn das passiert, und wir weisen das Ergebnis wieder zu foo verlieren wir die Spur der Erinnerung wir haben bereits zugewiesen ist, führt zu einem Speicherverlust.

    C99 eingeführt, ein array-literal-syntax; Sie können etwas schreiben wie

    int *foo = (int[]){1,2,3,4,5};

    und dann ein index in foo wie ein array:

    printf("foo[%d] = %d\n", i, foo[i]);

    ich bin mir zwar ziemlich sicher, dass Sie nicht änderung des Inhalts der foo[i], ähnlich wie die, die Sie versuchen, zu ändern, den Inhalt einer string-literal nicht definiert ist (obwohl ich noch nicht gefunden, Kapitel und vers auf, dass).

    InformationsquelleAutor John Bode
  2. 4

    Können Sie nicht re-initialisieren Sie alle Arten als solche definitiv nicht arrays.

    Die Initialisierung ist ein einmaliges Ereignis, wenn man einen Wert einer variable in der gleichen Anweisung, wenn es erstellt wird.

    Könnten Sie ausdrücklich Schleife durch das array und füllen es wieder, wenn Sie brauchen, um zuweisen neue Werte zu jedem von Ihnen

    ODER

    Verwenden memset() oder memcpy() für die Einstellung aller Elemente auf bestimmten Wert oder kopieren bestimmte Elemente resp.

    • Wie über die reszing array-Länge in reinem c in der Laufzeit? Und wie abot free()/realloc() ist es?
    • Die Länge eines array muss eine compile-Zeit-Konstante, Also können Sie es nicht ändern zur Laufzeit.Auch Sie können die Größe nur eines dynamisch reservierten Arrays mithilfe realloc() aber das ist nicht neu-Initialisierung.
    InformationsquelleAutor Alok Save
  3. 1

    Initialisierung (falls vorhanden) müssen getan werden, während der Zeit der Erstellung einer Variablen. Weil, während der compile-Zeit, der compiler ordnet diesen Wert der Variablen. Alle anderen Aufgaben, nachdem diese Zeile ausgeführt wird, während der Laufzeit nur.

    In Ihrem Fall, können Sie initialisieren ein array während der Erstellung. Das nächste mal, wenn Sie einen Wert zuweisen, bedeutet nicht einen 'Initialisierung'; es ist eher ein run-time-Aufgabe, die nur.

    Wenn Sie erstellen möchten, und speichern Sie Elemente dynamisch, dann kann man Zeiger verwenden, um so zu tun.

    • die erneute Initialisierung von Arrays kann nicht getan werden in reinem c-runtime oder ich muse verwenden, Zeiger, free()/realloc() ?
    • realloc() reservieren mit einer neuen Größe. free() löschen, werden alle zugewiesenen Speicher. In Ihrem Fall können Sie realloc()
    InformationsquelleAutor Vishnu Haridas
  4. 1

    Meine Teillösung für die Zuweisung der neuen Werte (Werke in gcc mit c99-syntax):

    #define arr_set(type, arr, ...) { \
    int arr_size = sizeof((type[]){__VA_ARGS__}) / sizeof(type); \
    type *parr = (type[]){__VA_ARGS__}; \
    for (int i = 0; i < arr_size; i++) \
        arr[i] = *parr++; }

    Ist es nicht sicher (kein bounds checking), überschreibt es können nur aufeinander folgende Mitglieder ab von Anfang an, aber ich finde es nützlich, manchmal.

    Komplettes Beispiel:

    #include <stdio.h>

#define arr_set(type, arr, ...) { \
    int arr_size = sizeof((type[]){__VA_ARGS__}) / sizeof(type); \
    type *parr = (type[]){__VA_ARGS__}; \
    for (int i = 0; i < arr_size; i++) \
        arr[i] = *parr++; }

#define print_buf_int(buf) { \
    for (int i = 0; i < sizeof(buf)/sizeof(buf[0]); i++) \
        printf("%d ", (int)buf[i]); \
    printf("\n"); }

#define print_buf_char(buf) { \
    for (int i = 0; i < sizeof(buf)/sizeof(buf[0]); i++) \
        if (buf[i]) \
            printf("%c ", (char)buf[i]); \
        else \
            printf("null "); \
    printf("\n"); }

#define print_buf_str(buf) { \
    for (int i = 0; i < sizeof(buf)/sizeof(buf[0]); i++) \
        printf("%s ", (char*)buf[i]); \
    printf("\n"); }

int main()
{
    int brr[8] = {};
    int arr[8] = {3, 4, 5, 1, 0, 2};
    print_buf_int(arr);

    arr_set(int, arr, 9, 8 ,7);
    print_buf_int(arr);

    arr_set(int, arr, 0, 1, 2, 3, 4, 5, 6, 7);
    print_buf_int(arr);

    arr_set(int, arr, 11, 22, 33, 44, 55, 66, 77, 88, 99);  //'brr' gets overwritten!!!
    print_buf_int(arr);
    print_buf_int(brr);

    unsigned char crr[13] = {'a', 'b', 'c', [12] = 'z'};
    print_buf_char(crr);

    arr_set(char, crr, 'd', 'e', 'f', '1', '2', '3');
    print_buf_char(crr);

    unsigned short srr[] = {111, 222, 333, 444, 555};
    print_buf_int(srr);

    arr_set(unsigned short, srr, -1, 0, 666);
    print_buf_int(srr);

    char *prr[] = {"hello", "variadic", "world"};
    print_buf_str(prr);

    arr_set(char*, prr, "good", "bye");
    print_buf_str(prr);
}

    Ausgabe:

    3 4 5 1 0 2 0 0 
9 8 7 1 0 2 0 0 
0 1 2 3 4 5 6 7 
11 22 33 44 55 66 77 88 
99 0 0 0 0 0 0 0 
a b c null null null null null null null null null z 
d e f 1 2 3 null null null null null null z 
111 222 333 444 555 
65535 0 666 444 555 
hello variadic world 
good bye world
    InformationsquelleAutor LennyB
Schreibe einen Kommentar