迭代器平等

Question

I'm creating a container class which implements a double linked list.

template <class T>
class dl_list {
public:
    class link {
    public:
        T* data;
        link *prev, *next;
    };
    class iterator {
        link* node;
    public:
        link* get_node() { return node; }
        // ++, --, * operators, etc.
    };
    // other stuff
};

Pretty neat, I'm having fun with it. But one problem I'm having is when I define my equality operators for the iterator type, I have to do a template specialization.

template <class T>
bool operator==(typename dl_list<T>::iterator& lhv, typename dl_list<T>::iterator rhv) {
    return lhv.get_node() == rhv.get_node();
}

will not work, I have to specialize it like so:

bool operator==(typename dl_list<int>::iterator& lhv, typename dl_list<int>::iterator rhv) {
    return lhv.get_node() == rhv.get_node();
}

for every type I want to use it for, which is annoying for obvious reasons. How do I get around this?

Answer 1

Make it a member of the iterator class:

bool operator==( const interator& other ) const
{
    return node == other.node;
}

Answer 2

You can't. The compiler cannot know that some T is a nested type of some other U . Consider

template<> class dl_list<float> {
public:
    typedef dl_list<int>::iterator iterator;
};

You have to take the iterator type directly as the template parameter, or define it as a member of the iterator class, or define the iterator class outside dl_list and simply make a typedef for it inside dl_list.

Answer 3

Easiest cleanest way is to define the operator inside the iterator class:

class iterator
{
  public:
    ...
    friend bool operator==(iterator& lhs, iterator& rhs)
    {
        return lhs.get_node() == rhs.get_node();
    }
};

(Bit of a code smell here - I'd have expected get_node() to have a const version, allowing the operator== to accept parameters by const reference...)