Artikel pedia
| Home | Kontakt | Artikel einreichen | Oberseite 50 artikel | Oberseite 50 autors
 
 


Artikel kategorien
Letztes fugte hinzu
    Ms-access

   Instrumentation + schnittstellen

   Pc tuning - volle kraft voraus für ihr system

   Informatorische grundlagen

   Javascript

   Interne sortieralgorithmen - der kern der sache

   Plotter und sonstige drucker

   Frage 20 (rössl priska)

   Internet - programmierung

   Monitore

   Semesterarbeit und spezialgebiet für informatik

   Erörterungs zum thema

   Inhaltsverzeichnis

   Einführung in die entwicklung ganzheitlicher informationssysteme:

   Titel dokument
alle kategorien




  Zeiger



        C-Maturareferat               Z E I G E R                     von Marcus Konegger       1998/99 © im Mai 1999  Inhaltsverzeichnis   1 Grundlagen 3 1.1 “Normale” Objekte 3 2 Dynamische Datenstrukturen 4 3 “C-typische” Verwendung von Zeigern 4 3.1 VAR-Parameter 4 3.2 Arrays & Zeigerarithmetik in C/C++ 5 3.2.1 Arrays 5 3.

2.2 Zeigerarithmetik 5 3.3 Zeiger auf Zeiger & Zeigerarrays 6 3.3.1 Zeiger auf Zeiger 6 3.3.

2 Zeiger-auf-Zeiger als VAR-Parameter 6 3.3.3 Zeigerarrays 6       Grundlagen  Ein Zeiger (Pointer) ist eine Variable, die als Wert die Adresse einer anderen Variable speichert. In C/C++ ist es möglich, sämtliche Datenstrukturen mit Zeigern zu bearbeiten.   Zeiger können auf   “normale” bzw. dynamische   Objekte verweisen.

Der Unterschied liegt darin, zu welchem Zeitpunkt der benötigte Speicherplatz feststeht. Für normale Variable (int i) wird der Speicherplatz bereits zum Kompilierzeitpunkt festgelegt und reserviert, bei dynamischen Objekten hingegen ist es zum Zeitpunkt der Kompilierung nicht klar, wieviel Speicherplatz benötigt wird, da es höchstwahrscheinlich bei jedem Programmdurchlauf unteschiedlich viel sein wird. Der Speicherplatz wird daher erst zur Laufzeit angefordert und reserviert.   Der Vorteil für dynamische Datenstrukturen sind:   Effizientere und flexiblere Speichernutzung (Aufbau von komplexen Strukturen: Listen, Bäume)   Nachteil:   komplizierte Algorithmen sind erforderlich       “Normale” Objekte   in C/C++ in Pascal   int x; // Def. einer Integer- // Variable   int* pi; // Def. eines Integer- // Zeigers   pi = &x; // Zuweisung: pi // erhält die Adresse // von x   *pi = 30; // Zuweisung: x erhält // den Wert 30  In Pascal sind Deklarationen von Zeigern auf dynamische Objekte nicht möglich Dynamische Datenstrukturen   C C++ Pascal   typedef struct knoten { int iInfo; struct knoten* pNext; } Knot;   // Deklaration Knot* A;   // Anfordern von // Speicherplatz A = (Knot *) malloc (sizeof(Knot));   // Zuweisen von Werten A -> iInfo = 28; A -> pnext = NULL;   // Freigeben des reservierten // Speichers free ( A );     struct knoten { int iInfo; struct knoten* pNext; } Knot;   // Deklaration Knot* A;   // Anfordern von // Speicherplatz A = new Knot;   // Zuweisen von Werten A -> iInfo = 28; A -> pnext = NULL;   // Freigeben des reservierten // Speichers delete A;   Type Reczeiger = ^Prec;   Prec = Record iInfo: integer; pNext: RecZeiger; end;     var A: RecZeiger;       new ( A );     A^.

