Vícenásobné zanoření – C / C++ – Fórum – Programujte.com

Ahoj, 

potřeboval bych zodpovědět několik dotazů:

-- je to programátorsky správně takto vytvořený kód? Nebo je to principiálně dobře, ale používat by se to nemělo?

-- je správně napsaný kopírovací konstruktor a operátor přiřazení?

-- jak by mělo probíhat dealokování objektů, až se bude vracet zpět ze zanoření?

o co sem se snažil.

- active state

- return state - actvice state

                     - return state - active state

                                          - return state - atd.

namespace ui
{

enum State
{
    Menu1 = 0,
    Menu2 = 1,
    Menu3 = 2
};

}


struct State
{
    State()
        : activeState(ui::NoState)
        , returnState(0)
    {}

    State(ui::State state)
        : activeState(state)
        , returnState(0)
    {}

    State(ui::State state, ui::State returnState)
        : activeState(state)
        , returnState(new State(returnState))
    {}

    State(ui::State state, State returnState)
        : activeState(state)
        , returnState(new State(returnState))
    {}

    State(const State &state)
        : activeState(state.activeState)
        , returnState(new State)
    {
        returnState = state.returnState;
    }

    State &operator=(const State &other)
    {
        if (this != &other)
        {
            delete returnState;

            returnState = new State;
            returnState = other.returnState;
            activeState = other.activeState;
        }

        return *this;
    }

    ui::State activeState;
    State *returnState;
};

#1 Bobek
uz od oka je to blbe, jelikoz nedodrzujes takzvane "rule of three" respektive "rule of five" - pokud ma objekt netrivialni konstruktor (ovbykle je tim mysleno "neco alokuje"), tak by mel mit taktez destruktor, copy constructor, copy assigment operator (to je to pravidlo tri) a pravidlo peti pak jeste pridava move constructor a move assigment operator.

Jedine co implementujes je ten copy constructor a copy assigment operator (oba blbe). Udelas new a pak ten pointer prepises pointerem z other.returnState misto abys zkopiroval jeho hodnotu na misto, ktere sis udelal pomoci new.

Destruktor si uplne vynechal a bude ti tam unikat pamet (jeste krom toho predchoziho zmineneho)

#2 KIIV

takže opravené řešení je následující. Tohle už by mělo odpovídat "rule of three".

    ~State()
    {
        delete returnState;
    }

    State(const State &state)
        : activeState(state.activeState)
        , returnState(new State)
    {
        returnState->activeState = state.returnState->activeState;
        *returnState->returnState = *state.returnState->returnState;
    }

    State &operator=(const State &other)
    {
        if (this != &other)
        {
            delete returnState;

            activeState = other.activeState;

            returnState = new State;
            returnState->activeState = other.returnState->activeState;
            *returnState->returnState = *other.returnState->returnState;
        }

        return *this;
    }

#3 Bobek
no nejsem si jist co to presne ma delat, ale nebylo by od veci kontrolovat jestli returnState neni NULL + vyuzit ten copy assigment operator: *returnState = *(other.returnState);

U  *returnState->returnState = *other.returnState->returnState;  vlastne delas jen melkou kopii. Ale bez kontroly NULL se to pravdepodobne utopi v nekonecne rekurzi. Plus si nejsem uplne jist prioritama, jestli se pak dereferencuje to co ma (radeji dat extra zavorky nez to mit komplet blbe).
 

#4 KIIV
Ještě než si to napsal sem tam dodělal kontroly ... a doplnil to co píšeš. Podle debuggování se to chová korektně. Tak uvidíme. Děkuji za rady.