Arrays und Pointer

Nur für Spezialisten

Arrays:
Arrays sind Kollektionen von Objekten derselben Art, die aufeinanderfolgend im Speicher angelegt werden.

Deklaration: Type name[Laenge]
Zugriff: auf einzelne Elemente kann direkt mittels des Positions–Index zugegriffen werden: name[index]
Vorsicht: C++ zählt von 0 bis N-1: 1. Element = Index '0'

int n[20]; // Deklaration von int array mit 20 Elementen
// direkter Zugriff auf einzelne Elemente mittels [index]
// aber Vorsicht, C/C++ zaehlt von 0 bis N-1
n[0] = ...; //1. Element
...
n[19] = ...;// Letztes Element

// Auch direkte Initialisierung moeglich, 
// dann keine Dimensionierung noetig
double x[] = { 2.7, 8.1, 9.0, 27.4, 1.45e8, -0.886e-50 };
//
// Ausgabe 1. und letztes Element
cout << x[0] << " " << x[5] << endl;

In modernem C++ wird weitgehend auf die Verwendung von Standard Arrays verzichtet und stattdessen der STL Vector (vector<Type>) verwendet. Dieser ist wesentlich flexibler in Bezug auf dynamisches Erzeugen, Erweitern, Initialisieren, etc.

Pointer:
Ein Pointer ist eine Variable, die eine Speicheradresse enthält.

Deklaration: Type * name, d.h. auch hier Typ-Angabe erforderlich, Unterschied zu normaler Variablen–Deklaration ist * vor dem Identifier.
Zuweisung: name = & var, Address-Zuweisung mittels Adress Operator <#2862#>&.
Verwendung (1): Wert (=Inhalt der Pointer Variablen) ist Adresse
Verwendung (2): De–Referenzieren, d.h. Auslesen des Wertes an der Adresse mittels * vor Namen.

    int b = 42;
    int *pb;  // pb deklariert als pointer auf int
    pb = &b;  // & ist Adress operator, liefert Adresse von b
    cout << b << endl;
    cout << pb << endl; // Kryptische Adresse
    cout << *pb << endl; // De-referenzieren: *pb == b
    double x = 7.256;
    double *px = &x; // px deklariert als pointer auf double
    px = &b; // illegal pointer auf double kann nicht Adresse von int nehmen

Einfache Variable: Name ist “Label” mit dem Inhalt der Variablen angesprochen wird:
Pointer: Auch Variable, aber Inhalt ist Adresse und Typ einer anderen Variablen:

... oder ein Array:

Pointer–Arithmetik
Für pointer ist Addition und Subtraktion definiert

pa+3 zeigt auf Speicherstelle 3*int weiter oben als pa ( = 3*4 = 12 Bytes).
px - 5 zeigt auf Speicherstelle 5*double weiter unten als px ( = 5*8 = 40 Bytes).
Analog decrement/increment: Nach pa $\bgroup\color{magenta}$--$\egroup$ ; ... px++;
zeigt pa auf die um 4 Byte kleiner Adresse und px auf die um 8 Byte höhere Adresse.

Pointer und Arrays sind eng verknüpft, die Syntax kann man wechselweise verwenden:



    int a[5] = { 1, 2, 3, 4, 5}; // direct array initialisation !
    int *pa = a;
    cout << pa[2] << endl;   // array-syntax for pointer 
    cout << *(a+2) << endl;  // pointer-syntax for arrays
    pa += 2;
    cout << *pa << endl;  // .. 3
    a += 2;               // illegal, no pointer arithmetics for arrays

Vorsicht, bei Definition eines Pointers wird nur der Pointer selbst angelegt, nicht das Objekt worauf er zeigt:


    int c = 55;
    int d = 66;
    int *pc;
    *pc = d;   // illegal, pointer zeigt ins jenseits: --> core dump
    pc = &d;   // ok, nun zeigt er auf d
    *pc = c;   // ok, Wert bei d wird ueberschrieben

Nicht–initialisierte Pointer gefährlich:

core dump bei Zugriff auf illegalen Bereich in Unix $\bgroup\color{green}\ensuremath{\Rightarrow}\egroup$ Programm–Abbruch aber klare Diagnose.
Überschreiben von anderen Datenbereichen des eigenen Programms $\bgroup\color{green}\ensuremath{\Rightarrow}\egroup$ schwer zu findende, nicht reproduzierbare Laufzeit–Fehler.
Überschreiben von Datenbereichen anderer Programme bzw. des Betriebssystems. Nicht möglich unter Unix/Linux und Windows NT/XP, aber grosses Problem für Windows 95/98/...

Pointer – Wozu?

Pointer sind für eine Reihe von Aufgaben unverzichtbar:

Arbeiten mit dynamisch angelegtem Speicher oder Datenstrukturen bzw. Klassen ( $\bgroup\color{green}\ensuremath{\Rightarrow}\egroup$ später)
Verknüpfen von Datenstrukturen.
Direktes Ansprechen von Ein-/Ausgabe-Ports oder sonstigen Peripherie-Geräten.

Allerdings ist die Verwendung heikel, kleine Programmier–Fehler können zu bizarren, schwer zu findenden Laufzeit–Fehlern führen.

In C werden Pointer sehr häufig verwendet für Arbeiten mit character strings (char *) , für Parameterübergabe bei Funktionsaufrufen ( $\bgroup\color{green}\ensuremath{\Rightarrow}\egroup$ später), u.v.m.

In C++ deutlich reduziert, an vielen Stellen kann man mit Referenzen arbeiten, STL container anstelle dynamischer Arrays verwenden, ...