Question

在真正的C ++应用程序中实现迭代器似乎至少可以说是令人困惑的。我在演示中实现了这个以理解迭代器。

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

第一个问题是具体迭代器应该接收AutoDealer类还是存储汽车的这个类中的实际list？我希望它接受AutoDealer类，因为这样它有类所有权并且一起处理它作为一个独立迭代器的反对，它只对结构的内部部分构成但后来看起来更好？< / p>

第二个问题是因为我使用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。数据成员实际上驻留在混凝土内部以进行封装。如何使用接口类迭代数据？

我的主要目标是在我的应用程序中迭代std::list<Car>。 AutoDealer是否应该承担此责任，或者在主要课程之外进行迭代是否与OOP一致？我的目标是一个良好的面向对象设计，并对设计模式开放。

Answer 1

如果你坚持使用运行时多态迭代器，那么你的具体迭代器需要在std::list<Car>::iterator构造函数中使用一对private，你就可以使AutoDealerImpl成为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创建实际的{{1}}对象应该是微不足道的。

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

谁应该有一个迭代器，我的数据类或该类中的实际列表？

1 个答案: