C + 11战略模式与国家

时间:2014-04-29 09:35:21

标签: c++ design-patterns c++11

本书中Strategy Pattern的一个例子Head First Design Patterns是用{+ 3}}用C ++编写的。我正在练习根据[here]将其转换为C ++ 11样式,如下所示。

Quack 行为:

struct Quack {
    static void quack()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};

struct MuteQuack {
    static void quack()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};

飞行行为:

struct FlyWithWings {
public:
    static void fly()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};

struct FlyNoWay {
public:
    static void fly()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};

Duck 层次结构:

class Duck
{
public:
    typedef std::function<void(void)> QUACK;
    typedef std::function<void(void)> FLY;

public:
    Duck(const QUACK &q, const FLY &f)
        : m_Quack(q), m_Fly(f) {}

    virtual ~Duck()
    {
    }

    void perform_quack()
    {
        m_Quack();
    }
    void perform_fly()
    {
        m_Fly();
    }

protected:
    QUACK   m_Quack;
    FLY     m_Fly;

private:
    Duck(const Duck&) = delete;
    Duck& operator=(const Duck&) = delete;
};

class MallardDuck
    : public Duck
{
public:
    MallardDuck()
        : Duck(&Quack::quack, &FlyWithWings::fly)
    {
    }
};

class PaintedDuck
    : public Duck
{
public:
    PaintedDuck()
        : Duck(&MuteQuack::quack, &FlyNoWay::fly)
    {
    }
};

到目前为止,客户运作良好。

int main()
{
    MallardDuck x1;
    x1.perform_quack();
    x1.perform_fly();

    PaintedDuck x2;
    x2.perform_quack();
    x2.perform_fly();

    return 0;
}

现在我想扩展到新的RubberDuck类到 Duck 层次结构,而RubberDuck使用具有对象的新的行为FlyWithRocket州。如下:

新的飞行行为:

class FlyWithRocket {
public:
    FlyWithRocket() : m_Energy(3) {}
    void fly()
    {
        if(m_Energy > 0)
        {
            fly_with_rocket();
            --m_Energy;
        }
        else
        {
            fly_out_of_energy();
        }
    }

private:
    void fly_with_rocket()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
    void fly_out_of_energy()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    unsigned int m_Energy;
};

新的 Duck 类型:

class RubberDuck
    : public Duck
{
public:
    RubberDuck()
        : Duck(&MuteQuack::quack, std::bind(&FlyWithRocket::fly, std::ref(m_flyrocket)))
        , m_flyrocket()
    {
    }
private:
    FlyWithRocket m_flyrocket;
};

从现在开始,我想知道成员初始化顺序的规则。基础Duck在成员m_flyrocket之前初始化,但请注意,基本Duck已使用尚未初始化的绑定m_flyrocket进行初始化。 因为我在VS2013中运行它,这在运行时没有错误。

但是代码实际上不安全吗?如果没有,我怎么能修改为更好的设计?

1 个答案:

答案 0 :(得分:7)

这不安全,但除非你从基类构造函数中调用m_Fly(),否则不太可能破坏。

你可以通过以下方式轻松避免这种情况:

  1. 为基类构造函数提供一个虚拟或默认构造的std::function,并在派生类构造函数中将m_Fly重新赋值给绑定函数

    RubberDuck()
        : Duck(&MuteQuack::quack, std::function<void()>())
    {
        m_Fly = std::bind(&FlyWithRocket::fly, std::ref(m_flyrocket));
    }
    
  2. 使FlyWithRocket成为一个仿函数(只需将void fly重命名为void operator())并按值传递而不是保留私有成员(它将归m_Fly所有1}}函数对象,如果需要,可以通过std::function::target<FlyWithRocket>()访问它

    class FlyWithRocket {
    public:
        FlyWithRocket() : m_Energy(3) {}
        void operator() () {
    // ...
    
    RubberDuck()
        : Duck(&MuteQuack::quack, FlyWithRocket()) {}