C++ Linked List Iterator Class - c++

Question

I created a singly linked list for a project and now need to create a custom Iterator class. I have a nested class within my Linked List that defines my iterator. I have written most of the class, but am confused as to how to implement some functions. My issues are as follows:
-Please look at my end() function. I set it to the default constructor for the Iterator class, so the
currentNode variable in iterator got defaulted to NULL I guess. Is this correctly implemented?
-How should I overload the -> operator in the Iterator class?
class SSLL_Iter : public std::iterator<std::forward_iterator_tag, T>
{
public:
typedef T value_type;
typedef std::ptrdiff_t difference_type;
typedef T& reference;
typedef T* pointer;
typedef std::forward_iterator_tag iterator_category;
typedef SSLL_Iter self_type;
typedef SSLL_Iter& self_reference;
private:
Node* currentNode;
public:
explicit SSLL_Iter( Node* start = NULL) : currentNode( start ) {} //****************complete
SSLL_Iter( const SSLL_Iter& src ) : currentNode( src.currentNode ) {} //****************complete
reference operator*() const { //****************complete
T& temp = (currentNode->data);
return temp;
}
pointer operator->() const {} //*******??????????????????
self_reference operator=( const SSLL_Iter& src ) { //****************complete
this->here = src.here;
return *this;
}
self_reference operator++() { // preincrement //****************complete
currentNode = currentNode->next;
return *this;
}
self_type operator++(int) { // postincrement //****************complete
self_type temp = (*this);
++(*this);
return temp;
}
bool operator==(const SSLL_Iter& rhs) const { //****************complete
return (this->currentNode == rhs.currentNode);
}
bool operator!=(const SSLL_Iter& rhs) const { //****************complete
return (this->currentNode != rhs.currentNode);
}
}; // end SSLL_Iter
typedef std::size_t size_t;
typedef T value_type;
typedef SSLL_Iter iterator;
//typedef Const_SSL_Iter const_iterator;
SSLL() {}
SSLL(const SSLL& src ) {
for(int i = 0; i < src.size(); ++i) { // populate this SSLL with copies of the other SSLL's contents
this->push_back(src.item_at(i));
}
}
~SSLL() {
if(!is_empty()) {
clear();
}
}
iterator begin() { return SSLL_Iter( head ); }
iterator end() { return SSLL_Iter(); }

Answer 1

return &*(*this); is a decent operator->.
Your SSLL class probably does not have an efficient at, so don't use it in the copy constructor. Instead, create a SSLL template<class Iterator> void append(Iterator s, Iterator f), and implement SSLL(const SSLL& src) in terms of it.
If you have C++11 support, consider replacing the next node of Node with a std::unique_ptr<Node>. Do the same with the pointer-to-first Node in the SSLL root. Now memory management is handled pretty much automatically. You may need a .get() in your iterator after that change. This also eliminates the body of your destructor, makes your move-constructor =default correct (unless you are counting nodes), etc.