[C++] Zeiger auf Objekte (?)

[Markus (Gast)]

Hallo,

ich habe folgenden Code gegeben, der die Klassen Bruch und Bruchkopie 
beschreibt:

#include<string>
#include<memory>
#include <iostream>

class Bruch {
public:
    // Kopierkonstruktor
    Bruch(const Bruch& b) : m_zaehler{ b.m_zaehler }, m_nenner{ b.m_nenner } { }
    Bruch() : m_zaehler{ 2 }, m_nenner{ 99 } { }
    Bruch(int z, int n) : m_zaehler{ z }, m_nenner{ n } { }
    int m_zaehler;
    int m_nenner;
};

class BruchKopie {
public:
    Bruch* m_bruch;
    BruchKopie(const Bruch& b) : m_bruch{ new Bruch{ b } } { }
    ~BruchKopie() {
        delete m_bruch;
    }
};

int main() {
    Bruch b1{ 2, 5 };
    b1.m_zaehler = 123;
    std::cout << b1.m_zaehler << std::endl;

    BruchKopie b5{ b1 };

    // hier weitere Anweisungen
}

Warum funktionieren folgende Anweisungen?

    std::cout << (b5.m_bruch)->m_zaehler << std::endl;
    std::cout << b5.m_bruch->m_zaehler << std::endl;
    (b5.m_bruch)->m_zaehler = 77;
    std::cout << (*b5.m_bruch).m_zaehler << std::endl;

b5 ist ein Objekt der Klasse Bruchobjekt und besitzt ein Klassenelement 
namens m_bruch, das einen Zeiger auf eine Bruchklasse beinhaltet.
Daher hätte ich erwartet, daß dieses Klassenelement dereferenziert 
werden muß?

   std::cout << (b5.*m_bruch).m_zaehler;
   std::cout << b5.(*m_bruch).m_zaehler;
   std::cout << b5.*m_bruch.m_zaehler;

Die Anweisungen funktionieren aber nicht (in meiner Verzweiflung habe 
ich alle möglichen Kombinationen durchprobiert, Sternchen hier, 
Sternchen da, bis ich auf etwas funktionierendes traf. Besonders 
zielführend scheint mir das nicht zu sein :-)

[MaWin (Gast)]

Markus schrieb:

> b5 ist ein Objekt der Klasse Bruchobjekt und besitzt ein Klassenelement
> namens m_bruch, das einen Zeiger auf eine Bruchklasse beinhaltet.
> Daher hätte ich erwartet, daß dieses Klassenelement dereferenziert
> werden muß?

Genau das machst du doch.

[code]
std::cout << (*b5.m_bruch).m_zaehler << std::endl;
              DA
[\code]

[Rolf M. (rmagnus)]

Markus schrieb:
> Warum funktionieren folgende Anweisungen?

Weil du in allen vieren genau das tust:

> Daher hätte ich erwartet, daß dieses Klassenelement dereferenziert
> werden muß?

[Markus (Gast)]

Aber b5 ist doch ein 'normales' Objekt, kein Zeiger.
m_bruch ist ein Zeiger.
Warum also nicht b5.*m_bruch.m_zaehler?

[MaWin (Gast)]

Markus schrieb:
> Warum also nicht b5.*m_bruch.m_zaehler?

Weil die Syntax halt so ist in C.

https://en.cppreference.com/w/c/language/operator_precedence

[MaWin (Gast)]

(Gilt natürlich auch für C++)

https://en.cppreference.com/w/cpp/language/operator_precedence

[Volker Z. (vzavza)]

Weil du nicht die Membervariable der Klasse, sondern den gesamten 
Ausdruck (Menbervariable der speziellen Instanz) dereferenzieren willst.

[Yalu X. (yalu) (Moderator)]

Markus schrieb:
> Daher hätte ich erwartet, daß dieses Klassenelement dereferenziert
> werden muß?

Das wird in den Beispielen ja auch getan, in den ersten drei Zeilen mit
"->", in der letzten Zeile mit "*".

>    std::cout << (b5.*m_bruch).m_zaehler;

>    std::cout << b5.*m_bruch.m_zaehler;

Der ".*"-Operator tut etwas anderes, siehe

  https://en.cppreference.com/w/cpp/language/pointer

(Abschnitt "Pointers to members")

>    std::cout << b5.(*m_bruch).m_zaehler;

Diese Zeile ist schon syntaktisch falsch.

[Rolf M. (rmagnus)]

Markus schrieb:
> Aber b5 ist doch ein 'normales' Objekt, kein Zeiger.
> m_bruch ist ein Zeiger.

m_bruch für sich alleine existiert nicht. Der Zeiger heißt b5.m_bruch, 
und den musst du dereferenzieren, was du hier tust:

Markus schrieb:
> std::cout << (b5.m_bruch)->m_zaehler << std::endl;

Die Klammern kann man dabei weglassen, da . und -> von links nach rechts 
ausgewertet wird, daher funktioniert auch:

> std::cout << b5.m_bruch->m_zaehler << std::endl;

Und das hier ist die etwas umständliche Form des voherigen:

> std::cout << (*b5.m_bruch).m_zaehler << std::endl;

Das funktioniert, weil a->b einfach nur eine Kurzform von (*a).b ist. Da 
der Operator . stärker bindet als * (siehe Operatorrangfolge), wird hier 
nicht b5, sondern b5.m_bruch dereferenziert.

> Warum also nicht b5.*m_bruch.m_zaehler?

Weil .* ein ganz anderer Operator ist. Und b5.(*m_bruch) funktioniert 
nicht. Da müsste ja zuerst ein freistehendes m_bruch dereferenziert 
werden und b5.<das Ergebnis davon> gemacht werden, was nicht dem 
entspricht, was du willst und außerdem in C++ gar nicht möglich ist.

[Markus (Gast)]

Rolf M. schrieb:
> m_bruch für sich alleine existiert nicht. Der Zeiger heißt b5.m_bruch,
> und den musst du dereferenzieren, was du hier tust:

Ah, okay.
Ich verstehe zwar nicht warum, werde es aber bei obengenannten 
cppreference.com nochmal nachlesen.
Vielen Dank vorerst.

[db8fs (Gast)]

Markus schrieb:
> Ich verstehe zwar nicht warum, werde es aber bei obengenannten
> cppreference.com nochmal nachlesen.

Ganz einfach, weil du eine Objektinstanz brauchst - ohne die existieren 
Membervariablen nicht. Ist ja der Zweck von deinem Konstruktor, eben 
diese zu initialisieren.

Kannste dir doch mit verschachtelten structs herleiten das ganze:

struct A
{
  struct B 
  {
     int tolleZahl;
     std::string tollerString;
  } myMember;
};

//...
int main()
{
  A a;
  a.myMember.tolleZahl = 3;
}

Guck's dir am besten im Debugger an, da kannste auch Pointer-Ausdrücke 
ausprobieren.

Allerdings noch am Rand, ich würd abraten davon, bei Klassen Zuweisungen 
zu machen, die tief verschachtelte innere Membervariablen ändern. Ist 
zwar so eine Unart auch bei Java und C#, aber in C++ ne blöde Idee. 
Stichwort Law-of-Demeter.