带有迭代器实现的列表 ADT 的 C++ 模板化接口

Question

I'd like to have an interface for the List ADT which provides the user with iterators. Currently I have the following for the iterator:

template <typename D>
class   IIterator
{
    public:
        virtual D           &operator*(void) = 0;
        virtual IIterator   &operator++(void) = 0;
        virtual bool        operator==(const IIterator &rhs)    const = 0;
        virtual bool        operator!=(const IIterator &rhs)    const = 0;
        virtual IIterator   &operator--(void) = 0;
};

And this for the List interface, which uses the iterator interface above:

# include "IIterator.hpp"

template <typename D>
class   IList
{
    public:
        virtual IIterator<D>    begin(void) const = 0;
        virtual IIterator<D>    end(void)   const = 0;
        virtual void            insertFront(const D &e) = 0;
        virtual void            insertBack(const D &e) = 0;
        virtual void            insert(const IIterator<D> &p, const D &e) = 0;
        virtual void            eraseFront(void) = 0;
        virtual void            eraseBack(void) = 0;
        virtual void            erase(const IIterator<D> &p);
};

I can abandon the iterator interface, it's not required by the assignment, but the List has to implement a pure virtual interface. The thing is, if I discard IIterator , I don't know if it's possible to have IList::insert() and IList::erase() in it anymore, since they take not only the template argument but also the Iterator that is to be implemented in the class inheriting the interface.

The following List implementation inherits from IList and uses doubly linked list. It doesn't compile:

template <typename D>
class   NodeList : public IList<D>
{
    private:
        struct  Node
        {
            D       data;
            Node    *prev;
            Node    *next;
        };
    public:
        class   Iterator : public IIterator<D>
        {
            public:
                D           &operator*(void);
                bool        operator==(const IIterator<D> &p)   const;
                bool        operator!=(const IIterator<D> &p)   const;
                Iterator    &operator++(void);
                Iterator    &operator--(void);
            private:
                Iterator(Node *node);
                Node        *_ptr; 
        };
        NodeList(void);
        ~NodeList(void);
        NodeList(const NodeList &copy);
        NodeList            &operator=(const NodeList &rhs);
        int                 size(void)  const;
        bool                empty(void) const;
        IIterator<D>        begin(void) const;
        IIterator<D>        end(void)   const;
        void                insertFront(const D &e);
        void                insertBack(const D &e);
        void                insert(const Iterator &p, const D &e);
        void                eraseFront(void);
        void                eraseBack(void);
        void                erase(const Iterator &p);
    private:
        int                 _n;
        Node                *_header;
        Node                *_trailer;
};

It outputs the following error:

./../../libft/NodeList.hpp:52:11: error: 'NodeList<int>::insert' hides overloaded virtual function [-Werror,-Woverloaded-virtual]
                void                            insert(const Iterator &p, const D &e);
                                                ^
main.cpp:27:17: note: in instantiation of template class 'NodeList<int>' requested here
        NodeList<int>           seq2;
                                ^
./../../libft/IList.hpp:26:18: note: hidden overloaded virtual function 'IList<int>::insert' declared here: type mismatch at 1st parameter
      ('const IIterator<int> &' vs 'const NodeList<int>::Iterator &')
                virtual void                    insert(const IIterator<D> &p, const D &e) = 0;
                                                ^

Doesn't subtype polymorphism let the IList interface know that NodeList<int>::Iterator is IIterator<int> 's subclass therefore the virtual function insert() is not hidden but rather properly overloaded? (the same error is output concerning erase() )

I believe there's a terrible design flaw, could you please tell me what can be replaced, reworked and how else I can achieve the needed result?

Answer 1

There are many issues and caveats with both the general design and code here, but let's focus on the specific question you are asking:

If the base class' method returns a IIterator<D> by value , then that's the only type that subclasses will be allowed to return for their overloads.

You "could" have the base return a pointer to a IIterator<D> , and have the appropriate subclass instantiated in overloads but...

Virtual overloaded operators are a massive pain to deal with, so having a one-size-fit-all type being returned is actually a really good thing if you want to maintain iterators that feel like pointers.

Instead, you should use the pimpl pattern to hide the implementation details of the current class in a member of the iterator, while keeping the iterator a value type.

It would look roughly like this:

template <typename D>
class Iterator
{
public:
    class Impl {
    public:
        virtual D*   get() = 0;
        virtual void inc() = 0;
        virtual void dec() = 0;
    };

    explicit Iterator(std::unique_ptr<Impl> impl) 
        : impl_(std::move(impl)) {}

    D&        operator*() { return *impl_->get(); }
    Iterator& operator++() { impl_->inc(); return *this; }
    Iterator& operator--() { impl_->dec(); return *this; }
        
    bool operator==(const Iterator& rhs) const  {
       return impl_->get() == rhs.impl_->get();
    }

    // Modern C++ (C++-20 and up) synthesizes operator!=() from operator==().

private:
    std::unique_ptr<Impl> impl_;
};

template <typename D>
class NodeList
{
  // ...
private:
    class IteratorImpl : public Iterator<D>::Impl
    {
    public:
        D*   get() override;
        void inc() override;
        void dec() override;
    private:
        Iterator(Node* node);
        Node* _ptr; 
    };

public:
    Iterator<D> begin() const override  {
      return Iterator<D>{std::make_unique<Iterator>(this)};
    }
};