c++ - 谁应该拥有迭代器、我的数据类或该类中的实际列表？

Question

至少可以说，在实际 C++ 应用程序中实现迭代器似乎相当令人困惑。我正在演示中实现它以了解迭代器。

我有 AudoDealer 类，它有地址等，而且它有一个实际列表(在我的例子中是 STL::list)，其中包含该经销商的所有汽车。现在我想要一个迭代器，它可以迭代该经销商中的所有汽车。

第一个问题是具体迭代器是否应该接受 AutoDealer类或实际 list在这个类里面存放汽车？我希望它接受 AutoDealer 类，因为这样它有点拥有类的所有权并一起处理它，而不是一个独立的迭代器，它只对结构的内部部分构成但后来看起来更好？

第二个问题是因为我使用 STL 列表类作为我的容器，存储 int currentItem没有意义，但我应该存储 std::list<>iterator遍历。现在我真的不能让这个迭代器类型开始存储!它将打破暴露列表实现的原则。

我的代码在下面，它仍在进行中，但一切都在下面，顺便说一句，我正在阅读四本书。

// IteratorDemo.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <list>

using namespace std;

template <class Object>
class Iterator
{
public:
    virtual Object * first();
    virtual Object * next();
    virtual bool IsDone() const  = 0;
    virtual Object * currentItem() const  = 0;
};


class Car
{
    string make;
    string model;
    string price;
    bool isTruck; // if true is truck, otherwise sedan (assume for this example)
};

//template <class Item>
class AutoDealer
{
public:
    AutoDealer();
    virtual ~AutoDealer();

    // create iterator
    //virtual Iterator<item> * CreateIterator() = 0;



    virtual string GetDealerAddress() 
    { 
        return address;
    };
    virtual void SetDealerAddress(string addr)
    {
        address = addr;
    }
    virtual void SetNumberOfSedans() = 0;
    virtual void SetNumberOfTrucks() = 0;

    virtual Car * GetCar() = 0;
    virtual void AddCar(Car car) = 0;

protected:
    string address;

};

//template <class item>
class AutoDealerImpl : public AutoDealer
{
public:
    AutoDealerImpl()
    {
    }
    virtual ~AutoDealerImpl();

/*  virtual Iterator<item> * CreateIterator()
    {
        return std::list<Car>::iterator;
    }
*/

    virtual void SetNumberOfSedans();
    virtual void SetNumberOfTrucks();

    virtual Car * GetCar();
    virtual void AddCar(Car car)
    {
        carList.push_back( car );
    }

protected:
    std::list<Car> carList; // list implementation


};

template <class Object>
class AutoDealerIterator : public Iterator<Object>
{
public:
    AutoDealerIterator( AutoDealer * theDealer )
    {
//      dealer = theDealer;
    }
    virtual Object * first()
    {
    }
    virtual Object * next();
    virtual bool IsDone() const  = 0;
    virtual Object * currentItem() const  = 0;

protected:
    AutoDealer * dealer;
    int _currentItem; // this is an issue, it should be std::list<car>::iterator type here but how can I access that?
                     // I am not traversing a simple list but an STL list which already
                    // has its own iterator and I need that iterator to travese but how do I access it?

};


int _tmain(int argc, _TCHAR* argv[])
{



}

更新

我从这个演示项目中得到了另一个目标，它可以绕过前面的问题。因为我有 CAutoDealer这只是界面，而不是 AutoDealerImpl这是具体的。数据成员实际上位于具体内部以进行封装。如何使用接口(interface)类遍历数据？

我的主要目标是遍历 std::list<Car>在我的申请中。应该AutoDealer有这个责任还是在主类之外迭代这个符合OOP？我的目标是良好的面向对象设计并接受设计模式。

Answer 1

如果你坚持使用运行时多态迭代器，你会让你的具体迭代器采用一对 std::list<Car>::iterator s 在 private构造函数，然后你会制作你的 AutoDealerImpl你的一个 friend AutoDealerIterator所以它可以构建它们:

class AutoDealerIterator
    : public Iterator<Car>
{
    friend class AutoDealer;
    std::list<Car>::iterator d_begin;
    std::list<Car>::iterator d_it;
    std::list<Car>::iterator d_end;

    AutoDealerIterator(std::list<Car>::iterator begin, std::list<Car>::end)
        : d_begin(begin)
        , d_it(begin)
        , d_end(end)
    {
    }
public:
    Car * first() final { this->d_it = this->d_begin; return this->next(); }
    Car * next() final  { return ++this->d_it == this->d_end? 0: &*this->d_it; }
    bool  IsDone() const final { return this->d_it == this->d_end; }
    Object * currentItem() const final { return &*this->d_it; }
};

创建实际的 AutoDealerIterator来自 AutoDealer 的对象应该是微不足道的。

请注意，使用运行时多态迭代器通常不是一个好主意:它不太有效，而且很可能相对较慢。此外，似乎大多数序列处理实际上都对它正在处理的对象有一个具体的想法。