iInfo := 28; A^.pNext := NIL;       dispose ( A );   Verschiedene Arten von dynamische Datenstrukturen:   einfach verkettete Listen doppelt verkettete Listen geschlossene Listen Binärbäume     “C-typische” Verwendung von Zeigern     VAR-Parameter   Da es in C/C++ keine VAR-Parameter gibt, werden sie durch Zeiger emuliert bzw. realisiert, d.h. soll eine Funktion den Wert eines übergebenen Parameters verändern, so wird dieser Funktion die Adresse der zu ändernden Variable übergeben. In der Funktion wird die Adresse mittels eines Zeigers gespeichert respektive auf den Inhalt der Variable zugegriffen.

  void tausche ( int* zahl1, int* zahl2 ) { int hilfe;   hilfe = *zahl1; *zahl1 = *zahl2; *zahl2 = hilfe; }   void main ( void ) { int a = 3; int b = 17;   tausche ( &a, &b ); }     Arrays & Zeigerarithmetik in C/C++   Arrays   Arrays sind konstante Zeiger auf einen Datenblock im Speicher, d.h. der Zeiger kann nicht verändert werden. Bei der Deklaration von einem Array wird Speicher reserviert.   Beispiele:   float v[3]; // ein Array aus 3 floats v[0]..

.v[2] int a[2][5]; // zwei 5elementige int-Arrays char* vpc[32]; // ein Array aus 32 char-Pointern     Beispiel 2:   void main ( void ) { int feld [20]; // Ein Array mit 20 Integer-Werten wird angelegt int* pI; // Ein Zeiger auf eine Integer-Variable   pI = feld; // pI besitzt die Startadresse des Arrays (1. Element) feld = pI; // Nicht möglich, da sonst die Startadresse des Arrays // verändert werden würde. }   Zeigerarithmetik   Arithmetische Operationen (+, -, ++, --, …) mit Zeigern beziehen sich auf die Größe des Datentyps des Pointers. D.h.




bei der Addition oder Subtraktion zu oder von einem Pointer verweist dieser auf den um die jeweilige Anzahl von Elementen (bei Integer z.B. 2 Bytes) weiter vorne oder hinten liegenden Speicherplatz. Subtrahiert man zwei Pointer von einander, so ergibt diese Berechnung die Anzahl der Elemente, um die der erste Pointer weiter oben im Speicher verweist.   void main ( void ) { int feld [10]; int* pi1; int* pi2; float* pf;   pi1 = feld; // pi1 verweist auf 1. Element im Array ‚feld‘ pi2 = &feld [5]; // pi2 verweist auf 6.

Element im Array ‚feld‘ printf ( ”%d”, pi2-pi1 ); // Ergebnis: 5   ++ pi2; // Erhöhung um 2 Bytes (= sizeof ( int )) ++ pf; // Erhöhung um 4 Bytes (= sizeof ( float )) }     Zeiger auf Zeiger & Zeigerarrays   Zeiger auf Zeiger   Ein Zeiger-auf-Zeiger ist ein Zeiger, dessen Inhalt die Adresse einer anderen Zeigervariablen enthält. Der Zeiger, auf den verwiesen wird, kann “verändert” werden, d.h. auf einen anderen Teil des Speichers versetzt werden. Ein Zeiger-auf-Zeiger wird durch ‚**‘ definiert.   Beispiel:   void main ( void ) { char puffer [10]; char ch; char* z1; char** zz;     z1 = puffer + 1; // z1 zeigt auf das 2.

Zeichen in puffer zz = &z1; // zz zeigt auf den Zeiger z1   strcpy ( puffer, ”ABCDE” );   ch = puffer [3]; // ch enthält das 4. Zeichen von puffer (=‘D‘) ch = *z1; // ch enthält den Inhalt von z1 (=‘B‘) ch = **zz; // ch enthält den Inhalt auf dem Zeiger, auf den // zz zeigt, also z1 (=‘B‘) }     Zeiger-auf-Zeiger als VAR-Parameter   z.B.: long strtol (const char* zeichenkette, const char** endptr, int basis)     Zeigerarrays   Stellt ein Array aus lauter Zeigern dar.   Beispiel:   void main (int argc, char* argv [] ) // oder: int argc, char** argv { printf ( ”Das Programm heißt %s”, *argv ); }  

Suchen artikel im kategorien
Schlüsselwort
  
Kategorien
  
  
   Zusammenfassung Der Vorleser

   sachtextanalyse

   interpretation zwist

   Fabel interpretation

   literarische charakteristik

   interpretation bender heimkehr

   felix lateinbuch

   interpretation der taucher von schiller

   textbeschreibung

   charakterisierung eduard selicke


Anmerkungen:

* Name:

* Email:

URL:


* Diskussion: (NO HTML)




| impressum | datenschutz

© Copyright Artikelpedia.com