C++迭代器和繼承

Question

有什麼是執行下面的迭代器的最好辦法一個簡單的問題：

說我有一個模板化基類「目錄」和兩個子類「ListImpl1」和「ListImpl2」。基類的基本要求是迭代，即我可以這樣做：

for(List<T>::iterator it = list->begin(); it != list->end(); it++){ 
    ... 
} 

我還想允許迭代器除了如：

for(List<T>::iterator it = list->begin()+5; it != list->end(); it++){ 
    ... 
} 

所以問題是，迭代器的實施ListImpl1將不同於ListImpl2。我通過使用包含ListIterator的包裝器來解決這個問題，該包裝器包含一個ListIteratorImpl指針，該指針包含ListIteratorImpl2和ListIteratorImpl2子類，但這一切都變得非常混亂，尤其是當您需要在ListIterator中實現operator +時。

有關更好的設計來解決這些問題的任何想法？

Answer 1

如果你能逃脫使List<T>::iterator非虛，那麼委託的虛擬性關閉添加到列表，使事情變得簡單：

template<typename T> 
class List 
{ 
    virtual void add_assign(iterator& left, int right) = 0; 

public: 
    class iterator 
    { 
     const List* list; 
     const T* item; 
    public: 
     iterator(const List* list, const T* item) : list(list), item(item) {} 

     iterator& operator +=(int right) 
     { 
      list->add_assign(*this, right); 
      return *this; 
     } 
     static iterator operator +(iterator const& left, int right) 
     { 
      iterator result = left; 
      result += right; 
      return result; 
     } 
    }; 

    virtual iterator begin() const = 0; 
    virtual iterator end() const = 0; 
}; 

否則（如果迭代器需要存儲顯著不同的數據，例如） ，那麼你需要做的常規，無聊指針到實現，讓您的虛擬性：

template<typename T> 
class List 
{ 
    class ItImpl 
    { 
     virtual ItImpl* clone() = 0; 
     virtual void increment() = 0; 
     virtual void add(int right) = 0; 
    }; 
public: 
    class iterator 
    { 
     ItImpl* impl; 
    public: 
     // Boring memory management stuff. 
     iterator() : impl() {} 
     iterator(ItImpl* impl) : impl(impl) {} 
     iterator(iterator const& right) : impl(right.impl->clone()) {} 
     ~iterator() { delete impl; } 
     iterator& operator=(iterator const& right) 
     { 
      delete impl; 
      impl = right.impl->clone(); 
      return *this; 
     } 

     // forward operators to virtual calls through impl. 
     iterator& operator+=(int right) 
     { 
      impl->add(right); 
      return *this; 
     } 
     iterator& operator++() 
     { 
      impl->increment(); 
      return *this; 
     } 
    }; 
}; 

template<typename T> 
static List<T>::iterator operator+(List<T>::iterator const& left, int right) 
{ 
    List<T>::iterator result = left; 
    result += right; 
    return result; 
} 

template<typename T> 
class MagicList : public List<T> 
{ 
    class MagicItImpl : public ItImpl 
    { 
     const MagicList* list; 
     const magic* the_magic; 
     // implement ... 
    }; 
public: 
    iterator begin() const { return iterator(new MagicItImpl(this, begin_magic)); } 
    iterator end() const { return iterator(new MagicItImpl(this, end_magic)); } 
}; 

Answer 2

所以問題是， 實施迭代器 ListImpl1的將是該 爲ListImpl2不同。我使用包含一個指向 ListIteratorImpl與子類 ListIteratorImpl2和 ListIteratorImpl2包裝的ListIterator 解決此得到了由 ，但它的所有 變得相當混亂，尤其是當 需要實現運營商+在 的ListIterator。

這種設計很好恕我直言，我看不出什麼雜亂的。除平等和減法，迭代器的操作可以通過虛函數來實現很容易，所以你必須像

class ListIteratorInterface // abstract 
{ 
protected: 
    virtual Data& operator*()=0; 
    // and other operations 
}; 
class ListIteratorA; 
class ListIteratorB; // implementation of the above 
class ListIterator 
{ 
    ListIteratorInterface* impl_; 
public: 
    // when you create this, allocate impl_ on the heap 
    // operations, forward anything to impl_ 
}; 

Answer 3

你可以存儲運營商+作爲基類專用虛擬方法，並有迭代器調用。

或者，您可以考慮靜態多態列表類，而不是運行時多態。

Answer 4

說我有一個模板化基類「目錄」和兩個子類「ListImpl1」和「L istImpl2「

通過在這裏使用繼承你到底得到了什麼？

Answer 5

也有一些是迭代器中很重要的，所謂的迭代器類別：

• InputIterator的
• 輸出迭代
• ForwardIterator
• BidirectionalIterator
• RandomAccessIterator的

每個類別DEF在迭代器中有效支持的一組精確操作。

在這裏，你似乎希望拒絕那個強大的身份識別機制來創建某種混合類別，其中的操作都存在，但不能保證它們的效率。

我認爲你的設計有異味。