Rzutowanie + Dziedziczenie

 #include <iostream>
using namespace std;

struct figura {
    double pole;
};

struct prostokat : figura {
    double pole;
};

struct romb : figura {
    double pole;
};

struct kwadrat : romb, prostokat {
    double pole;
    double get_pole(){
    
        /* tu jest problem */
        cout << ((figura*)(romb*)this)->pole << endl;
        cout << ((figura*)(prostokat*)this)->pole << endl;
    
        /* to przypisanie tez nie wiadomo czy dziala dobrze */
        ((figura*)(romb*)this)->pole = 30;
        ((figura*)(prostokat*)this)->pole = 35;
        
        /* to wyswietla sie niby poprawnie */
        cout << pole << endl;
        cout << romb::pole << endl;
        cout << prostokat::pole << endl;
        cout << ((figura*)(romb*)this)->pole << endl;
        cout << ((figura*)(prostokat*)this)->pole << endl;
        
        //return pole + romb::pole + prostokat::pole + 
        //((figura*)(romb*)this)->pole + 
        //((figura*)(prostokat*)this)->pole;
    }
};

int main()
{

    kwadrat obj;
    
    obj.pole = 5;
    obj.romb::pole = 10;
    obj.prostokat::pole = 15;
    
    /* to przypisuje wartosci niewiadomogdzie */
    ((figura)(romb)obj).pole = 20;
    ((figura)(prostokat)obj).pole = 25;
    
    /* to wyswietla sie jeszcze poprawnie */
    cout << "kwadrat-pole:" << obj.pole << endl;
    cout << "romb-kwadrat-pole: " << obj.romb::pole << endl;
    cout << "prostokat-kwadrat-pole: " << obj.prostokat::pole << endl;
    cout << "figura-romb-kwadrat-pole: " << ((figura)(romb)obj).pole << endl;
    cout << "figura-prostokat-kwadrat-pole: " << ((figura)(prostokat)obj).pole << endl;
    
    /* tutaj metoda siega na poczatku do dwoch podejrzanych pol z ktorymi jest
    problem */
    obj.get_pole();
       
}

Może mi ktoś wytłumaczyć, skąd rzutowania tego typu:

((figura*)(romb*)this)->pole = 30; ??

Bo nie jestem w stanie tego zrozumieć

Masz wcześniej w dziedziczeniu dla kwadratu dwa różne klasy figura, rzutowanie pozwala na dostanie się do jednej z nich. Poczytaj o dziedziczeniu diamentowym i wirtualnym. Ogólnie kwadrat ma 5 różnych pól o nazwie pole. Jeżeli ten kod ma jakikolwiek inny cel niż pokazanie wielodziedziczenia, to widzę tutaj więcej problemów niż linii kodu.

Taak, to jest program przykładowy, który nawet w owej postaci się nie kompiluje (przez dwie linijki w mainie), ale ogólnie nie ma żadnego sensu.

Czy chodzi o to, że mamy dziedziczenie nie wirutalne, więc tworzą się obiekty:

• figura (dla prostokąt)
• figura (dla romb)
• prostokąt (dla kwadrat)
• romb (dla kwadrat)
• kwadrat?

Tylko w takim razie do którego obiektu odwołuję się przez:

((figura*)(romb*)this)->pole

a do którego przez:

romb::pole ?

EDIT

Jeśli dobrze rozumiem, to "((figura*)(romb*)this)->pole" odwołuje się do "figura (dla romb)" natomiast "romb::pole" do "romb (dla kwadrat)". Dobrze rozumuję?

kwadrat dziedziczy wielokrotnie po romb i prostokat. Zarówno romb jak i prostokat dziedziczy po figura. Tak więc klasa kwadrat będzie miała dwie osobne 'figury', jedną dla 'rombu', drugą dla 'prostokąta'; pole występuje w tej klasie 5 razy:

• this->pole
• ((romb*)this)->pole
• ((prostokat*)this)->pole
• ((figura*)(romb*)this)->pole
• ((figura*)(prostokat*)this)->pole
  Natomiast jeśli by zastosować wspomniany przez Zjarka diament opatrując klasę figura słówkiem virtual (virtual class figura...) wtedy 'kwadrat' będzie posiadać jedną 'figurę' która jednocześnie będzie wspólna i dla 'prostokątu' i dla 'rombu'.