C-Pointer (Zeiger, Adressen) vs. C++ Referenzen

Transkript

1 C-Pointer (Zeiger, Adressen) vs. C++ Referenzen Der Pointer (C/C++): In C/C++ ist der Pointer ein eigener Datentyp, der auf Variablen/Objekte zeigen kann. Indem man den Pointer dereferenziert, gewinnt man das Datenobjekt zurück, auf das der Pointer zeigt. Der Dereferenzierungs-Operator in C/C++ ist der Stern * und wird vor den Pointer geschrieben: Ist p ein Pointer, der auf ein Objekt zeigt, dann ist *p dieses Objekt. Ist x ein Objekt, so ist &x ein Pointer auf dieses Objekt. Definition von Pointern: In C/C++ definiert man den Typ des dereferenzierten Objekts, z.b. int *p; double *r; // definiert p als Pointer auf einen int: (*p) ist ein int // Pointer auf ein double-objekt int n, x[20], *q; // definiert einen int n, ein Array x[20], einen Pointer q In C++ ist es eher üblich, den Pointer als "eigenen Datentyp" zu betrachten und schreibt daher oft: int* p; // p ist int-pointer Da aber C und C++ dieselbe Syntax haben, muss man aufpassen: in C: int *p, n; // p ist int-pointer, n ist int in C++: int* p, n; // p ist int-pointer, n ist int (nicht int*) Achtung: Bei der Definition eines Pointers wird der Speicherplatz für diese Pointer-Variable reserviert. Der Pointer zeigt nach der Definition noch nicht auf irgendein Datenobjekt, auch wird kein Platz für das Datenobjekt selbst reserviert. Pointer auf unterschiedliche Objektklassen sind inkompatibel. p = 1; // p wird auf die Adresse 1 gerichtet; ziemlich sinnfrei *p = 1; // das Objekt, auf das p zeigt, wird auf 1 gesetzt, hier sicher Absturz

2 q = p; r = p; p = &n; // in Ordnung, beides sind Pointer auf int // Warnung: Die Pointer (double*) und (int*) sind inkompatibel // korrekt: p zeigt ab jetzt auf n *p = 5; // ist dasselbe wie: n = 5 p = &x[4]; // p zeigt jetzt auf x[4] *p = -17; // dasselbe wie x[4] = -17 Verwendung von Pointern Abgesehen von obigen eher unsinnigen Anwendungen werden Pointer aus 2 Gründen verwendet: 1) Zur Geschwindigkeitsoptimierung in kritischen Programmteilen 2) Zur Übergabe von Objekten an Funktionen ad 2): Aus folgenden Gründen ist es sinnvoll und oft auch notwendig, statt einer Kopie des Objekts einen Pointer(oder eine Referenz) auf das Objekt zu übergeben: 1) Man kann keine Kopie des Objekts erstellen (z.b. Funktionen). Diese können nur per Pointer (oder per Referenz) übergeben werden. 2) Man will das Objekt in der Funktion ändern. Das geht nur über einen Pointer (call by address). Der Pointer wird als Kopie übergeben (C kann nur Wertübergabe!) 3) Das Kopieren des Objekts benötigt zu viel Zeit oder Speicherplatz und ist unnötig. 4) Es ist wichtig, dass das Objekt nur einmal existiert (z.b. FILE, eine Struktur für die Dateiverwaltung ). In C/C++ können Funktionen die per Kopie übergebenen (call by value) Argumente des Aufrufers nicht ändern. Das funktioniert erst dann, wenn man Pointer auf diese Objekte oder aber "getarnte Pointer = Referenzen" in C++ übergibt. void set5(int n) // total sinnlose Funktion, soll n beim Aufrufer auf 5 setzen, das geht so nicht { n = 5; irgendwo anders im Programm steht: int i = 1; set5(i);

3 Welchen Wert hat die Variable i nach diesen 2 Zeilen? Man stellt fest, dass sie immer noch den Wert 1 hat. Beim Aufruf von set5(i) wird die Variable i kopiert (diese Kopie hat den Anfangswert 1) und diese Kopie wird der Funktion set5 als Argument n übergeben. Diese ändert nun diese Kopie auf 5, aber das Original i wird NICHT verändert. Sollen Funktionen die Original-Aufruf-Parameter ändern, so muss man die Adressen der Objekte oder Referenzen auf die Objekte übergeben. Unser Programm lautet verbessert: void set5(int* p) // p zeigt auf das zu verändernde int-objekt { *p = 5; // verändere das referenzierte Objekt! irgendwo anders im Programm steht: int i = 1; set5(&i); // übergibt den Pointer &i; i hat danach den Wert 5. Die Referenz (nur C++) In C++ gibt es zusätzlich noch die Referenzen. Diese können ähnlich wie Pointer eingesetzt werden, haben aber eine ganz andere Syntax und gehorchen auch anderen Regeln. Eine Referenz ist kein eigener Datentyp sondern ein Alias-Name für das Originalobjekt. Eine Referenz muss immer auf ein existierendes Objekt zeigen und bleibt dauerhaft mit diesem Objekt verbunden! Eine Referenz muss nicht (kann nicht!) dereferenziert werden. int i; int& i2 = i; int* p; int& j; // korrekt: Referenz i2 ist ein Alias für i // korrekt: Pointer p zeigt auf nichts // Fehler: Referenz j zeigt auf nichts i2 = 5; // ändert das Original i (hier steht kein *) p = &i; // richtet p auf i *p = 7; // ändert i (bei Pointern muss hier der * stehen) Mit Referenzen lässt sich das vorige Programm so schreiben: void set5(int& r) // r referenziert das übergebene int-objekt { r = 5; // verändere das referenzierte Objekt! irgendwo anders im Programm steht:

