leider fällt mir kein besserer Betreff ein, vielleicht wurde das auch schon mal gefragt (konnte leider noch nix dazu finden, bitte einfach drauf hinweisen).

Folgendes ist mein Problem:

Ich habe eine Klasse PointC zur Abbildung von Punkten. Neben dem Default-Konstruktor gibt es noch einen mit (int x, int y) zur Initialisierung mit entsprechenden Koordinaten. Nun habe ich eine andere Klasse, deren Objekte eine Referenz auf die Klasse PointC enthalten.
Diese Referenz soll während des Programmverlaufes immer wieder mal auf eine andere Instanz der Punkt-Klasse zeigen (Punkte sind unveränderlich, habe dies aber nicht mit speziellen Konstrukten abgebildet, sondern nur Setter und Getter weggelassen und die Koordinatenvariablen private gemacht).
Damit jeder Punkt immer gültige Werte hat, möchte ich die Referenz der anderen Klasse in der Initialisierungsliste gleich mit dem Konstruktor, welcher die Variablen enthält aufrufen. Das klappt aber leider nicht (eine andere Möglichkeit wäre natürlich, im Default-Konstruktor x und y mit 0 zu initialisieren).

Folgendes hab ich probiert:

OtherClassC::OtherClassC() : myPoint(0,0)

Das mag der GCC leider nicht (kommt wohl mit dem Komma nicht klar). Die Frage ist: Geht so etwas überhaupt? Wenn ja, wie?

Vielen Dank schon mal!

Ciao

Folgendes ist mein Problem:

blah blah blah

warum so viel blah blah statt ein paar Programmzeilen, aus denen man erkennen kann, was du vor hast?

Das mag der GCC leider nicht (kommt wohl mit dem Komma nicht klar).

Fehlermeldungen kann man kopieren und hier einfügen. Zusammen mit dem Programmcode ist dann meistens klar, was nicht geht.

Wenn ich dich richtig verstehe willst du aus einem Objekt auf verschiedene wechselnde existierende Punktobjekte verweisen. Dazu musst du Pointer verenden.

Folgendes hab ich probiert:

OtherClassC::OtherClassC() : myPoint(0,0)

OtherClassC::OtherClassC() : myPoint(0,0) { }
// guckst du -----------------------------^^^

Reth schrieb:

Diese Referenz soll während des Programmverlaufes immer wieder mal auf eine andere Instanz der Punkt-Klasse zeigen (Punkte sind unveränderlich, habe dies aber nicht mit speziellen Konstrukten abgebildet, sondern nur Setter und Getter weggelassen und die Koordinatenvariablen private gemacht).

Du weisst schon dass man Referenzen nicht "umbiegen" kann, ja? Und dass Referenzen in C++ ein Objekt nicht am Leben halten...

hustbaer schrieb:

Du weisst schon dass man Referenzen nicht "umbiegen" kann, ja? Und dass Referenzen in C++ ein Objekt nicht am Leben halten...

Ja, das ist mir bekannt, hab ich aber wohl leider wieder außer 8 gelassen. D.h., eine Referenz würde hier gar nicht funktionieren.

Habe folgendes Problem:
In einer Klasse habe ich als Member eine Referenz auf ein Objekt der Klasse Punkt. Die hab ich gemacht, damit von allen Methoden heraus daruf zugegriffen werden kann.
Nun möchte ich dieser Referenz im Programmverlauf immer wieder ein anderes Objekt vom Typ Punkt zuweisen. Das klappt dann aber wohl nicht, wenn ich Dich und die nachgeschlagenen anderen Quellen zum Thema Referenz richtig verstehe.

Was passiert denn wenn ich sowas machen würde:

// header
class MyClass1
{
    ...
    PointC& point;

    void receivePoint();
    void usePoint();
    ...
}

// impl.; point wurde mit einem Objekt und den Koordinaten 0,0 initialisiert
class MyClass1::receivePoint(const PointC& newPoint)
{
    point = newPoint;
}

