为什么有人会更喜欢静态策略而不是动态策略？

Question

#include <iostream>

class Strategy
{
public:
    virtual void execute() = 0;
};

class Strategy1 : public Strategy
{
public:

    virtual void execute() override { std::cout << "executed1\n"; }
};

class Strategy2 : public Strategy
{
public:

    virtual void execute() override { std::cout << "executed2\n"; }
};

template <typename S>
class StaticStrategy
{
    S strategy;

public:

    void execute()
    {
        strategy.execute();
    }
};

class DynamicStrategy
{
    Strategy* strategy;

public:

    DynamicStrategy(Strategy* strategy) : strategy(strategy) {}

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

    void setStrategy(Strategy* newStrategy)
    {
        delete strategy;
        strategy = newStrategy;
    }

    ~DynamicStrategy()
    {
        delete strategy;
    }
};

int main()
{
    StaticStrategy<Strategy1> staticStrategy;
    staticStrategy.execute();

    DynamicStrategy dynamicStrategy(new Strategy1{});
    dynamicStrategy.execute();

    dynamicStrategy.setStrategy(new Strategy2{});
    dynamicStrategy.execute();
}

这里是用 C++ 编写的静态和动态策略模式的示例。我想知道为什么有人会使用静态策略而不是动态策略。似乎动态策略可以完成静态策略的所有工作，而且还具有更大的灵活性，因为可以在运行时间更改策略。谁能给我一个静态策略比动态策略更好的例子吗？

Answer 1

静态版本在某些方面更强大且更易于使用。

静态版只要求S有一个成员函数execute，而动态版要求用户继承自Strategy。

静态版本对分配策略或生命周期没有要求，而在代码片段中，动态版本需要堆分配。如果动态版本不取得所有权，则无需分配即可替代动态版本，在这种情况下，客户端必须关注 Strategy 生命周期。

鉴于静态版本，需要堆分配的客户端可以删除策略类型以使用单一策略类型进行堆分配。但是鉴于上面的动态版本，客户端无法撤销堆分配的要求。

静态版本对编译器是完全可见的，此信息可用于优化。动态版本通过 Strategy 基 class 间接访问，因此除非编译器可以证明（或推测）正在使用的具体 Strategy class，否则不会发生内联。

为什么有人会更喜欢静态策略而不是动态策略？

Why would anyone prefer static strategy over the dynamic one?

c++

design-patterns

strategy-pattern