Optimising a LinkedList data structure - Part 1 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 &lt;vector&gt;
#include &lt;cassert&gt;
template &lt;typename T_&gt;
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_ &amp; d = Object{ }, Node * p = nullptr, Node * n = nullptr )
          : data(d), prev(p), next(n) { }

        Node( T_ &amp;&amp; d, Node * p = nullptr, Node * n = nullptr )
          : data( std::move(d)), prev(p), next(n) { }


        Node( Node &amp;&amp; n ) {        // Rvalue move ctor
            data = std::move(n.data);
            prev = std::move(n.prev);
            next = std::move(n.next);
        }
        Node&amp; operator = ( Node &amp;&amp; n ) { // Rvalue = operator
            data = std::move(n.data);
            prev = std::move(n.prev);
            next = std::move(n.next);
            return *this;
        }
        void swap(Node&amp; rhs) throw ()
        {
            std::swap(prev, rhs.prev); std::swap(next, rhs.next);
        }
    };

public:
    struct LinkedListIterator : public std::iterator&lt;std::forward_iterator_tag, T_, int&gt;
    {
        Node*  _pNode;

        LinkedListIterator(Node* p = nullptr) : _pNode(p) {}


        Node* getNode() { return _pNode; }

        T_ operator * () { return _pNode-&gt;data; }
        LinkedListIterator &amp; operator ++ () { _pNode = _pNode-&gt;next; return *this; } // pre
        LinkedListIterator operator ++ (int) { LinkedListIterator retval = *this; ++*this; return retval; } // post
        bool operator &lt; ( LinkedListIterator const&amp; rhs ) const { return _pNode &lt; rhs._pNode; }
        bool operator != ( LinkedListIterator const&amp; rhs ) const { return _pNode != rhs._pNode; }
        bool operator == ( LinkedListIterator const&amp; rhs ) const { return _pNode == rhs._pNode; }
    };
There are several small things I can see in class Node:


You have a move constructor, but no copy constructor.
You have a move assignment operator, but no copy assignment operator.
Since you use C++11, you should replace the exception specification throw () (now deprecated) by noexcept.
Your move assignment operator is not protected against self-assignment. You should add the condition if (&amp;n != this) { ... }.
Also, if possible, your move constructor and operator= should be noexcept too.
Generally speaking, with move assignment operator, you don't want to move pointers, you only want to swap them since - I believe - your nodes own the pointed values (more information here).

Node&amp; operator=(Node&amp;&amp; n) noexcept {
    if (&amp;n != this) {
        std::swap(data, n.data);
        std::swap(prev, n.prev);
        std::swap(next, n.next);
    }
    return *this;
}