1

Using template classes I'm trying to implement an iterator class for a custom container based on a linked list. I'm trying to iterate over nodes in my linked list.

My main code is:

#include "Smaph.h"
#include <iostream>
#include <string>
using namespace std;

int main() {
Smaph<string, int> x1;
x1.insert("john", 3);
x1.insert("alex", 5);
cout << "Size is " << x1.size() << endl;
Smaph<string, int>::iterator it;
for (it=x1.begin(); it!=x1.end(); ++it)
    cout << *it << endl;
}

The error happens when the for loop statement is executed, with the call to x1.begin()

The error is in converting the head pointer:

could not convert
((const Smaph<std:basic_string<char>, int>*)this)->
    Smaph<std::basic_string<char>, int>::head
from
    Smaph<std::basic_string<char>, int>::node* const
to
    Smaph<std::basic_string<char>, int>::iterator
    aka sl_iterator<std::basic_string<char>, int>

Following is my single Smaph.h file

template <typename T1, typename T2> class sl_iterator;

template <typename T1, typename T2>
class Smaph
{
public:
    typedef T1 key_type;
    typedef T2 mapped_type;
    typedef unsigned int size_type;
    typedef sl_iterator<T1, T2> iterator;

friend class sl_iterator<T1, T2>;

struct node {
    T1 datum1;
    T2 datum2;
    struct node *next;
};
node *head, *tail;
Smaph() : head(0), tail(0)  { }
~Smaph() { clear(); }

bool insert(const key_type &first, const mapped_type &second) {
    node *p = new node;
    p->datum1 = first;
    p->datum2 = second;
    p->next = 0;
    if (!tail)              // empty list?
        head = p;
    else
        tail->next = p;
    tail = p;
    return (1);     // return true for now
}

size_type size() const {
    int count=0;
    for (node *p = head; p; p=p->next)
        count++;
    return count;
}

void clear() {
    while (head) {
        node *p = head->next;
        delete head;
        head = p;
        }
}

bool empty() const {
    return !head;
}

iterator begin() const {
    return head;
}

iterator end() const {
    return 0;
}
};

template <typename T1, typename T2>
class sl_iterator {
public:
    typedef T1 key_type;
    typedef T2 mapped_type;
    typedef unsigned int size_type;

    struct node {
        T1 datum1;
        T2 datum2;
        struct node *next;
    };

//private:
    node *p;
    // This private ctor is for the container class only:
    sl_iterator(node *ptr) : p(ptr) { }
public:
    sl_iterator() : p(0) { }
    sl_iterator &operator++() {        // Preincrement
        p = p->next;
        return *this;
    }
    sl_iterator operator++(int) {      // Postincrement
        const sl_iterator tmp = *this;
        ++*this;
        return tmp;
    }

    // *sl_iterator: Return a reference to the datum
    T1 &operator*() const {
        return p->datum1;
    }
    // sl_iterator->: Return the address of the datum
    T1 *operator->() const {
        return &p->datum1;
    }

    bool operator==(const sl_iterator &rhs) const {
        return p==rhs.p;
    }
    bool operator!=(const sl_iterator &rhs) const {
        return !(*this == rhs);
    }
}; // end class
4

1 回答 1

1

您似乎希望嵌套类sl_iterator<T1, T2>::node和Smaph<T1, T2>::node编译器将其视为同一类。尽管它们的定义相同，但事实并非如此。

您可能想要更改 的定义sl_iterator，使其不包含 的进一步定义node，而是引用Smaph::node：

template <typename T1, typename T2>
class sl_iterator {
// ...
    typename Smaph<T1, T2>::node *p;
    sl_iterator(typename Smaph<T1, T2>::node *ptr) : p(ptr) { }

// ...
};
于 2013-04-28T16:08:33.607 回答