Allgemeines zu zeigern
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 ( "%d\n" , *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
{
int Info ;
struct knoten *Next ;
} 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 )
{
int Help ;
Help = *A ;
*A = *B ;
*B = Help ;
}
void main ()
{
int x = 44 , y = 17 ;
Tausche ( &x , &y ) ;
// x = 17 , y = 44 ;
}
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 ()
{
int Array[17] ;
int *zArr ;
zArr = Array ; // Möglich, Zeiger zeigt auf erstes Element
Array = zArr ; // Nicht möglich
}
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 ()
{
int iFeld[17] , *piFeld1 , *piFeld2 ;
float *pfFeld ;
piFeld1 = iFeld ;
piFeld2 = &Feld[5] ;
printf ( "%d", piFeld2 - piFeld1 ) ; // Ergebnis: 5
piFeld2 ++ ; // Erhöhung um 2 Bytes ( sizeof ( int ) )
pfFeld ++ ; // Erhöhung um 4 Bytes ( sizeof ( float ) )
}
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 ()
{
char Puffer[10] , ch , *p1 , **pp ;
strcpy ( Puffer , "ABCDEFG" ) ;
p1 = Puffer + 1 ; // p1 zeigt auf 'B' ;
pp = &p1 ; // pp zeigt auf p1
ch = Puffer[3] ; // in ch steht das Zeichen 'D'
ch = *p1 ; // in ch steht Inhalt von p1, also 'B'
Puffer[2] = **pp ; // Im Puffer steht jetzt: ABBDEFG
}
Zeiger als VAR-Parameter:
long strtol ( const char* Kette , const char** EndPtr, int Basis ) ;
// EndPtr zeigt auf erstes fehlerhaftes Zeichen
void main ()
{
char *zKette , *zFehler ;
long Wert ;
strcpy ( zKette , "17C" ) ;
Wert = strtol ( zKette , &zFehler , 10 ) ;
// Wert = 17, zFehler = 'C'
}
Zeiger-Arrays:
void main ( int argc , char *argv[] )
{
printf ( "Name des Programms: %s" , *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 ) ;
| Anmerkungen: |
| impressum | datenschutz
© Copyright Artikelpedia.com
