0

我有一个指向可变对象的智能指针容器。我必须编写两个for_each循环，一个用于将对象作为只读数据访问，另一个用于可变数据。编译器告诉我这std::vector< boost::shared_ptr<Object> >不一样std::vector< boost::shared_ptr<const Object> >，注意const.

这是我的示例代码：

#include <vector>
#include "boost/shared_ptr.hpp"
#include <iterator>

class Field_Interface
{ ; };
typedef boost::shared_ptr<Field_Interface> Ptr_Field_Interface;
typedef boost::shared_ptr<const Field_Interface> Ptr_Const_Field_Interface;

struct Field_Iterator
  : std::input_iterator<std::forward_iterator_tag, Ptr_Field_Interface>
{
  // forward iterator methods & operators...
};

struct Const_Field_Iterator
  : std::input_iterator<std::forward_iterator_tag, Ptr_Const_Field_Interface>
{
  // forward iterator methods & operators...
};

struct Field_Functor
{
  virtual void operator()(const Ptr_Field_Interface&) = 0;
  virtual void operator()(const Ptr_Const_Field_Interface&) = 0;
};

class Record;
typedef boost::shared_ptr<Record> Ptr_Record;
typedef boost::shared_ptr<const Record> Ptr_Const_Record;

class Record_Base
{
  protected:
    virtual Field_Iterator beginning_field(void) = 0;
    virtual Field_Iterator ending_field(void) = 0;
    virtual Const_Field_Iterator const_beginning_field(void) = 0;
    virtual Const_Field_Iterator const_ending_field(void) = 0;

    void for_each(Field_Functor * p_functor)
    {
       Field_Iterator iter_begin(beginning_field());
       Field_Iterator iter_end(ending_field());
       for (; iter_begin != iter_end; ++ iter_begin)
       {
         (*p_functor)(*iter_begin);
       }
     }
};

class Record_Derived
{
public:
   typedef std::vector<Ptr_Field_Interface> Field_Container;
   typedef std::vector<Ptr_Record>          Record_Container;
private:
   Field_Container m_fields;
   Record_Container m_subrecords;
};

鉴于上述所有细节，我如何实现Record_Basein的纯抽象方法Record_Derived？

我试过了：

  • 返回m_fields.begin()，
    返回转换错误（不能转换std::vector<...> to Field_Iterator）
  • 返回&m_fields[0]，这是危险的，因为它假设了std::vector.

顺便说一句，我没有使用std::for_each，因为我必须遍历一个字段容器和一个子记录容器。

4

3 回答 3

1

您所做的类似于Composite和Visitor模式。这两种模式很好地融合在一起，所以看起来你走在了正确的轨道上。

要实现复合模式，请分配以下角色（请参阅复合模式 UML 图）：

  • 叶->Field
  • 复合 ->Record
  • Field组件-> and的抽象基类Record（想不出好名字）

在复合类型上调用的组件操作以递归方式传递给所有子项（叶子和其他嵌套的复合类型）。

要实现访问者模式，operator()请在仿函数类中为每个组件子类型（字段和记录）重载。

我建议您获取“四人帮”的设计模式书的副本，它更好地解释了这些概念，并且比我可能做的更详细。

这里有一些示例代码可以激发您的胃口：

#include <iostream>
#include <vector>
#include "boost/shared_ptr.hpp"
#include "boost/foreach.hpp"

class Field;
class Record;

struct Visitor
{
    virtual void operator()(Field& field) = 0;
    virtual void operator()(Record& field) = 0;
};

class Component
{
public:
    virtual bool isLeaf() const {return true;}
    virtual void accept(Visitor& visitor) = 0;
};
typedef boost::shared_ptr<Component> ComponentPtr;

class Field : public Component
{
public:
    explicit Field(int value) : value_(value) {}
    void accept(Visitor& visitor) {visitor(*this);}
    int value() const {return value_;}

private:
    int value_;
};

class Record : public Component
{
public:
    typedef std::vector<ComponentPtr> Children;
    Record(int id) : id_(id) {}
    int id() const {return id_;}
    Children& children() {return children_;}
    const Children& children() const {return children_;}
    bool isLeaf() const {return false;}
    void accept(Visitor& visitor)
    {
        visitor(*this);
        BOOST_FOREACH(ComponentPtr& child, children_)
        {
            child->accept(visitor);
        }
    }

private:
    int id_;
    Children children_;
};
typedef boost::shared_ptr<Record> RecordPtr;

struct OStreamVisitor : public Visitor
{
    OStreamVisitor(std::ostream& out) : out_(out) {}
    void operator()(Field& field) {out_ << "field(" << field.value() << ") ";}
    void operator()(Record& rec) {out_ << "rec(" << rec.id() << ") ";}
    std::ostream& out_;
};

int main()
{
    RecordPtr rec(new Record(2));
        rec->children().push_back(ComponentPtr(new Field(201)));
        rec->children().push_back(ComponentPtr(new Field(202)));
    RecordPtr root(new Record(1));
        root->children().push_back(ComponentPtr(new Field(101)));
        root->children().push_back(rec);

    OStreamVisitor visitor(std::cout);
    root->accept(visitor);
}

在 Record 中，您可能希望提供用于操作/访问子级的方法，而不是返回对底层子级向量的引用。

于 2010-02-13T04:36:16.597 回答
0

当您使用通用容器类型时，我建议不要编写自己的迭代器。当您编写自己的容器时，编写自己的迭代器是有意义的。但是，当您计划编写自定义迭代器时，请查看Boost.Iterator包。

于 2010-02-13T00:50:12.127 回答
0

如果你想对std::vector用户隐藏它及其迭代器，那么你需要提供多态迭代器来配合你的多态RecordBase容器。any_iterator从 Adob​​e ASL 库中查看。这些 链接也可能会有所帮助。

但是，您应该考虑在设计中使用 Composite 和 Visitor 模式，而不是费尽心思。请参阅我的另一个答案。

于 2010-02-13T04:15:40.000 回答