Administrace komentářů

Dejme tomu ze mam 2 tridy - A a B. Obe dedi z tridy Base. Nepridavaji zadne promenne, jen predefinuji virtualni funkce.

Program nacita data a vetsinou z nich chce vytvorit tridu B. Obcas ale A a problem je ze tuto informaci se dozvi az pozdeji.

Kdyz se dozvi ze vlastne potrebuje A tak nechci aby musel alokovat novou pamet, ani aby musel zpetne menit pointery ktere uz ukazuji na B.

Začalo to hezky, skoro jako v pohádce: Žily byly dvě sestry, jedna staříkova, druhá stařenčina ...

... ale zápletka na sebe nenechala dlouho čekat. Pokud program chce "většinou" vytvořit třídu B, ale někdy později ji chce vyměnit za A, tak najednou se po nás chce zajistit dynamické chování ve statickém světě dědičnosti tříd. Prostě z jezevčíka mávnutím kouzelné hůlky udělat dobrmana. Vždyť je to přeci také pes. Použití operátoru new s umístěním je ale stejné jako nahánění jezevčíka s chirurgickým skalpelem v ruce.

Když se na to podívám z druhé strany, tak vlastně nepotřebuji předělávat jezevčíka na dobrmana, ale chci jen naučit psa kousat jako dobrman, aby mi nikdo nechodil po dvorku. Pokud nejsem psí zubař, tak mohu tedy skalpel s klidem zahodit .

Na všechno mi stačí jedna hlavní třída a to případné "kousání" si zajistíme až podle situace.

#include <iostream>

enum StrategyType 
{
    A,
    B
};

class Strategy
{
    protected:
        std::string* x;
        int* y;

    public:
        void setOptions(std::string* _x, int* _y) { x = _x; y = _y; }
        virtual void doSomething() = 0;
};

class StrategyA : public Strategy
{
    virtual void doSomething()
    {
        std::cout << "I am 'A'. x = " << *x << ", y = " << *y << std::endl;
    }
};

class StrategyB : public Strategy
{
    virtual void doSomething()
    {
        std::cout << "I am 'B'. x = " << *x << ", y = " << *y << std::endl;
    }
};

class Base 
{
    private:
        std::string x;
        int y;
        Strategy* strategy;

    public:
        Base(std::string x_, int y_): x(x_), y(y_), strategy(NULL) {}
        ~Base() { delete strategy; }

        void doSomething()
        {
            strategy->doSomething();
        }

        void setStrategy(StrategyType type) 
        {
            if (strategy)
                delete strategy;
            if (type == A)
                strategy = new StrategyA();
            else if (type == B)
                strategy = new StrategyB();
            strategy->setOptions(&x, &y);
        }
};

int main()
{
    Base base("life, universe and everything", 42);
    base.setStrategy(B);
    base.doSomething();
    // ...
    base.setStrategy(A);
    base.doSomething();

    return 0;
}

Oproti zadání je možné měnit strategie nejen z B na A, ale i zpět a navíc opakovaně.