Startseite   |  Site map   |  A-Z artikel   |  Artikel einreichen   |   Kontakt   |  
  


informatik artikel (Interpretation und charakterisierung)

Allgemeines zu zeigern


1. Java
2. Viren

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

 
 

Datenschutz
Top Themen / Analyse
indicator Die Verantwortung der SQS
indicator THE HISTORY OF THE INTERNET
indicator Einleitung - Endliche Automaten
indicator Windows NT
indicator Software Projektplanung -
indicator Stapelverarbeitungsdateien (Batch-Files)
indicator Digitale Signatur
indicator Der Weg nach vorn, von Bill Gates
indicator Sicherheitsaspekte
indicator PC - Bussysteme


Datenschutz
Zum selben thema
icon Netzwerk
icon Software
icon Entwicklung
icon Windows
icon Programm
icon Unix
icon Games
icon Sicherheit
icon Disk
icon Technologie
icon Bildung
icon Mp3
icon Cd
icon Suche
icon Grafik
icon Zahlung
icon Html
icon Internet
icon Hardware
icon Cpu
icon Firewall
icon Speicher
icon Mail
icon Banking
icon Video
icon Hacker
icon Design
icon Sprache
icon Dvd
icon Drucker
icon Elektronisches
icon Geschichte
icon Fehler
icon Website
icon Linux
icon Computer
A-Z informatik artikel:
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z #

Copyright © 2008 - : ARTIKEL32 | Alle rechte vorbehalten.
Vervielfältigung im Ganzen oder teilweise das Material auf dieser Website gegen das Urheberrecht und wird bestraft, nach dem Gesetz.
dsolution