Frage/n zu Listing 6.9

Werbeanzeige

easyMaxi

Frischling

Beiträge: 72

03.01.2011, 23:37

Frage/n zu Listing 6.9

Hallo

Ich bin nun im Kapitel mit Zeigern und Referenzen angekommen.
Irgendwie ist mir noch nicht ganz der Sinn von Referenzen klar.
Wenn ich doch eine "Kopie" erzeuge und die Weitergebe dann kann ich doch auch das Original weitergeben weil jede Veränderung sich gleich auswirkt. Ein Zeiger zeigt doch auf die Adresse und ist doch immer wenn etwas verändert werden muss dann die beste Lösung oder?!

Nun aber zur eigentlichen Frage:
Es werden in Parameter übergeben mit dem Zusatz const.(bei LadeLevel)
Warum das? Eine Funktion kann doch sowieso nicht einen Parameter ändern. Bzw. schon aber das juckt den echten Parameter ja nicht.

Und was genau mache ich in Listing 6.4.
mit

	C-/C++-Quelltext
1	int *pPunkte = NULL;

soll der Zeiger ja sauber gemacht werden, so das er auf keinen Fall auf irgendwas zeigt.
Aber mit

	C-/C++-Quelltext
1	*pPunkte = 4

füge ich doch einen Wert an den Ort der Adresse ein.
Warum greife ich mal auf den Zeiger zu und mal auf den Ort? Oder habe ich das falsch verstanden?
Adressen bekommt man anscheinend immer mit "&" oder? Also bei Referenzen und *.
Der Syntax ist mir immer nicht ganz so klar (:

Ah tut mir leid das so viele Fragen aufkommen nur ich versuche das ganze im ganzen zu verstehen und das fällt mir nicht immer leicht.

Zum Seitenanfang

n0_0ne

1x Contest-Sieger

Beiträge: 678

04.01.2011, 01:28

Naja, zum einen ist es ja so, dass wenn du eine const referenz als parameter übergibst, diesen parameter dann auch nicht ändern kannst. Referenzen sind nicht wirklich eine Kopie, also nichts eigenständiges, wenn du eine Referenz übergibst an eine funktion, und das objekt da veränderst, verändert es sich auch da, wo du die funktion aufgerufen hast.

Im Gegensatz zu einer Referenz, die du als Kopie verstanden hast, wird aber, wenn du das Original übergibst, wirklich eine Kopie erstellt. Eine Referenz ist in der Hinsicht eher wie ein Zeiger.

Was die Syntax angeht: ja, die ist am Anfang wirklich verwirrend, weil die Zeichen mehrere Bedeutungen haben.

* deklariert zum einen einen Zeiger als solchen, zum anderen ist es aber auch gerade der "Dereferenzierungsoperator" (der aus dem Zeiger wieder ein objekt macht), also das genaue gegenteil.

& deklariert dagegen referenzen, aber gibt dir bei objekten auch deren adresse zurück, was wieder zu den Zeigern gehört.

Meiner Meinung nach, hätte man das in der Syntax irgendwie besser machen können. Aber wenn man genug Erfahrung damit hat, verwechselt man da eigentlich auch nichts mehr.

http://pixelscientists.com

Zum Seitenanfang

SaRu

Alter Hase

Beiträge: 543

04.01.2011, 01:43

N'Abend easyMaxi,

also der Vorteil von Referenzen und Zeigern ist, dass keine Kopie von der Variable (die der Funktion übergeben wird) angelegt werden muss. Das ist nämlich bei dem so genannten call by value der Fall. Zeiger nutzt man meist dann, wenn man innerhalb der Funktion die Variable / das Objekt auf die / das der Zeiger zeigt ändern möchte. Denn Zeiger sind an ihrer Syntax schon leicht zu erkennen. Referzenen benutzt man meist dann, wenn man die Variable / das Objekt nicht verändern (sondern nur den Wert auslesen oder so) möchte, denn bei denen ist die Syntax im Grunde ähnlich der bei Variablen. Hoffe die Ausführung in Kurzform ist verständlich?!

Funktionsparameter bei denen von Anfang an feststeht, dass sie innerhalb einer Funktion nicht geändert werden, werden als konstant deklrariert, damit man sie nicht versehentlich in der Funktion ändert und dann auch innerhalb dieser Funktion eine Variable mit einem falschen Wert vorliegen hat. Solche Fehler sind schwer zu finden, denn das Programm läuft ja in den meisten Fällen ohne Fehler, allerdings ist das Ergebnis ein anderes als man das erwartet.
Ein eher sinnloses, aber einfaches Beispiel:

C-/C++-Quelltext

int Quadrieren(int basis)  // kein konstanter Funktionsparameter
{
    basis += 7;   // irgendwo in der Funktion wird versehentlich der Wert des Parameters geändert
    
    return (basis * basis);
}

int BesserQuadrieren(const int basis)  // hier ein konstanter Funktionsparameter
 {
    basis += 7;   // sowas kann nicht passieren, denn der Funktionsparameter ist konstant
    
    return (basis * basis);
 }

Quadrieren(4);  // Liefert 121 zurück
BesserQuadrieren(4);  // Liefert 16 (richtig) zurück  - bzw. es kommt zu einem Fehler falls man nämlich versucht eine Konstante zu ändern

Zu Listing 6.4:

Dein erste Code-Ausschnitt zeigt die Deklaration (und hier auch gleichzeitige Definition) eines Zeigers. Dabei wird der Stern (*) nicht als Dereferenzierungs-Operator sondern als "Kennzeichnung" für einen Zeiger verwendet. Sonst hätte man ja gar keinen Zeiger sondern nur eine normale Integer-Variable. Beim zweiten Code-Ausschnitt wird der Stern dann aber als solcher Dereferenzierungs-Operator benutzt, man spricht also die Speicherstelle an, auf die der Zeiger zeigt. Die Adresse der Speicherstelle bekäme man dann OHNE den Stern.
Hier ein paar Beispiele:

C-/C++-Quelltext

int *pPunkte;  // Stern als Kennzeichen für einen Zeiger
pPunkte = &Punkte;  // Dem Zeiger wird die Adresse der Variable Punkte zugewiesen
pPunkte // enthält jetzt die Adresse zum Speicherbereich der Variable Punkte
*pPunkte // repräsentiert den Wert der Variable Punkte - also das was an der Speicherstelle wirklich steht
*pPunkte++; // erhöht den Wert der Variable Punkte um 1 - denn der Zeiger zeigt ja auf diese Variable
pPunkte++; // verändert die Adresse auf die der Zeiger zeigt - führt zu einem Fehler, denn jetzt zeigt der Zeiger eben auf eine ganz andere Stelle im Speicher