Я создал простой HashMap (unordered_map) с базовыми реализациями.Теперь я хотел создать простой пользовательский прямой итератор, производный от std :: iterator.Тем не менее, я не могу понять реализацию первого и второго члена итератора, как итератор unordered_map.Может кто-то помочь мне, пожалуйста ?Для простоты предположим, что мой HashMap исправил 10 сегментов и просто использовал простой модуль по модулю, чтобы добраться до индекса, предполагая, что элементы будут целочисленного типа.Ниже приведена реализация моего HashMap и итератора.
#include <iostream>
#include <iterator>
#include <utility>
#include <cassert>
template<typename K, typename V>
class Node
{
public:
K key;
V val;
Node *next;
Node(K k, V v)
{
key = k; val = v; next = nullptr;
}
};
template<typename K, typename V>
class Element
{
public:
int count;
Node<K, V> *head;
Node<K, V> *tail;
Element *next;
Element()
{
count = 0;
head = tail = nullptr;
next = nullptr;
}
};
template<typename K, typename V>
class ForwardIterator : public std::iterator<std::forward_iterator_tag, std::pair<K, V>>
{
Node<K, V> *itr;
Element<K, V> *el;
public:
explicit ForwardIterator(Node<K, V> *i, Element<K, V> *e) : itr(i), el(e) {}
ForwardIterator() : itr(nullptr), el(nullptr) {}
void swap(ForwardIterator& other)
{
std::swap(itr, other.itr);
std::swap(el, other.el);
}
ForwardIterator& operator++()
{
assert(itr != nullptr && "Out of bounds");
if(itr->next == nullptr) // last node in the current index
{
while(el->next != nullptr)
{
el = el->next;
if(el->head != nullptr) // if there is atleast one node at the current index
{
itr = el->head;
break;
}
else
itr = nullptr;
}
}
else
itr = itr->next;
return *this;
}
ForwardIterator operator++(int)
{
assert(itr != nullptr && "Out of bounds");
ForwardIterator tmp(*this);
if(itr->next == nullptr) // last node in the current index
{
while(el->next != nullptr)
{
el = el->next;
if(el->head != nullptr) // if there is atleast one node at the current index
{
itr = el->head;
break;
}
else
itr = nullptr;
}
}
else
itr = itr->next;
return tmp;
}
template<typename key, typename value>
bool operator==(const ForwardIterator<key, value>& rhs) const
{
return itr == rhs.itr && el == rhs.el;
}
template<typename key, typename value>
bool operator!=(const ForwardIterator<key, value>& rhs) const
{
return itr != rhs.itr || el != rhs.el;
}
std::pair<K, V>& operator* () const
{
assert(itr != nullptr && "Out of bounds");
return std::pair<K, V>(itr->key, itr->val);
}
std::pair<K, V>& operator-> () const
{
assert(itr != nullptr && "Out of bounds");
return std::pair<K, V>(itr->key, itr->val);
}
};
template<typename K, typename V>
class MyHashMap
{
private:
Element<K, V>* arr[10];
int size;
public:
typedef ForwardIterator<K, V> myIt;
typedef ForwardIterator<const K, const V> cMyIt;
MyHashMap()
{
size = 0;
arr[0] = new Element<K, V>();
for(int i=1; i<10; ++i)
{
arr[i] = new Element<K, V>();
arr[i-1]->next = arr[i];
}
}
myIt begin()
{
if(size == 0)
{
myIt m(nullptr, nullptr);
return m;
}
else
{
Element<K, V> *temp = arr[0];
while(temp->head == nullptr)
temp = temp->next;
myIt m(temp->head, temp);
return m;
}
}
myIt end()
{
myIt m(nullptr, nullptr);
return m;
}
std::pair<myIt, bool> insert(std::pair<K, V>& p)
{
int index = p.first%10;
if(arr[index]->head == nullptr)
{
arr[index]->head = new Node<K, V>(p.first, p.second);
arr[index]->tail = arr[index]->head;
++(arr[index]->count);
}
else
{
Node<K, V> *temp = new Node<K, V>(p.first, p.second);
arr[index]->tail->next = temp;
arr[index]->tail = temp;
++(arr[index]->count);
}
++size;
myIt m(arr[index]->tail, arr[index]);
return std::pair<myIt, bool>(m, true);
}
myIt find(K k)
{
int index = k%10;
Node<K, V> *temp = arr[index]->head;
while(temp != nullptr)
{
if(temp->key == k)
{
myIt m(temp, arr[index]);
return m;
}
else
temp = temp->next;
}
return end();
}
int remove(K k)
{
int index = k%10;
Node<K, V> *temp = arr[index]->head;
Node<K, V> *t2 = temp;
while(temp != nullptr)
{
if(temp->key == k)
{
if(arr[index]->count == 1)
{
delete temp;
arr[index]->head = arr[index]->tail = nullptr;
}
else if(arr[index]->head == temp)
{
arr[index]->head = arr[index]->head->next;
delete temp;
}
else if(arr[index]->tail == temp)
{
delete temp;
t2->next = nullptr;
arr[index]->tail = t2;
}
else
{
t2->next = temp->next;
delete temp;
}
--(arr[index]->count);
--size;
return 1;
}
else
{
t2 = temp;
temp = temp->next;
}
}
return 0;
}
V &operator[](K k)
{
int index = k%10;
Node<K, V> *temp = arr[index]->head;
while(temp != nullptr)
{
if(temp->key == k)
return temp->value;
else
temp = temp->next;
}
exit(0);
}
};
Теперь ниже мой основной.
int main()
{
MyHashMap<int, int> mhm;
mhm.insert(std::pair<int, int>(1,1));
mhm.insert(std::pair<int, int>(2,2));
MyHashMap<int, int>::myIt it = mhm.begin();
//std::cout << it->first << " " << it->second << std::endl ->this line doesn't compile
}
РЕДАКТИРОВАТЬ: вышеупомянутый фрагмент кода возвращается в исходное состояние, котороебыли проблемы.Вопрос очень четко обозначен ответом @ "r3mus n0x", а также @Evg в комментарии.После внесения изменений, как было предложено, он работает, как и ожидалось.Спасибо всем за помощь.