222
 
   
   
clemens clemens clemens
Referat

TitelAllgemeines zu Zeigern 
Anzahl Worte800 
SpracheDeutsch 
ArtReferat 
Schlagwortedynamische Objekte; Zeigerarithmetik; void Zeiger; 
Downloads+++++++ 
Bewertung++++ 

Download Zip (3.8kB)
Download Pdf (41.4kB)


Auszug aus dem Referat (ohne Grafiken)

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:



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:


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 ) ;

Ende des Auszuges


Hier hast Du die Möglichkeit dieses Referat zubewerten
und somit die Gesamtbewertung mitzubestimmen!