C++：是否必须将策略放入包装器中以避免裸露的新建/删除？

Question

所以我发现了策略的乐趣。

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

class FooStrategy : public Strategy
{
    virtual void action() { /* do some stuff */ };
};

class BarStrategy : public Strategy
{
    virtual void action() { /* do different stuff */ };
};

void computation()
{
    Strategy *strategy;
    if ( /* some decision logic */ )
        strategy = new FooStrategy();
    else
        strategy = new BarStrategy();

    //later on...
    //big loop! don't want any overheads beyond what if/else would give
    for (int i=0;i<100000000;++i)
    {
        //...various other code and then:
        strategy->action();
    }

    //...other code and possibly more strategy->action() calls, then finally:
    delete strategy;
}

所有这些都是为了在每次需要 action() 时用决策逻辑替换 if/else 子句而编写的。我们可以假设它读起来更清楚，因为这就是我们使用它的原因。至于开销，strategy 的虚拟函数表无疑最终会出现在处理器缓存中，因此与 if/else 相比，开销应该很小，对吧？

然而。 C++ 不允许堆栈上的抽象基类，大概是因为它们的大小未知，因此策略必须存在于堆上，从而引入了危险的 new 和 删除 运算符。当然，我可以编写一个包装类来安全地处理策略的创建和删除，并且希望编译器能够完全优化它。但我想知道，如果所有策略都具有相同的大小，是否有一种更优雅的方法将策略放入堆栈中，从而确保自动删除？

编辑感谢大家的回复，我认为他们都非常好，并且对不同的做事方式很有启发。我不会接受任何个人的正确观点。我建议未来的读者考虑所有这些，并慷慨地投票！

Answer 1

为什么不直接使用智能指针呢？

std::auto_ptr<Strategy> strategy;
if ( /* some decision logic */ )
    strategy.reset(new FooStrategy());
else
    strategy.reset(new BarStrategy());

现在您无需删除任何内容。

C++11 还提供 std::unique_ptr 和 std::shared_ptr。此外，Boost 还提供 shared_ptr 以及 boost::scoped_ptr （这比 auto_ptr 更好，因为复制了 auto_ptr code> 可能会导致问题。 scoped_ptr 是不可复制的）。

Answer 2

如果您可以在通话时间决定，您可以使用 templates:

template <typename TPolicyImpl>
void computation()
{
    TPolicyImpl policy;
 ...
}

并像这样调用它：

  computation<FooPolicy>()

Answer 3

您可以按照其他人的建议采用智能指针方式，也可以使用 C 风格的方式：

void fooStrategy() { /* do some stuff */ }

void barStrategy() { /* do other stuff */ }

void computation()
{
    typedef void (*Strategy)();
    Strategy strategy;
    if ( /* some decision logic */ )
        strategy = &fooStrategy;
    else
        strategy = &barStrategy;

    //later on...
    //big loop! don't want any overheads beyond what if/else would give
    for (int i=0;i<100000000;++i)
    {
        //...various other code and then:
        strategy();
    }

    //...other code and possibly more strategy() calls
}

编辑

或者，以同样的思路。只要您的策略是无状态的，为什么不为每个策略拥有一个全局对象 - 那么您就不必担心删除：

class FooStrategy : public Strategy
{
    virtual void action() { /* do some stuff */ };
} FooStrategyObject;

class BarStrategy : public Strategy
{
    virtual void action() { /* do different stuff */ };
} BarStrategyObject;

/* ... */

if ( /* some decision logic */ )
    strategy = &FooStrategyObject;
else
    strategy = &BarStrategyObject;

Answer 4

这就是我要做的：

• 为“Strategy”类和所有其他类创建构造函数 private
• 编写一个工厂函数，该函数返回指向具有引用计数的 Strategy 类的智能指针或所有权语义的转移。这应该包含您的 if 条件。
• 让您的每个 Strategy 子类都将此函数作为 friend。

这样，您将确保您的Strategy对象仅作为智能指针的一部分创建。缺点是您需要将 friend 声明添加到所有当前和未来的 Strategy 子类中。

Answer 5

您可以使用 ScopeGuard 模式的变体：

const Strategy& strategy = FooStrategy();

const 引用（并且必须是 const）可以绑定到临时变量，从而延长临时变量的生命周期。这使您可以安全（高效）地将所有内容放在堆栈上，同时通过其基本类型（作为 const Strategy& ）引用对象。