4 int i = 1; set5(i); // i hat danach den Wert 5. Hier darf beim Aufruf kein Adress-Operator stehen Obwohl Referenzen und Pointer eng verwandt sind, gibt es 2 Hauptunterschiede: 1) Eine Referenz zeigt immer auf das Element, auf das sie konstruiert wurde. Ein Pointer kann auch umdefiniert werden und kann dann andere Ziele anvisieren. 2) Eine Referenz muss beim Erstellen auf ein existierendes Objekt verweisen. Ein Pointer kann auch ins Nirvana zeigen (z.b. der Nullpointer, der die Adresse 0 anvisiert). Nullpointer als Ergebnisse werden in C oft auch zur Signalisierung eines Fehlers eingesetzt: if (fopen(filename, "r") == 0) // das Öffnen der Datei hat nicht geklappt. Referenzen lassen sich nicht zu diesem Zweck einsetzen, da das Ziel der Referenz, wie gesagt, immer gültig sein muss: Es gibt keine Null-Referenz! Arrays und Pointer Arrays(Felder) und Pointer sind in C/C++ eng verwandt, genauer gesagt ist ein Array ein nicht-veränderbarer Pointer auf das nullte Array-Element. Genauso kann man Pointer mit Index-Klammern verwenden, als wären sie Arrays. ACHTUNG: Bei der Definition eines Arrays wird Speicherplatz für alle Elemente reserviert. Bei der Definition eines Pointers wird nur der Platz für die Pointervariable selbst reserviert. int some_integers[30], *ip; // int Array der Länge 30 und ein Pointer ip ip = some_integers; ip = &some_integers[0]; // korrekt, ip zeigt auf some_integers[0] // korrekt, ist dasselbe some_integers[5] = ip[10]; // korrekt, ip als array interpretiert some_integers = ip; *ip = *some_integers; // FEHLER: some_integers ist konstanter Pointer // korrekt, interpretiere some_integers als // pointer. *some_integers ist dasselbe wie some_integers[0] ip = some_integers + 2; // korrekt: rechte Seite: Pointer + int gibt Pointer auf // das Arrayelement mit dem Index 2

5 ip = &some_integers[2]; // ist genau dasselbe wie voriges Statement *ip == some_integers[2]; // korrekt und TRUE, da es DIESELBE SPEICHERZELLE ist Innerhalb der Funktion, in der ein Array definiert wurde, ist bekannt, dass es sich um ein Array handelt. Insbesondere ist auch die Dimension bekannt, da dafür eine Konstante verwendet werden muss. Bei der Übergabe eines Arrays an eine Funktion ist in der aufgerufenen Funktion nur mehr der Pointer vorhanden (kein Array und es ist auch die Dimension unbekannt). Arrays zerfallen durch die Übergabe zu reinen Pointern: void print(double v[3]) Obiger Funktionskopf ist legal, aber absolut irreführend. Es handelt sich bei v um ein Argument, das an die Funktion print übergeben wird. Dies ist demnach ein reiner Pointer und die Angabe der Dimension [3] ist unnütz und gefährlich. Es wird suggeriert, dass C/C++ dem eine Bedeutung schenken. Das ist NICHT DER FALL. Diese Funktion wird von C/C++ umgewandelt zu void print(double* v) und sollte auch genauso definiert werden! Deshalb sollte die Dimension zusätzlich übergeben werden: void print(double* v, unsigned dim) // dim: Dimension von v Aber Achtung: double v[3]; Das ist eine Definition eines Objekts und die Dimension ist hier tatsächlich Teil des Objekttyps. Übergibt man ein Array an eine Funktion, so erhält diese nur einen Pointer auf das Startelement. Mit diesem Pointer kann das Originalarray immer verändert werden. Zur Indexüberwachung sollte die Dimension des Arrays als zusätzliches Argument mit übergeben werden. Die C++ Container-Template-Klassen sind keine Arrays und damit auch keine Pointer! Will man sie an Funktionen übergeben und von diesen verändern lassen, muss man sie per Pointer (bitte nicht!!!!) oder viel besser per Referenz übergeben! Da sie ihre Länge kennen, ist kein weiteres Argument nötig.

