8. Referenzen und Zeiger

Transkript

1 8. Referenzen und Zeiger

2 Motivation Variable werden in C++ an speziellen Positionen im Speicher abgelegt. An jeder Position befindet sich 1 Byte. Sie sind durchnummeriert beginnend bei 0. Diese Positionen nennt man auch Adressen Derzeit sind 32-Bit Adressen üblich: Beispiele (hexadezimale Schreibweise): A1F2C73A Diese hexadezimalen Adressen stellen einen besonderen Datentyp dar, der in speziellen Variablen gespeichert wird: Zeigervariable Dr. Norbert Spangler / Grundlagen der Informatik

3 Beispielprogramm void main() { int i=123; // Variable i int *zeiger_i=&i; //Zeigervariable auf i cout<<" i zeiger_i"<<endl; cout<<setw(8)<<i<<" "<<zeiger_i<<endl; cout<<&i<<" "<<&zeiger_i<<endl; } Dr. Norbert Spangler / Grundlagen der Informatik

4 Variable i Übersicht Variable zeiger_i Wert/Inhalt von zeiger_i Wert/Inhalt von i 0012FF Name i Name zeiger_i Adresse der Variablen 0012FF60 Adresse der Variablen 0012FF54 Wert/Inhalt 123 Wert/Inhalt 0012FF Normalerweise spielen die Werte der Adressen keine Rolle Dr. Norbert Spangler / Grundlagen der Informatik

5 Begriffe Zeiger Ein Zeiger(Pointer) ist ein Ausdruck, dessen Wert die Adresse und den Typ eines anderen Objekts darstellt. Adresse Eine Adresse beschreibt die Position eines Bytes im Speicher mit 32 Bits. Sie wird üblicherweise hexadezimal angegeben mit 8 Hexadezimalziffern. Adressoperator & (unärer Operator) Ist x ein Objekt, so bezeichnet &x die (logische) Speicheradresse des Objekts. Die echte physikalische Hauptspeicheradresse wird durch das Betriebssystem ermittelt. Zeigervariable Variablen zur Speicherung von Zeigern sind Zeigervariable (manchmal werden sie auch nur Zeiger/Pointer genannt). Dr. Norbert Spangler / Grundlagen der Informatik

6 8.1 Zeiger Zeiger Ein Zeiger(Pointer) ist ein Ausdruck, dessen Wert die Adresse und den Typ eines anderen Objekts darstellt. Sprechweise: Zeiger auf int oder auch int-zeiger usw. Zum Zeiger gehört also nicht nur die Speicheradresse sondern auch der dazugehörige Typ. Damit kennt man auch die Anzahl der Bytes, welche ein an dieser Adresse gespeichertes Objekt belegt. Zeigervariable Variablen zur Speicherung von Zeigern sind Zeigervariable (manchmal werden sie auch nur Zeiger/Pointer genannt). Die gespeicherten Adressen können geändert werden. Jede Zeigervariable belegt 4 Bytes (=32 Bits) Dr. Norbert Spangler / Grundlagen der Informatik

7 Deklaration Deklaration von Zeigervariablen Zur Deklaration von Zeigervariablen ist in der Typdeklaration ein * vor dem Namen anzugeben. Eine Zeigervariable kann immer nur Adressen von Objekten des eines Typs zeigen. Beispiel: int *zeiger_i;// Typ Zeiger auf int oder auch int* char *temp;//typ Zeiger auf char oder auch char* Folgende Befehle sind damit möglich: int i=0; char c= ; zeiger_i=&i; temp=&c; zeiger_i=&c; //ergibt Fehlermeldung temp=zeiger_i; //ergibt Fehlermeldung Dr. Norbert Spangler / Grundlagen der Informatik

8 Initialisierung Zeigervariable sollten üblicherweise immer initialisiert werden. Beispiel: int i=0, *zeiger_i=&i;//in einer Deklaration moeglich Sind keine sinnvollen Anfangsadressen bekannt, sollten Zeigervariable mit der Speicheradresse 0 belegt werden. Die Verwendung dieser Adressse erzeugt immer eine Fehlermeldung. Anstelle der Ziffer 0 sollte besser die benannte Konstante NULL verwendet werden. char *temp1=null, *temp2=0; Dr. Norbert Spangler / Grundlagen der Informatik

9 Initialisierung # include <iostream> using namespace std; void main() { int *ptr1, *ptr2=null; cout << ptr1 << endl; cout << ptr2 << endl; if ( ptr1==null ) cout << " Zeiger 1 ist NULL" << endl; else cout << " Zeiger 1 ist nicht NULL"<< endl; if ( ptr2==null ) cout << " Zeiger 2 ist NULL"<< endl; else cout << " Zeiger 2 ist nicht NULL"<< endl; } Dr. Norbert Spangler / Grundlagen der Informatik

10 Zugriffe auf Objekte Mittels des Verweisoperators * ist es möglich, das Objekt anzusprechen, auf das ein Zeiger verweist. int i=123, zeiger_i=&i,b; b=*zeiger_i + 7; //entspricht b=i+7; Dann ist *zeiger_i die ganze Zahl 123 und b hat den Wert 130. Der Verweisoperator * hat eine hohe Vorrangstufe. Dr. Norbert Spangler / Grundlagen der Informatik

11 Zusammenfassung Variable Zeigervariable Adresse von i i zeiger_i &i Adresse der Zeigervariablen &zeiger_i (irrelevant) Wert von i *zeiger_i (=123 im Beispiel) Wert von zeiger_i &i Dr. Norbert Spangler / Grundlagen der Informatik

12 Fragen Frage 1: Was ist **zeiger, ***zeiger usw. zeiger *zeiger **zeiger macht nur Sinn, wenn an der Adresse, auf die Zeiger verweist, wieder eine Adresse gespeichert ist usw. -> schwer nachvollziehbar Dr. Norbert Spangler / Grundlagen der Informatik

13 8.2 Rechnen mit Zeigern Ausdruck: zeiger_i + 1 Adresse + 1 ergibt die nächste Adresse Da es sich hier um Adressen von int-objekten handelt ist es die Adresse des nächsten int-objekts (analog für andere Typen), welche damit um 4 höher ist als die in zeiger_i gespeicherte Adresse!!!!! void main() { int i=123,*zeiger_i=&i; cout<<"zeiger_i "<<zeiger_i<<endl; cout<<"zeiger_i+1 "<<zeiger_i+1<<endl; } Dr. Norbert Spangler / Grundlagen der Informatik

14 Rechnen mit Zeigern/Allgemein zeiger + 1 ergibt die nächste Adresse eines Elements vom selben Typ zeiger + 2 analog zeiger + i ergibt mit einem int i das i-te Element vom selben Typ Damit entspricht dies einem Array Der Wert dieses i-ten Elements erhält man mittels *(zeiger+i) Alternative Schreibweise zeiger[i] Dies entspricht einem Array mit dem Namen der Zeigervariablen Umkehrung: Der Name eines Arrays entspricht einer Zeigervariablen, die aber nicht geändert werden kann, also einem const-zeiger. Dr. Norbert Spangler / Grundlagen der Informatik

15 Zeiger und Arrays/Beispiel # include <iostream> using namespace std; void main() { // Deklarationen int j=5,name[10]={9,8,7,6,5,4,3,2,1,0}, *zeiger=&name[0]; cout << "Arrayname " << name << " Zeiger " <<zeiger<< endl; cout << name[j] << " " << *(name+j) << " " << *(zeiger+j) << " " << zeiger[j]<<endl; cout << &name[j] << " " << name+j << " " << zeiger+j << " " << &(zeiger[j]) << endl; } Dr. Norbert Spangler / Grundlagen der Informatik

16 Zeiger und Arrays &name[j] name+j sind gleichwertig (Adressen) name[j] *(name+j) sind gleichwertig (Werte) &zeiger[j] zeiger+j sind gleichwertig (Adressen) zeiger[j] *(zeiger+j) sind gleichwertig (Werte) Dr. Norbert Spangler / Grundlagen der Informatik

17 8.3 Referenzen Eine Referenz ist ein anderer Name (Alias) für ein bereits existierendes Objekt. Damit wird kein neuer Speicherplatz reserviert. Beispiel: int i=123, &k=i; Damit bezeichnen k und i dasselbe Objekt. i 123 k Dr. Norbert Spangler / Grundlagen der Informatik

18 Beispiel void main() { int i=123,&k=i; cout<<k++<<endl<<i<<endl<<&i<<endl<<&k<<endl; } Dr. Norbert Spangler / Grundlagen der Informatik

19 Deklaration Referenzen werden mit dem Zeichen & definiert. Dies ist dem Namen voranzustellen. Beispiel int i=123,&k=i; Allgemeine typ name1, &name2=name1,... Referenzen müssen bei der Definition initialisiert werden. Referenzen sind danach nicht mehr änderbar, zeigen also immer auf denselben Speicherplatz. Im Gegensatz zu Zeigervariablen sind sie damit nicht änderbar. Referenzen werden eigentlich nur bei der Parameterübergabe von Funktionen verwendet, wenn Parameter geändert werden sollen, was bei Call by Value nicht möglich ist Dr. Norbert Spangler / Grundlagen der Informatik

20 Call by Reference: Beispiel // Funktionsaufruf/Variablentausch Referenzparameter #include <iostream> using namespace std; void main() { int a=2,b=3; void tausch (int &,int &); // Parameter jetzt als Referenz cout << " programm anfang a " << a << " b " << b << endl; tausch(a,b); cout << " programm ende a " << a << " b " << b << endl; } void tausch (int &i1,int &i2) // Parameter jetzt als Referenz { int h; cout << " tausch anfang i1 " << i1 << " i2 " << i2 << endl; h=i1; i1=i2; i2=h; cout << " tausch ende i1 " << i1 << " i2 " << i2 << endl; } Dr. Norbert Spangler / Grundlagen der Informatik

21 Call by Reference: Beispiel Die Parameter i1 und i2 werden als Referenz festgelegt, d.h. die lokalen Variablen sind eine Referenz (Aliasname, aber dieselbe Adresse!!!!) zu den Parametern im Aufruf (a,b). Damit werden die Werte an den Adressen des aufrufenden Programmteils vertauscht!!!!! Die lokalen Variablen sind Referenzen der Variablen des aufrufenden Programms. -> Call by Reference Achtung : Ausdrücke/Konstante sind damit auf Parameterposition verboten also tausche (a+3,b) geht dann nicht/macht keinen Sinn; Dr. Norbert Spangler / Grundlagen der Informatik

22 Prototyp Definition Aufruf Referenzen als Parameter von Funktionen typfunktion name(,typparameter&, ); typfunktion name(,typparameter& namep, ) name(,v, ) //mit einer Variablen v Steht auf Parameterposition eine Referenz,so wird diese Variable mit Call by Referenz übergeben. Die lokale Variable in der Funktion wird eine Referenz des aktuellen Parameters. Das Objekt kann damit verändert werden. Call by Reference hat folgende Vorteile Die Parameter werden nicht kopiert -> keine Speicherplatzverdoppelung Es können mehrere Parameter in der Funktion geändert werden, d.h. es kann mehrere Ergebnisse geben. Aber: Ausdrücke auf Parameterposition sind nicht erlaubt. Dr. Norbert Spangler / Grundlagen der Informatik

23 8.4 Verwendung von Zeigern Zeiger werden eingesetzt, um Adressen in Funktionen bekannt machen, damit die dort stehenden Werte geändert werden können (analog zu Call by Reference) Dynamisch neue Objekte in beliebiger Anzahl zu erzeugen. Objekte miteinander zu verlinken Dr. Norbert Spangler / Grundlagen der Informatik

24 Zeiger als Parameter von Funktionen/Beispiel // Funktionsaufruf/Variablentausch - Zeigerparameter #include <iostream> using namespace std; void main() { int a=2,b=3; void tausch (int *,int *); cout << " programm anfang a " << a << " b " << b << endl; tausch(&a,&b);// was ergibt sich bei tausch(a,b) cout << " programm ende a " << a << " b " << b << endl; } void tausch (int *i1,int *i2) { int h=*i1; // Was ergibt sich bei int h=i1? *i1=*i2; *i2=h; } Dr. Norbert Spangler / Grundlagen der Informatik

25 Zeiger als Parameter von Funktionen Es hat geklappt. Dr. Norbert Spangler / Grundlagen der Informatik

26 Prototyp Definition Aufruf Zeiger als Parameter von Funktionen typfunktion name(,typparameter*, ); typfunktion name(,typparameter* namep, ) name(,ptr, ) //mit einer zeigervariablen ptr oder name(,&v, )//mit dem Wert einer Zeigervariablen Steht auf Parameterposition eine Zeigervariable,so wird diese Variable mit Call by Value übergeben.der Wert (=die Adresse eines Objekts in der aufrufenden Funktion) wird in eine lokale Zeigervariable kopiert und ist in der Funktion damit bekannt. Das Objekt kann damit verändert werden.. Dies entspricht im Prinzip genau der Technik Call by Reference. Daher: Als Parameter von Funktionen haben Zeigervariable gegenüber Referenzen keine Vorteile. Dr. Norbert Spangler / Grundlagen der Informatik

27 Dynamische Objekte Bisher mussten Daten vor ihrer Verwendung immer deklariert werden, wobei speziell bei Arrays die Anzahl der Elemente zur Compile-Zeit schon bekannt sein musste (Vorgabe durch Konstanten). Dies ist in der Realität nicht immer durchführbar. Daher gibt es eine Möglichkeit, zur Laufzeit des dynamisch Speicherplatz zu reservieren und auch wieder freizugeben. Hierfür gibt es die Operatoren new und delete. Dr. Norbert Spangler / Grundlagen der Informatik

28 Dynamische Objekte Der Operator new erwartet als Argument den Typ des anzulegenden Objekts und liefert als Ergebnis dessen Adresse: typ1 *name1 = new typ1(anfangswert); //neue Variable typ2 *name2 = new typ2[n]; //Array: n darf eine int-variable sein!! bzw. typ1 *name1; typ2 *name2; name1 = new typ1(anfangswert); //neue Variable name2 = new typ2[n]; //Array: n darf eine int-variable sein!! Damit lassen sich Arrays mit beliebiger Länge erzeugen. Der operator delete löscht mit new angelegte Objekte delete name1; //loescht Variable delete[]name2; //loescht Array Dr. Norbert Spangler / Grundlagen der Informatik

29 Dynamische Objekte/Beispiel int n; double *ptr_d, *ptr_a; ptr_d = new double; cin>>n; ptr_a = new double [n]; cin>>ptr_a[j]; delete ptr_d; delete []ptr_a; 2 Zeiger auf double Eine neue Variable vom Typ double wird erzeugt. Sie hat keinen Namen. Ihre Adresse steht in ptr_d; Eine neues Array vom Typ double wird erzeugt. Es hat n Elemente. Der Name des Arrays ist ptr_a Mit new erzeugte Objekte können mit delete wieder gelöscht werden. Dr. Norbert Spangler / Grundlagen der Informatik

30 Anfangszeiger Adresse 1. Objekt Verlinkung von Objekten Objekt 1 Daten Objekt 1 Adresse nächstes Objekt Daten Objekt 2 Objekt 2 Adresse nächstes Objekt Letztes Objekt Daten letztes Objekt NULL Später genauer bei Strukturen Dr. Norbert Spangler / Grundlagen der Informatik