Was würde denn dann an der Stelle point = newPoint; genau passieren?
Und wie sollte ich dann das gewünschte Verhalten implementieren? Mir fällt da nur die Nutzung eines Zeigers ein. Allerdings frage ich mich dann schon, wofür Referenzen genutzt werden sollen, außer für CallByReferenzce-Aufrufe (habe natürlich schon über Vorteile und Anwendungsgebiete von Referenzen gelesen, aber für mich bisher nur wenige identifiziert im Vgl. zur Nutzung von Zeigern)?

Danke schon mal!
Ciao

Nun möchte ich dieser Referenz im Programmverlauf immer wieder ein anderes Objekt vom Typ Punkt zuweisen.

Das heißt, du willst einen Zeiger.

Was würde denn dann an der Stelle point = newPoint; genau passieren?

Eine ganz normale Zuweisung. Der Operator MyClass1::operator= wird aufgerufen. Kannst ihn ja mals selbst implementieren und dann ein Breakpoint setzen.

Eine ganz normale Zuweisung. Der Operator MyClass1::operator= wird aufgerufen. Kannst ihn ja mals selbst implementieren und dann ein Breakpoint setzen.

Aber was steht danach denn im LVALUE der Zuweisung? Diese ist zuvor ja die Referenz auf ein Punkt-Objekt und ihr wird ein anderes Punktobjekt zugewiesen.
Welches der beiden Objekte verbirgt sich denn dann hinter der Referenz nach der Zuweisung?

out schrieb:

Eine ganz normale Zuweisung. Der Operator MyClass1::operator= wird aufgerufen. Kannst ihn ja mals selbst implementieren und dann ein Breakpoint setzen.

Aber was steht danach denn im LVALUE der Zuweisung? Diese ist zuvor ja die Referenz auf ein Punkt-Objekt und ihr wird ein anderes Punktobjekt zugewiesen.
Welches der beiden Objekte verbirgt sich denn dann hinter der Referenz nach der Zuweisung?

Ich glaube du hast Referenzen nicht ganz verstanden. Eine Referenz ist nichts anderes als ein alternativer Name (Aliasname) für eine Variable).

int int_variable = 123;
int& schnuckiputz = int_variable;

int der_neue_wert = 987;

Ob du nun int_variable=int der_neue_wert oder schnuckiputz=der_neue_wert schreibst, ist egal. Du hast für eine Variable zwei Namen, int_variable und schnuckiputz . Welchen Namen du nun für die Zuweisung oder für irgendwas anderes nimmst, ist scheiß egal. Logischerweise bedeutet das dann auch, dass eine Referenz kein Objekt ist (also kein Speicherplatz belegt), sondern - wie gesagt - nur ein Kosename ist. Das bedeutet auch, dass du einer Referenz niemals etwas zuweisen kannst, sie somit auch niemals umbiegen kannst.

Ein Zeiger dagegen ist ein Objekt, er benötigt Speicher, z.B. 4Byte oder 8Byte. Darum sagt man auch manchmal Zeigervariable.

Wenn ich das nun richtig verstehe, wird dann bei meiner Zuweisung hier:

point = newPoint;

Der =-Operator der Klasse PointC auf dem Objekt, das sich inter point verbirgt ausgeführt und es werden die Werte aus dem Objekt newPoint zugewiesen.

Sehe ich das so richtig?

Reth schrieb:

Was würde denn dann an der Stelle point = newPoint; genau passieren?

Eine ganz normale Zuweisung. Der Operator MyClass1PointC::operator= wird aufgerufen. Kannst ihn ja mals selbst implementieren und dann ein Breakpoint setzen.

Korrektur

Reth schrieb:

Wenn ich das nun richtig verstehe, wird dann bei meiner Zuweisung hier:

point = newPoint;

Der =-Operator der Klasse PointC auf dem Objekt, das sich inter point verbirgt ausgeführt und es werden die Werte aus dem Objekt newPoint zugewiesen.

Sehe ich das so richtig?

Ja das ist absolut richtig. point.operator=(newPoint); wird gemacht.