6 void f1(std::vector<double> x) // erwartet eine vector-kopie, kann Original nicht ändern void f2(std::vector<double>* x) // erwartet einen Pointer auf den vector, kann diesen ändern // z.b. (*x)[5] = 3; // aber bitte nicht das falsche: *x[5] = 3; ) void f1(std::vector<double>& x) // erwartet eine vector-referenz, kann Original ändern (z.b. x[5] = 3; ) Pointer-Arithmetik: Für Pointer sind folgende Rechenoperationen erlaubt: Pointer + Integer, Pointer - Integer, Pointer++, ++Pointer, Pointer--, --Pointer Die Adressen ändern sich immer um Vielfache der Basistyps, d.h. es gilt für jeden Pointer p: p + 1 == &(p[1]); // zeigt auf das Array-Element mit dem Index 1 p + n == &(p[n]); p++; // p zeigt jetzt auf das nächste Objekt in dem Feld Außerdem gibt es die int-differenz: Pointer - Pointer (nur für Pointer auf denselben Typ!) ist der Indexunterschied der Elemente: int feld[10], p = &feld[3], q = &feld[7]; q-p; // hat den Wert 7-3, also 4 p-q; // hat den Wert 3-7, also -4

7 Pointer auf Funktionen Für mathematische Algorithmen ist oft die Übergabe von Funktionen erforderlich z.b. bei der numerischen Differentiation oder Integration: Man möchte gerne die zu differenzierende oder zu integrierende Funktion als Parameter übergeben. Dies lässt sich in C "sehr leicht" durch einen Pointer auf die Funktion erledigen: Ist z.b. die reelle Quadrier-Funktion f(x) in C realisiert als double f(double x) { return x*x; so ist &f ein Pointer auf diese Funktion und kann z.b. an eine Funktion numdiff (die f numerisch an einer Stelle a differenziert) weitergegeben werden. Die einzige Schwierigkeit (aber die ist beachtlich), ist die korrekte Deklaration des Funktionspointer-Parameters &f in numdiff: Diese erwartet also einen Pointer p auf eine Funktion, d.h. (*p) ist diese Funktion. Eine Funktion in C ist etwas, was aufgerufen werden kann, was mit dem Aufrufoperator () geschieht. diese Funktion nimmt ein double-argument entgegen und hat ein double Ergebnis. Damit landet man bei double (*p)(double)für p. double numdiff(double (*p)(double), double a) // p ist Pointer auf Funktion, a die Stelle, an der differenziert werden soll { double h=1e-6; // eine gute Wahl f. h return ( (*p)(a+h) - (*p)(a-h) )/(2*h); // so sieht der Aufruf von *p aus. Beachte die Klammern! In C++ und in C seit C99 werden Funktionen automatisch in Pointer umgewandelt, der Adressoperator darf hier weggelassen werden. Ebenso muss nicht dereferenziert werden. Somit kann man obiges einfacher schreiben als: double numdiff(double f(double), double a) // f ist Pointer auf Funktion, a die Stelle, an der differenziert werden soll { double h=1e-6; // eine gute Wahl f. h return ( f(a+h) - f(a-h) )/(2*h);

8 Pointer auf Pointer und Pointer-Arrays C erlaubt es, Pointer auf Felder, Pointer auf Pointer, Felder von Pointern usw. zu definieren. Ich empfehle hier Klammern zu setzen, wenn man ganz sicher sein will! Manche dieser Konstruktionen sind sinnvoll und werden im Weiteren benötigt. int** p; *p; **p; // ein Pointer auf einen Pointer vom Typ int, wird gebraucht // Pointer auf einen Integer // der Integer char (*p)[20]; // p zeigt auf ein char-feld der Länge 20 char* (p[20]); // Feld von 20 Pointern, die alle auf einen char zeigen // einfach ausgedrückt: Feld von 20 Strings char* p[20]; int* p() // genau dasselbe, wird gebraucht // p ist eine Funktion die einen int-pointer retourniert // dürfte eher selten so gewollt sein int (*p)(); // p ist ein Pointer auf eine Funktion, die einen // int-rückgabewert hat, wird gebraucht int p(); // dasselbe, aber einfacher (in C++ und ab C99) Pointerartige Objekte in C++ C++ kennt zusätzliche Objekttypen, die ähnlich wie Pointer verwendet werden können. Dazu zählen z.b. die Iteratoren der Container-Templates und die Smartpointer von C++ (std::shared_ptr und std::unique_ptr). Diese können immer dereferenziert werden (wie echte Pointer) und gestatten auch weitere Pointeroperationen (je nach Typ): Manche lassen sich inkrementieren und dekrementieren, definieren einen Indexoperator usw. Die klassische for-schleife durch [first, last): for (auto it = first; it!= last; ++it) Tue etwas mit *it: