Allgemeines zu Zeigern

Ein Zeiger ( Pointer ) ist prinzipiell eine Variable, in der ein Wert gespeichert wird.

Der Unterschied zu 'normalen' Variablen liegt nur in der Interpretation; beim Zeiger wird der Inhalt als eine Adresse im Speicher interpretiert.

Zeiger können verweisen auf:

'Normale' Objekte oder auf

dynamische Objekte

Zeiger auf "normale" Objekte

Dieser Zeiger ist ein Zeiger auf eine Variable, deren Speicherplatz schon beim Compilieren festgelegt wird.

Beispiel:

long NVar;                   // Definition einer long-Variable

long *pNVar ;                // Definition eines Zeigers auf long

pNVar = &NVar ;              // pNormVar erhält die Adresse von NormVar

*pNVar = 17 ;                // NormVar wird der Wert 17 zugewiesen

printf ( '%dn' , *pNVar ) ; // Ausgabe des Wertes

printf ( '%X' , pNVar ) ;    // Ausgabe der Adresse ( Hexadezimal )

Zeiger auf dynamische Objekte

Das Haupteinsatzgebiet ist die dynamische Speicherverwaltung.

Beispiel:

typedef struct knoten

Knoten ;

Knoten * pKn ;

char * pStr ;

in C:

pKn = ( Knoten * ) malloc ( sizeof ( Knoten ) ) ;

pStr = ( char * ) malloc ( 100 ) ;   // 100 Bytes reservieren

free ( pKn ) ; // Freigeben des Speichers

free ( pStr ) ;

in C++:

pKn = new Knoten ;

pStr = new char ( 100 ) ; // 100 Bytes reservieren

// auch z.B.: pDlg = new MyDialog ;  ( komplexe Objekte für MFC )

delete ( pKn ) ;

delete ( pStr ) ; // Freigeben des Speichers

Der VAR-Parameter

Da es in C keine richtigen 'VAR-Parameter' gibt, werden diese durch Zeiger realisiert.

Es wird einer Funktion einfach die Adresse der Variablen übergeben.

Beispiel:

void Tausche ( long *A , long *B )

void main ()

Zeiger und Arrays

In C unterscheiden sich Arrays und Zeiger nur geringfügig:

Ein Array kann nicht 'umgesetzt' werden.  ( Wie konstanter Zeiger auf erstes Element )

Bei der Definition eines Arrays wird Speicher reserviert.

Beispiel:

void main ()

Zeigerarithmetik

Was passiert bei Additionen oder Subtraktionen zweier Zeiger?

Addiert man z.B. die Zahl 17 zu einem Zeiger vom Typ integer, so wird zeigt dieser Pointer auf das Element, welches um 17 Plätze weiter im Speicher liegt, gesetzt.

Dies heißt jedoch nicht, daß der Zeiger um 17 Byte verschoben wurde, sondern um 34 Byte.

Die Rechnung ist ganz einfach:

Speicherstelle-Neu = Speicherstelle-Alt + Anzahl * Größe des Datentyps

Bei char ist die Größe des Datentyps 1, bei integer 2, bei long 4,

Beispiel:

void main ()

Zeiger auf Zeiger

Da ein Zeiger eigentlich eine ganz 'normale' Variable ist, kann man natürlich auch einen Zeiger definieren, der auf einen anderen Zeiger verweist.

Beispiel:

void main ()

Zeiger als VAR-Parameter:

long strtol ( const char* Kette , const char** EndPtr, int Basis ) ;

// EndPtr zeigt auf erstes fehlerhaftes Zeichen

void main ()

Zeiger-Arrays:

void main ( int argc , char *argv[] )

Der void-Zeiger

Ein Zeiger kann natürlich auch vom Typ void sein; dieser Zeiger ist zu jedem anderen Typ kompatibel.

Sein Problem ist allerdings, daß er nur mittels casting verwendbar ist.

Typisches Beispiel ist die malloc-Funktion:

char *pStr ;

int *pFeld ;

pStr = ( char * ) malloc ( 100 ) ;

pFeld = ( int * ) malloc ( 17 ) ;