Call by Reference Objekt übergeben!

buu2188

Schönen guten Tag
Ich hätte mal eine Frage an Euch, rein zum Verständnis für das weitere lernen.

Wenn ich eine Funktion habe wie folgende:

void CZahl::objectrechnen(CZahl& rechnen)
{
	m_Zahl = rechnen.m_Zahl + 3;
}

Kann ich mir das wie folgt vorstellen, wenn ein Objekt übergeben wird "rechnen" die Adresse des Objektes zugewiesen und dann? Also ich weiß was in der Funktion passiert, nur würde ich mir es gerne vorstellen, kann so am besten lernen wenn ich genau weiß was passiert. Was bedeutet es eigentlich bei dem Parameter "rechnen" mit dem Punkt also:

rechnen >>.<< m_zahl + 3;

Also ich stelle mir es so vor:
Man übergibt der Funktion ein Objekt mit einem Integer.... Die lokale Variable "rechnen" bekommt per Referenz die Adresse des Objektes usw.

Kann mir es auch bei anderen Funktionen nicht so ganz erklären mit den übergebenen Parametern.. Kann mir das eventuell jemand einfach erklären?

MFG

wob

buu2188 schrieb:

void CZahl::objectrechnen(CZahl& rechnen)
{
	m_Zahl = rechnen.m_Zahl + 3;
}
Kann ich mir das wie folgt vorstellen, wenn ein Objekt übergeben wird "rechnen" die Adresse des Objektes zugewiesen und dann?

Als erstes wäre es mal gut, wenn du deine Gedanken in lesbare Sätze verpacken könntest... Ich weiß nicht, was du mit diesem "Satz" sagen willst.

buu2188 schrieb:

Was bedeutet es eigentlich bei dem Parameter "rechnen" mit dem Punkt also:
rechnen >>.<< m_zahl + 3;
Also ich stelle mir es so vor:
Man übergibt der Funktion ein Objekt mit einem Integer.... Die lokale Variable "rechnen" bekommt per Referenz die Adresse des Objektes usw.

Den Punkt kann man sich vielleicht am besten als "+" für ein Offset vorstellen. Wenn du ein struct S { int a; int b; }; hast und eine Variable s vom Typ S (also S s; ), dann bekommst du mit &s die Adresse des Structs. s.a ist dann das erste Element darin (mit Offset 0), während s.b einfach ein paar Bytes weiter im Speicher liegt. (stell dir vor, einfach &s + sizeof(alle vorherigen Variablen) + ggf. irgendwelches Padding, damit die Variables an "guten" Speicheradressen liegen) Der . macht also eine Addition auf die Adresse.

Also angenommen, s liegt an der Speicheradresse 1000, dann liegt s.a ebenfalls an der Adresse 1000 (=1000 + 0) und s.b liegt bei 1004 (=1000 + sizeof(s.a)) (unter der Annahme sizeof(int)=4 ). Also ".a" wäre dann +0 und ".b" wäre dann dasselbe wie "+4".

Wenn du jetzt sowas hast wie struct S {char c[3]; int i;}; , dann kann der Compiler zwischen die Variable c und i auch "Leerraum" (Padding) einfügen. Obwohl sizeof(c[3])=3, kann s.i dann trotzdem auch bei Offset +4 liegen.

In deiner Funktion übergibst du die Adresse auf eine Variable vom Typ CZahl. Stell dir das & in der Variablendeklaration so vor, als würde da ein Pointer stehen, nur dass der Compiler beim Aufruf automatisch das die Adresse nimmt und innerhalb der Funktion automatisch dereferenziert (den * setzt).

"Die lokale Variable "rechnen" bekommt per Referenz die Adresse des Objektes usw."

Was soll das genau bedeuten? -> Die lokale Variable "rechnen" referenziert das übergebene Objekt. Oder: enthält dessen Adresse.

So, diese Beschreibung ist sicher nicht standardkonform, aber vielleicht hilft sie dir trotzdem. Ansonsten schreibe deine Fragen bitte so, dass man sie klar verstehen kann.

buu2188

Vielen vielen Dank schon mal für deine Antwort
Das Problem ist ich weiß nicht wie ich meine Problematik genau definieren kann, ich glaube ich denke einfach zu kompliziert.
Deine Definition mit dem

"."

scheint mir sehr schlüssig zu sein. Aber ich dachte immer mit dem Punkt rufe ich eine Funktion auf wie z.B

"Objekt.Funktion( )".

void CZahl::objectrechnen(CZahl& rechnen)

Kann ich mir das vorstellen wenn ich ein Objekt übergebe zum Beispiel

CZahl eins(1);
eins.objectrechnen(eins);

Das das Objekt "eins" der Referenz Variablen

CZahl& rechnen

"rechnen" übergeben wird ( also die Adresse )?
Also man dann in der Funktion mit der Adresse des Objektes "eins" arbeitet?

Vielen Dank im Voraus

ich glaube ich denke einfach zu kompliziert.

ich glaube, du denkst irgendwie gar nicht...

Aber ich dachte immer mit dem Punkt rufe ich eine Funktion auf wie z.B

Gleiches Prinzip: Klasse.Methode(). Angenommen du arbeitest mit einer Klasse CString und möchtest dich einer Funktion daraus bedienen, wendest du die entsprechende Methode auf deine Variable mit einen "." an.

Kann ich mir das vorstellen wenn ich ein Objekt übergebe zum Beispiel
C++:
CZahl eins(1);
eins.objectrechnen(eins);

Das das Objekt "eins" der Referenz Variablen
Code:
CZahl& rechnen
"rechnen" übergeben wird ( also die Adresse )?
Also man dann in der Funktion mit der Adresse des Objektes "eins" arbeitet?

Finnegan

Vielleicht hilft es deinem Verständnis, wenn du dir Referenzen als Alias vorstellst:

int& die_variable_a = a;

Gibt der Variable a einfach nur den zusätzlichen Namen die_variable_a , mit der man ebenfalls auf sie zugreifen kann.

Bei einem Funktionsaufruf wie deinem

void CZahl::objectrechnen(CZahl& rechnen)
{
   ...
}

eins.objectrechnen(eins);

Bekommt die Variable eins innerhalb der Funktion den zusätzlichen Namen rechnen , der auch nur dort gültig ist.

Spar dir also lieber allzu komplizierte Verständnishilfen mit Adressen und solchem Kram.

daddy_felix

"Referenzen" und "." haben nicht wirklich was miteinander zu tun.

Wenn du ein Objekt hast, dann greifst du mit "." auf Elemente dieses Objektes zu, das gilt für Methoden wie auch für Variablen.