基本 class 参考派生 object - 策略模式

Question

Below is a simple strategy pattern implemented using the base class references to a derived object. The solution does not produce an expected result (12 and 2). When base class reference is switched to pointers, it works. Can someone explain what is happening behind the scenes with references here? The issue is in the setStrategy() method of the Context class. I am wondering why doesn't the strategy variable reference the ConcreteStrategy2 after the call to setStrategy() method?

#include <iostream>


class Strategy {
public:
    virtual ~Strategy() = default;

    virtual int execute(int x, int y) const = 0;
};


class ConcreteStrategy1 : public Strategy {
public:
    int execute(int x, int y) const override
    {
        return x + y;
    }
};


class ConcreteStrategy2 : public Strategy {
public:
    int execute(int x, int y) const override
    {
        return x - y;
    }
};


class Context {
    Strategy &strategy;

public:
    Context(Strategy &strategy) : strategy {strategy}
    {
    }

    void setStrategy(Strategy &strat)
    {
        this->strategy = strat;
    }

    void doLogic() const
    {
        std::cout << strategy.execute(7, 5) << std::endl;
    }
};

int main()
{
    ConcreteStrategy1 strat;
    Context context {strat};
    context.doLogic();

    ConcreteStrategy2 strat2;
    context.setStrategy(strat2);
    context.doLogic();

    return 0;
}

Answer 1

You are trying to reassign a reference, but references cannot be reassigned. It assigns to Strategy object being referred to instead. If you make Strategy non-copyable/assignable that re-assignment through reference will fail to compile.

Use a pointer instead:

class Context {
    Strategy* strategy;
public:
    Context(Strategy &strategy) : strategy {&strategy} {}
    void setStrategy(Strategy &strat) { this->strategy = &strat; }
    void doLogic() const { std::cout << strategy->execute(7, 5) << std::endl; }
};

---

Using reference members is almost always a mistake because it breaks value semantics, as you observe. One can get away with using reference members in non-copyable classes.

Answer 2

Additional solution to Maxim Egorushkins answer.

You could also use std::reference_wrapper instead of a pointer:

class Context {
    std::reference_wrapper<Strategy> strategy;

public:
    Context(Strategy &strategy) : strategy {strategy} { }
    void setStrategy(Strategy &strat) { this->strategy = strat; }
    void doLogic() const { std::cout << strategy.get().execute(7, 5) << std::endl; }
};

Here are both versions next to each other: https://gcc.godbolt.org/z/dveK9T