声明迭代功能的界面

Question

我有一个分配，我需要在其中进行linkedlist and traververver的模板类。类遍历的类需要是一个界面，该接口声明某些集合类的索引和迭代功能。我不确定如何为迭代器制作接口，以便linkedlist可以使用它。我在想

template <class T, class U>
class ITraversible {
public:
    virtual U begin() noexcept = 0;
    virtual U end() noexcept = 0;
    virtual T& operator[](int) = 0;
};

，然后在linkedlist标头文件中我要做：

template <class T>
class LinkedList : public ITraversible<T,typename LinkedList<T>::iterator> {
    struct node {
        T data;
        node* next, *prev;
        explicit node(const T&);
        void connect(node*);
    };
    node *head, *tail;
    int n;
public:
    /*************************ITERATOR************************/
    class iterator : public std::iterator<std::bidirectional_iterator_tag, node*> {
        typename LinkedList<T>::node* itr;
        explicit iterator(node*) noexcept;
        friend class LinkedList;
    public:
        iterator& operator++();
        iterator operator++(int);
        iterator& operator--();
        iterator operator--(int);
        bool operator==(const iterator&) const noexcept;
        bool operator!=(const iterator&) const noexcept;
        T& operator*() const noexcept;
        T& operator->() const noexcept;
    };
    /**********************************************************/
    LinkedList() noexcept;
    LinkedList(std::initializer_list<T>);
    LinkedList(const LinkedList&);
    LinkedList(LinkedList&&) noexcept;
    ~LinkedList() noexcept;
    LinkedList& operator=(LinkedList) noexcept;
    template <class A>
    friend void swap(LinkedList<A>&, LinkedList<A>&);
    void add(const T&);
    void removeAt(int);
    int size() const noexcept;
    bool operator==(const LinkedList&) const noexcept;
    bool operator!=(const LinkedList&) const noexcept;
    virtual T& operator[](int) override;
    virtual iterator begin() noexcept override;
    virtual iterator end() noexcept override;
};

但随后可遍历模板具有两个参数，它应该只有一个。这是我应该做的吗？请记住，我是模板和迭代器的新手。

Answer 1

创建接口时，您需要钉住正在返回的内容的静态类型。这些行为可能会动态不同，但是除了使用子类型关系时，您不能更改其他类型。

就个人而言，我认为此练习在C 上下文中不明智。使用Java或C＃时，May May 是有意义的。但是，可以获得类似的行为。绘制的草图将是这样的（尽管这应该有效它会很慢）：

template <typename T>
struct iterator_base {
     virtual iterator_base() {}
     virtual iterator_base<T>* do_clone() = 0;
     virtual T&                do_value() = 0;
     virtual void              do_next()  = 0;
     virtual bool              do_equal() = 0;
     // other operations to implement operator--, operator[], ...
};
template <typename It>
class iterator: iterator_base<typename std::iterator_traits<It>::value_type> {
    typedef typename std::iterator_traits<It>::value_type> type;
    It it;
    iterator_base<type>* do_clone() { return new iterator<It>(*this); }
    type& do_value() { return *this->it; }
    void  do_next()  { ++this->it; }
    bool  do_equal(iterator_base<type>* other) {
        return this->it == static_cast<iterator<It>>(other)->it;
    }
};
template <typename T>
class poly_iterator {
    std::unique_ptr<iterator_base<T>> ptr;
public:
     poly_iterator(iterator_base<T>* ptr): ptr(ptr) {}
     poly_iterator(poly_iterator const& other): ptr(other.ptr->clone()) {}
     poly_iterator& operator= (poly_iterator other) {
         other.swap(this);
         return *this;
     }
     void swap(poly_iterator& other) { swap(this->ptr, other.ptr); }
     T& operator*() { return this->ptr->value(); }
     T* operator->() { return &this->operator*(); }
     poly_iterator& operator++() { this->ptr->next(); return *this; }
     poly_iterator  operator++(int) {
         poly_iterator rc(*this);
         this->operator++();
         return rc;
     }
     bool operator== (poly_iterator const& other) {
         return this->ptr->equal(other.ptr.ptr());
     }
     bool operator!= (poly_iterator const& other) {
         return !(*this == other);
     }
     // other operations
};
// define a suitable specialization of std::iterator_traits<poly_iterator<T>>
template <typename T>
class ITraversible {
    virtual iterator_base<T>* do_begin() = 0;
    virutal iterator_base<T>* do_end()   = 0;
public:
    poly_iterator<T> begin() { return this->do_begin(); }
    poly_iterator<T> end()   { return this->do_end(); }
    // other operations
};
template <typename T>
class List: public ITraversible<T> {
    std::list<T> list;
    iterator_base<T>* do_begin() {
        return iterator<std::list<T>::iterator>(list.begin());
    }
    iterator_base<T>* do_end() {
        return iterator<std::list<T>::iterator>(list.end());
    }
public:
    // whatever is needed to fill the list
};