I have implemented a linked list. I feel I overdid it with pointers, used old standards and C++11, and I ended with too many lines of code. I will make my quotations into two parts: one for the Node
and iterator struct and the other for rest of the class.
For node and iterator, how can I optimize for C++11? Can you review it?
#include <vector>
#include <cassert>
template <typename T_>
class LinkedList
{
private:
struct Node
{
T_ data;
Node* prev;
Node* next;
/*Node(T_ D, Node* p = nullptr, Node* n = nullptr) : data(d), prev(p), next(n) {}*/
Node( const T_ & d = Object{ }, Node * p = nullptr, Node * n = nullptr )
: data(d), prev(p), next(n) { }
Node( T_ && d, Node * p = nullptr, Node * n = nullptr )
: data( std::move(d)), prev(p), next(n) { }
Node( Node && n ) { // Rvalue move ctor
data = std::move(n.data);
prev = std::move(n.prev);
next = std::move(n.next);
}
Node& operator = ( Node && n ) { // Rvalue = operator
data = std::move(n.data);
prev = std::move(n.prev);
next = std::move(n.next);
return *this;
}
void swap(Node& rhs) throw ()
{
std::swap(prev, rhs.prev); std::swap(next, rhs.next);
}
};
public:
struct LinkedListIterator : public std::iterator<std::forward_iterator_tag, T_, int>
{
Node* _pNode;
LinkedListIterator(Node* p = nullptr) : _pNode(p) {}
Node* getNode() { return _pNode; }
T_ operator * () { return _pNode->data; }
LinkedListIterator & operator ++ () { _pNode = _pNode->next; return *this; } // pre
LinkedListIterator operator ++ (int) { LinkedListIterator retval = *this; ++*this; return retval; } // post
bool operator < ( LinkedListIterator const& rhs ) const { return _pNode < rhs._pNode; }
bool operator != ( LinkedListIterator const& rhs ) const { return _pNode != rhs._pNode; }
bool operator == ( LinkedListIterator const& rhs ) const { return _pNode == rhs._pNode; }
};