C++ 装饰器还是抽象基类？两者似乎都不对

我正在编写一个接口，它基本上有两个方法

next

尝试获取下一个值和

prev

返回上一个值

struct foo
{
    virtual boost::optional<int> next() = 0;
    virtual int prev() = 0;
};

然而，它破坏了接口，现在要么要记住调用

abstract\u foo:：next

，要么被迫实现一个相当难看的

do\u next

另一种方法是使用装饰器：

struct foo
{
    virtual boost::optional<int> next() = 0;
    virtual int prev()
    {
        throw not_implemented();
    }
};

struct foo_decorator : public foo
{
    std::unique_ptr<foo> foo_;
    int prev_;

    foo_decorator(std::unique_ptr<foo>&& foo)
        : foo_(std::move(foo))
    {
    }

    boost::optional<int> next()
    {
        boost::optional<int> val = foo_->next_value();
        if(val)
            prev_ = *val;
        return val;
    }

    int prev()
    {
        return prev_;
    }
};

structfoo
{
虚拟boost:：可选的next（）=0；
虚拟整数prev（）
{
抛出未实现（）；
}
};
结构foo_装饰器：public foo
{
std：：唯一的\u ptr foo；
国际货币基金组织；
foo_装饰器（std:：unique_ptr&&foo）
：foo_（std:：move（foo））
{
}
boost:：可选的next（）
{
boost:：可选val=foo_uu->next_uvalue（）；
if（val）
prev_uuz=*val；
返回val；
}
int prev（）
{
返回上一步；
}
};

在这里，

not_implemented

只是在用户认为可以直接从基类使用

prev

时发出尖叫

---

有人对好的设计有好的建议吗？或者我应该简单地使用某种帮助类来帮助在派生类中手动实现它吗？

您的第一个选项实际上接近首选方式，如下所示：

class foo
{
  public:
    boost::optional<int> next()
    {
        boost::optional<int> val = do_next();
        if(val)
            prev_ = val;
        return val;
    }

    int prev()
    {
        return prev_;
    }

  private:
    int prev_;
    virtual boost::optional<int> do_next() = 0;
}; 

class-foo
{
公众：
boost:：可选的next（）
{
boost:：可选val=do_next（）；
if（val）
prev_uuval=val；
返回val；
}
int prev（）
{
返回上一步；
}
私人：
国际货币基金组织；
虚拟boost:：可选的do_next（）=0；
}; 

---

注意

next（）

和

prev（）

是如何非虚拟的，

do_next（）

是如何私有的

在第二个选项中，为什么不在基类中实现prev：

struct foo
{
public:
    virtual boost::optional<int> next() = 0;
    int prev()
    {
        return prev_;
    }
protected:
    int prev_;
};

struct foo_decorator : public foo
{
    std::unique_ptr<foo> foo_;

    foo_decorator(std::unique_ptr<foo>&& foo)
        : foo_(std::move(foo))
    {
    }

    boost::optional<int> next()
    {
        boost::optional<int> val = foo_->next_value();
        if(val)
            prev_ = *val;
        return val;
    }
};

structfoo
{
公众：
虚拟boost:：可选的next（）=0；
int prev（）
{
返回上一步；
}
受保护的：
国际货币基金组织；
};
结构foo_装饰器：public foo
{
std：：唯一的\u ptr foo；
foo_装饰器（std:：unique_ptr&&foo）
：foo_（std:：move（foo））
{
}
boost:：可选的next（）
{
boost:：可选val=foo_uu->next_uvalue（）；
if（val）
prev_uuz=*val；
返回val；
}
};

struct foo
{
public:
    virtual boost::optional<int> next() = 0;
    int prev()
    {
        return prev_;
    }
protected:
    int prev_;
};

struct foo_decorator : public foo
{
    std::unique_ptr<foo> foo_;

    foo_decorator(std::unique_ptr<foo>&& foo)
        : foo_(std::move(foo))
    {
    }

    boost::optional<int> next()
    {
        boost::optional<int> val = foo_->next_value();
        if(val)
            prev_ = *val;
        return val;
    }
};