[[:tux|{{ :linux.png?40|}}]]
=====C → Arrays====
Unter einem >><fc #008000>Array</fc><< versteht man die Zusammenfassung von mehreren Variablen des gleichen Typs und des selben Namens.
====Eindimensionale Arrays====
Die allgemeine Syntax zur Definition eines eindimensionalen Arrays ist: **//Datentyp Arrayname [GROESSE];//**

Beispiele:

<code c|Array Deklaration>int alpha [4]; /* Array aus 4 Elementen vom Typ Integer */
char beta [9]; /* Array aus neuen Elementen vom Typ Character */</code>

Die Anzahl der Elemente >>[GROESSE]<< muss immer eine positive, ganze Zahl sein. Das kann eine Konstate (Zahl) sein, nicht aber eine Variable. Die Größe eines Arrays kann nicht dynamisch zugeordnet werden, sie kann jedoch während der Laufzeit mit Hilfe der Funktionen >>malloc()<< und >>calloc()<< errechnet und konstruiert werden.

Angesprochen wird das gesamte Array über den //Arraynamen// und dem //Indexwert// der in //[GROESSE]// definierten Anzahl der Elemente des Arrays. Der Indexwert fängt bei Null an zu zählen (zero based index). Durch die Deklaration eines Arrays wird der benötigte Platz dafür, vorgegeben durch des Datentyp, im Speicher reserviert. Das bedeutet konkret, dass das Array >><fc #008000>int alpha [4]</fc>;<< den Platz für vier Integer (int) Variablen belegt, die genaue Größe hängt vom zugrunde liegenden System ab. Bei einem 32 Bit Integer (4 Byte) werden demnach 16 Byte reserviert.

{{ :tux:array2.png |}}

Bei der Initialisierung des Arrays wird dieses durch viele Compiler bereits mit Null gefüllt, solange nicht schon bei der Deklaration das Array initialisiert wird. Wird das Array mit weniger Elementen gefüllt, wie in //[GROESSE]// vorgegeben, dann wird der verbliebene Platz mit Null gefüllt. Die Angabe der Größe //[GROESSE]// des Arrays kann bei der Deklaration entfallen, wenn das Array explizit bereits bei der Deklaration initialisiert wird:

<code c|Initialisierung eines Arrays>int alpha [] = {0, 1, 2, 3};
int beta [4] = {0, 1, 2}; /* entspricht »int beta [4] = {0, 1, 2, 0};« */</code>

Die Größe //[GROESSE]// (Anzahl der Elemente) eines Arrays kann man ermitteln, in dem man den Gesamtspeicherplatz eines Arrays durch den Speicherplatzbedarf des zugrunde liegenden Datentyps teilt: 

<code c|sizeof_array.c>#include <stdio.h>

int alpha [] = {0, 1, 2, 3};

int main() {
    printf("Das Array alpha belegt im Speicher %d Byte Platz\n", sizeof(alpha));
    printf("Der Datentyp int (Integer) belegt pro Element %d Byte Platz im Speicher\n", sizeof(int));
    printf("Das Array alpha beinhaltet %d Elemente\n", sizeof(alpha) / sizeof(int));
    return 0;
}</code>

<xterm>$ <fc #008000>./sizeof_array</fc>
Das Array alpha belegt im Speicher 16 Byte Platz
Der Datentyp int (Integer) belegt pro Element 4 Byte Platz im Speicher
Das Array alpha beinhaltet 4 Elemente</xterm>

Eine etwas besondere Rolle im Kontext von Arrays, spielt der Datentyp Character (char). Ein Element dieses Datentyps ist per Definition 1 Byte groß, d.h. es wird für jedes Zeichen nur ein Byte im Speicher belegt. Jedoch wird hier das Array mit dem Zeichen >><fc #008000>\0</fc><< abgeschlossen, was bedeutet, dass bei der Deklaration eines Zeichenfeld Arrays ein Zeichen mehr deklariert werden muss. Der String >>Hello, world!<< zB besteht aus 13 Zeichen, beim zählen der Elemente eines Arrays, welches mit dem String >>Hello, world!<< initialisiert ist, werden demnach 14 Elemente gezählt:

<code c|char_arrays_1.c>#include <stdio.h>

char alpha[] = "Hello, world!";

int main(void) {

  printf("Anzahl der Elemente des Strings '%s' ist %d\n", alpha, sizeof(alpha));
  printf("Die Groesse eines Element des Datentyps char ist %d Byte\n", sizeof(char));
  return 0;
}</code>

<xterm>$ <fc #008000>./char_arrays_1</fc>
Anzahl der Elemente des Strings 'Hello, world!' ist 14
Die Groesse eines Element des Datentyps char ist 1 Byte</xterm>

Ein char-Array kann auf mehrere Weisen initialisiert und auch ausgegeben werden:

<code c|int_char_arrays.c>#include <stdio.h>

char alpha01[14] = {72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0};
char alpha02[14] = {'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', '\0'};
char alpha03[]   = "Hello, world!";
int i;

int main(void) {
    printf("%s\n", alpha01);
    printf("%s\n", alpha02);
    printf("%s\n", alpha03);

    for(i=0; i<sizeof(alpha01); i++) {
       printf("%c", alpha01[i]);
    }
    printf("\n");

    for(i=0; i<sizeof(alpha02); i++) {
       printf("%c", alpha02[i]);
    }
    printf("\n");

    for(i=0; i<sizeof(alpha03); i++) {
       printf("%c", alpha03[i]);
    }
    printf("\n");

    return 0;
}</code>

Dieser Coder gibt erst mal immer den gleichen String >><fc #008000>Hello, world!</fc><< aus, welcher auf unterschiedliche Weise in ein char-Array kopiert wurde.

<xterm>$ <fc #008000>./int_char_arrays</fc> 
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
</xterm>

Damit man den Inhalt der Arrays >>alpha01<< und >>alpha02<< nicht selber ausrechnen und tippen muss, kann man die Ausgabe mit geeigneten Formatierungszeichen so hinbiegen, dass man sie so schon übernehmen kann:

<code c|out_char_arrays.c>#include <stdio.h>

char alpha[] = "Hello, world!";
int i;

int main(void) {

  for(i=0; i<sizeof(alpha); i++) {
       printf("%d, ", alpha[i]); /* %d gibt den Inhalt als dezimale Ganzzahl aus */
    }
    printf("\n");

    for(i = 0; i < sizeof(alpha) -1; i++) {
       printf("'%c', ", alpha[i]); /* %c gibt den Character, also das Zeichen als solches aus */
    }

    printf("\n");
    return 0;
}</code>

<xterm>$ <fc #008000>./out_char_arrays</fc> 
72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0, 
'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!',</xterm>