Zeiger und Vektoren

In C besteht eine besondere Beziehung zwischen Zeigern und Vektoren. Lediglich bei der Deklaration handelt es sich um unterschiedliche Objekte, in der Verwendung hingegen sind sie fast völlig identisch. Dies klingt zunächst etwas merkwürdig, läßt sich aber durch folgende Regeln einfach erklären:

1. Der Name eines Vektors kann behandelt werden wie ein Zeiger auf das erste Element (mit Index 0) des Vektors
2. Ein Zeiger zeigt immer auf das erste Element eines Vektors (der evtl. nur ein Element enthält)

Daraus ergeben sich folgende Ausdrucksmöglichkeiten:

Seien folgende Deklarationen gegeben:

int vec[20];
int *p
...
p=vec;

dann gilt:

1. p zeigt auf vec[0], ist also gleich &vec[0]
2. p + 1 zeigt auf vec[1], ist also gleich &vec[1]
3. *(p+1) ist gleich vec[1]

und umgekehrt:

1. vec zeigt auf p[0], ist also gleich &p[0]
2. vec + 1 zeigt auf p[1], ist also gleich &p[1]
3. *(vec+1) ist gleich p[1]

oder allgemein:

p[n] == *(p+n);
p + n == &p[n];

Aufgrund dieser Arithmetik ist es natürlich auch möglich, zu schreiben:

p = p + 1;

und daher auch p += 1 oder p++.

Diese letzten Ausdrücke sind allerdings nur mit echten Pointervariablen möglich, nicht mit Vektorennamen, denn der Name eines Vektors bezeichnet immer einen Zeiger auf das erste Element (Index 0) des Vektors

Nun können wir besser verstehen, warum Vektoren, die als Funktionsparameter erscheinen, immer die Originalvektoren manipulieren. Übergeben wird der Name des Vektors, und daher ein Zeiger auf das erste Element.

Weiterhin können wir jetzt auch besser bestimmen, von welchem Typ die Zeichenketten in C sind: es sind Vektoren vom Typ char. Qua Definition ist das letzte Element in einem solchen Vektor binär 0, sodaß für die Zeichenkette "Hallo" insgesamt 6 Bytes (5 für die lesbaren Buchstaben und eines für die abschließende 0) benötigt werden.

Übergeben wir eine solche Zeichenkette einer Funktion, so erhält diese (s.o.) einen Zeiger auf das erste Byte dieser Zeichenkette.

Wir wollen nun versuchen, eine Funktion zu schreiben, die einen Zeichenkette in eine andere kopiert.

Erster Versuch:

void string_copy (char quelle[], char ziel[])
{
  int index = 0;
  while(quelle[index] != 0)
  {
    ziel[index] = quelle[index];
    index++;
  }
}

Das können wir etwas kürzer schreiben:

void string_copy (char quelle[], char ziel[])
{
  int index = 0;
  while(ziel[index] = quelle[index])
    index++;
}

Jetzt benutzen wir die Zeigerschreibweise:

void string_copy (char *quelle, char *ziel)
{
  while(*ziel = *quelle){
    ziel++; 
    quelle++;
  }
}

und jetzt benutzen wir die Zeigerarithmetik noch effizienter:

void string_copy (char *quelle, char *ziel)
{
  while(*ziel++ = *quelle++)
    ;
}