Programmiersprache C/C++

Arrays

Arrays (deutsch auch als Felder oder Reihungen bezeichnet) gehören zu den aggregierten Datentypen, die im allgemeinen in jeder höheren Programmiersprache zur Verfügung stehen.

Ein Array besteht aus verschiedenen Komponenten, die alle den gleichen Datentyp besitzen.
Das Array (als Gesamtheit aller Komponenten) wird über einen Namen angesprochen.
Eine Komponente eines Arrays wird durch den Array-Namen und einen Index- Wert (eindimensionales Array) bzw. verschiedene Index-Werte (mehrdimensionales Array) angesprochen.
Der Index besitzt einen ordinalen Datentyp. Meistens wird mit ganzen Zahlen gearbeietet.
Der Index wird in C mit Null beginnend gezählt.

Meist werden Array über anonyme Datentypen deklariert:

  datentyp name[laenge];                  /* eindimensionales Array */
  datentyp name[laenge_1][laenge_2];      /* zweidimensionales Array */
  datentyp name[laenge_1]...[laenge_n];   /* n-dimensionales Array */

Beispiele:

  #define m  100
  #define n  200

  int    i[10];
  char   s[20];
  double d[m][n];

Der Zugriff auf Komponenten der oben deklarierten Arrays kann wie folgt geschehen:

  i[0]       erste Komponente des Arrays i
  s[19]      letzte Komponente des Arrays s
  d[0][0]    erste Komponente des Arrays d
  d[i][j]    (i*n + j+1)-te Komponente des Arrays d

Operatoren können immer nur auf Komponenten eines Arrays, nicht aber auf das Array selbst angewendet werden.

Initialisierung von Arrays

Bei der Deklaration eines Arrays kann gleichzeitg an die Komponenten ein Wert zugewiesen werden:

  datentyp name[laenge] = { wert_1, ..., wert_n };

Die ersten n Elemente (Komponenten) werden mit den angegebenen Werten belegt. Ist laenge > n, so erhalten die restlichen Elemente den Wert Null.

Die Längenangabe kann entfallen, wenn alle Elemente explizit initialisiert werden:

  datentyp name[] = { wert_1, ..., wert_n };

Das Array hat dann die Länge n.

Beispiel:

  int a[4] = { 0, 1, 2, 3 };
  int b[]  = { 0, 1, 2, 3 };
  int c[4] = { 0, 1, 2 };        /* entspricht  c[4] = { 0, 1, 2, 0 };  */

Bemerkung:
Die Länge (Anzahl der Elemente) von b kann wie folgt ermittelt werden:

  sizeof(b) / sizeof(int)

Eine besondere Rolle spielen Zeichenfelder.
Beispiel:

  char s1[7] = { 'S', 't', 'r', 'i', 'n', 'g', '\0' };
  char s2[]  = "String";

Das folgende Programm demonstriert unterschiedliche Möglichkeiten für den Umgang mit Zeichenfeldern (Zeichenketten):

  #include <stdio.h>      

  int main(void)
  {
    char s0[7] = { 83, 116, 114, 105, 110, 103, 0 };
    char s1[7] = { 'S', 't', 'r', 'i', 'n', 'g', '\0' };
    char s2[]  = "String";
    int i;
  
    for ( i=0; i<sizeof(s0); i++ ) printf("%c", s0[i]); printf("\n");
    for ( i=0; i<sizeof(s1); i++ ) printf("%c", s1[i]); printf("\n");
    for ( i=0; i<sizeof(s2); i++ ) printf("%c", s2[i]); printf("\n");
    printf("%s\n", s0);
    printf("%s\n", s1);
    printf("%s\n", s2);

    return 0;
  }

Es werden sechs identische Zeilen ausgegeben, die identisch sind und jeweils String enthalten.

Auch mehrdimensionale Arrays können initialisiert werden.
Beispiel:

  int a[2][3] = { { 11, 12, 13 }, { 21, 22, 23 } };    /*  identische  */
  int b[2][3] = { 11, 12, 13, 21, 22, 23 };            /* Wertbelegung */

  int c[2][3] = { { 1 }, { 2 } }                       /*  identische  */
  int d[2][3] = { { 1, 0, 0 }, { 1, 0, 0 } }           /* Wertbelegung */

Fehlerquellen

Ein Array, welches mittels
```
   int a[2];
   
```
deklariert wurde, besteht aus den Komponenten a[0], a[1].
a[2] ist unzulässig !
Die Verwendung von a[2] führt jedoch nicht notwendigerweise zu einem Fehler !
Bei der Übergabe/Übernahme von mehrdimensionalen Arrays an Prozeduren, die in einer anderen Sprache geschrieben sind, ist die Abspeicherungsreihenfolge zu beachten !
In C/C++ (und den meisten Sprachen) wächst zuerst der letzte Index, in Fortran zum Beispiel jedoch ist es der erste Index !
```
   C:        int a[2][2];        a[0][0]  a[0][1]  a[1][0]  a[1][1]
   Fortran:  integer a(2,2)      a(1,1)   a(2,1)   a(1,2)   a(2,2)
   
```
In C erfolgt die Anordnung zeilenweise, in Fortran spaltenweise !
Zudem beginnt Fortran Indizes standardmäß ab 1 zu zählen, C jedoch ab 0 !

Beispiel:

  #include <stdio.h>

  int main(void)
  {
    int a[4] = { 0, 1, 2, 3 };
    int *ip;
    int i;

    for ( i=0; i<4; i++ ) printf("%d ", a[i]);
    printf("\n");

    ip = a;
    for ( i=0; i<4; i++ ) printf("%d ", *ip++);
    printf("\n");

    ip = a;
    for ( i=0; i<4; i++ ) printf("%d ", *(ip+i));
    printf("\n");

    for ( i=0, ip=a; i<4; i++, ip++ ) printf("%d ", *ip);
    printf("\n");

    ip = &a[0];                                   /* entspricht  ip = a;  */
    for ( i=0; i<4; i++ ) printf("%d ", ip[i]);
    printf("\n");

    return 0;
  }

Alle Ausgabeschleifen liefern das gleiche Ergebnis: die Wertbelegung des Arrays a.

Zurück zum Menü
Zurück zur vorigen Seite Weiter zur nächsten Seite

P. Böhme, 31.12.1995