0

至少可以说，在真正的 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哪个是具体的。数据成员实际上驻留在混凝土内部以进行封装。如何使用接口类遍历数据？

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

4

1 回答 1

1

如果您坚持使用运行时多态迭代器，您将让您的具体迭代器std::list<Car>::iterator在构造函数中使用一对 sprivate并且您将成为您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; }
};

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

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

于 2013-09-19T22:43:53.427 回答