Pointer. Precompiled Header  Vorübersetzung eingebundener Dateien häufig genutzt, selten geändert  Projekttyp „Win32 Console Application“

Präsentation zum Thema: "Pointer. Precompiled Header  Vorübersetzung eingebundener Dateien häufig genutzt, selten geändert  Projekttyp „Win32 Console Application“"—  Präsentation transkript:

1 Pointer

2 Precompiled Header  Vorübersetzung eingebundener Dateien häufig genutzt, selten geändert  Projekttyp „Win32 Console Application“

3 Precompiled Header  stdafx.h alle include-Dateien des Projektes  stdafx.cpp Vorlage für die vorkompilierte pch-Datei #include "stdafx.h" // Hauptprogramm #include // Weitere includes #include "stdafx.h" // Vorlage für vorkompilierte // Objektdatei main.cpp stdafx.h stdafx.cpp

4 Precompiled Header  #pragma once einmaliges Einbinden der Datei  #define _WIN32_WINNT 0x0501 Verwendung von Funktionen ab bestimmter Windowsversion  #include Ersetzungsdefinitionen für Unicode / ANSI – Funktionen ProjectSettings > General > Character Set  int _tmain(int argc, _TCHAR* argv[]) Einstiegspunkt mit Parametern

5 Headerdatei – Eine Anwendung  Größe der Datentypen maschinenabhängig  typedef: Deklaration eines benutzerdefinierten Synonyms typedef int int32;  Verwendung von int32 äquivalent zu int

6 Aufgabe 5: typedef-header  Erstelle eine Headerdatei, die folgende Datentypen als Synonyme zur Verfügung stellt: int8; uint8; int16; uint16; int32; uint32; int64; uint64 'u' steht für unsigned die Zahl für die Größe des Datentyps in Bit  Benutze die erstellte Headerdatei in einem kleinen Programm, welches die Größe der definierten Datentypsynonyme ausgibt

7 Pointer und Referenzen  Wie „merkt“ sich der Rechner den Inhalt (Wert) einer Variablen Im Speicher abgelegte Variable (z.B. int) Programm „weiß“ beim Zugriff auf die Variable, an welcher Stelle diese im Speicher abgelegt ist Zugriff (lesen / schreiben) auf den Inhalt Interpretation nach Datentyp 1011011000000010000111001001110110110110 00000010 10011101 00011100 … …

8 Pointer und Referenzen  Hinter den Kulissen: Definition einer Variablen Reservieren einer Stelle im Speicher Interne Zuordnung von Variablennamen, Typ und Speicherstelle ev. implizite Initialisierung  Zugriff auf eine Variable Ermitteln der Speicherstelle anhand der Zuordnung Auslesen / Beschreiben der Speicherstelle  Variable verliert Gültigkeit Freigeben der reservierten Speicherstelle

9 Pointer und Referenzen  Ein Pointer ist eine Variable, deren Inhalt eine Speicheradresse ist 1011011000000010000111001001110110110110 0000000000000010 10011101 00011100 … … 1011011000000010000111001001110110110110 00000010 10011101 00011100 … …

10 Pointer und Referenzen  Der Inhalt eines Pointers ist die Startadresse einer anderen Variablen  Die Größe des zu interpretierenden Speicherblockes wird durch den Typen des Pointers bestimmt

11 Die Adresse einer Variablen  Die Adresse einer Variablen gibt die Stelle im Speicher an, in der sie gespeichert ist  Zugriff auf die Adresse über den Adressoperator (&), der direkt vor die Variable geschrieben wird int myVar = 12; cout << "Adresse von myVar: " << &myVar; Ausgabe: Adresse von myVar: 0012FF60

12 Aufgabe 6: Speicheradressen  Erstelle ein einfaches Programm mit 3 Variablen statisches Array vom Typ char mit 5 Feldern int double  Ermittle die Speicheradressen dieser Variablen und gib sie in der Konsole aus

13 Der Adressoperator &  Ermittelt die Adresse einer Variablen  ist kein lvalue &myVar1 = &myVar2; funktioniert NICHT!  Ein lvalue für die Adresse wird benötigt  Pointer!

14 Pointer  Definition mittels * vor demVariablennamen int *myPointer = NULL; der Typ gibt dabei den Typ der Variablen an, auf die der Pointer zeigen soll möglichst mit NULL Initialisieren  Zuweisung der Adresse einer Variablen myPointer = &myVariable dabei muss die Variable den gleichen Typ wie der Pointer haben Inhalt der Variablen myPointer ist die Adresse der Variablen myVariable

15 Pointer int myVar = 14; // normale Variable int *myPointer = NULL; // Variable vom Typ Pointer auf int myPointer = &myVar; cout << "Adresse von myVar: " << &myVar << endl; cout << "Inhalt von myPointer: " << myPointer << endl; Ausgabe: Adresse von myVar: 0012FF60 Inhalt von myPointer: 0012FF60

16 NULL-Pointer  NULL-Pointer bezeichnet einen ungültigen Pointer Pointer verweist auf keine gültige Adresse #define NULL 0  Pointer zeigt bei Definition ohne explizite oder implizite Initialisierung auf zufällige Adresse

17 Änderung von Variablen mittels Pointer  Zugriff auf den Inhalt der Variablen, auf die ein Pointer zeigt mittels * int myVar = 10; int *myPointer = NULL; myPointer = &myVar; *myPointer = 20; cout << "Inhalt, auf den myPointer zeigt: " << *myPointer;

18 Aufgabe 7: Erste Pointer  Lege je 2 Variablen vom Typ int32, bool und double an.  Erstelle für jeden dieser Datentypen einen Pointer  Gib die Adresse und den Inhalt der 6 Variablen in der Konsole aus. Benutze dazu nur die Pointer.  Gib die Adresse und den Inhalt der benutzten Pointer aus

19 Referenzen  Eine Referenz ist eine alternative Zugriffsmöglichkeit auf eine Variable  intern ein Zeiger auf eine Variable  Eine Referenz muss explizit initialisiert werden  keine nachträgliche Zuweisung einer anderen Variable möglich  Operatoren wirken immer auf den Inhalt, der sich hinter einer Referenz verbirgt

20 Referenzen  Definition mittels & vorm Variablennamen int myVar = 10; // normale Variable int &myRef = myVar; // Referenz  beide Variablen zeigen auf die gleiche Stelle im Speicher

21 Referenzen – Warum?  Wenn Referenzen genau das Gleiche machen wie Variablen – wofür braucht man sie dann?  Wir erinnern uns an Funktionen … Parameterübergabe immer call-by-value kein nachhaltiges Ändern des übergebenen Parameters möglich Bei einem Funktionsaufruf wird immer eine Kopie der Variablen angelegt

22 Referenzen als Funktionsparameter  Name des Parameters mit Adressoperator & void myFunction(int &myIntParam)  Keine Inhaltskopie sondern Variable, die auf die gleiche Speicherstelle zeigt  Keine aufwändigeres Kopieren bei größeren Strukturen

23 Konstante Referenzen  Variable soll nicht verändert werden  Übergabe als Referenz um eventuell aufwändiges Kopieren zu vermeiden  Deklaration des Parameters als const void myFunction(const int &myIntParam)

24 Aufgabe 8: Erste Referenzen  Erstelle Funktionen zum Verdoppeln eines 32bit und eines 64bit Integers. Der Rückgabewert (bool) soll über den Erfolg der Operation Auskunft geben.  Erstelle Funktionen zur Ausgabe des Ergebnisses der oben genannten Funktionen  Erstelle ein Programm, welches solange die oben genannten Funktionen aufruft, bis die Verdoppelungsfunktion fehlschlägt.

25 Pointer als Funktionsparameter type myFunction(type *intPointer)  Keine Inhaltskopie sondern Variable, die auf die Speicherstelle zeigt  Keine aufwändigeres Kopieren bei größeren Strukturen  … und wo ist jetzt der Unterschied zu Referenzen?

26 Pointer oder Referenz? void myFunc1(int &myVar); void myFunc2(int *myVar); Aufruf der Funktionen: int i; myFunct1(i); myFunct2(&i);

27 * und &  Bei der Definition int var1 // „normale“ Variable int *var2 // Zeiger auf einen Integer int *var2 = NULL // … incl. Initialisierung (NULL) int *var2 = &var1 // … auf gültige Variable int &var3 = var1 // Referenz auf var1, implizite Initialisierung muss sein  Gleiche Syntax (ohne Initialisierung) im Funktionskopf

28 * und &  Verwendung bei Zuweisung Referenz wie ganz normale Variable! Zugriff auf den Inhalt der Variablen, auf die der Pointer zeigt ○ cout << *var2; // Dereferenzierung über * ○ *var2 = 10; // Auch schreibend möglich Zugriff auf die Adresse der Variablen, auf die der Pointer zeigt ○ cout << var2; // Die Adresse ist der Inhalt des Pointers Zugriff auf Adresse einer normalen Variablen ○ var2 = &var1;

29 Dynamische Speicherverwaltung  Anfordern, Verwalten und Freigeben von Speicher nach Bedarf zur Laufzeit  Spezielle Operatoren in C++ new zur Resservierung des Speichers ○ keine Garantie einer impliziten Initialisierung! delete zur Freigabe des verwendeten Speichers ○ nur auf den BasePointer anwendbar! int32 *dynVar = new int32; delete dynVar;

30 Dynamische Speicherverwaltung  Pointer beliebig oft verwendbar  Speicherreservierung mit expliziter Initialisierung dynVar = new int32(10);  Wenn ein Pointer nicht mehr auf eine gültige Variable zeigt, auf NULL setzen! delete dynVar; dynVar = NULL;