Anonymní profil Torko – Programujte.com

#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.

#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;
    }

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;
};

Ahoj mám jednu otázku, která mi vrtá hlavou.

Popíšu příklad: 

class A
{
protected:
   virtual void run() = 0;
}

class B : public A
{
   // other methods
}

class C
{
   void run{};
}

void function (B *b)
{
    b->run();
}

int main()
{
   C *c = new B;
   
   function(c);
	
   return 0;
}

jak je možné, že toto zafunguje?

#4 KIIV
Ano tomu příkladu rozumím proč funguje. Teď už rozumím i tomu proč nefunguje moje řešení, děkuji za nakopnutí ...

#2 KIIV
Omluvám se samozřejmě jsou obě deklarovány jako public. Čekal sem spíš konstruktivní odpověď

Ahoj, mám dotaz ohledně jednoduchého dědění. Když bude mít třída předka svoji virtuálni metodu a potomek by chtěl tuto metodu přetížit, ale zároveň by měla instance potomka používat obě tyto metody? Je možné toho nějak docílit aniž by musel potomek přeimplementovat původní metodu? Příklad:

class A 

{

    virtual void start() {

           std::cout << "test start" << std::endl;

    }

}

class B : public A 

{

    void start(int x) {

           std::cout << "test start " << x << std::endl;

    }

}

void main (void)

{

     B *potomek = new B();

     potomek->start();   // tohle nebude ( pokud start nepreimplementuju) fungovat

     potomek->start(2);

}

Očekávám, že potomek získává VTM předka, tak nerozumím proč nevidí metodu start bez parametru? Mohl by mi to nějak někdo vysvětlit. Děkuju