More specifically, I am wondering why we use pointers in a typical linked list implementation. Are there any problems that the following implementation of a Node might cause?
template <typename T>
class Node {
T data;
Node<T>& next;
Node<T>& prev;
};
Is there some reason we should use pointers here instead of references?
You can't set references after creating them, which makes a non-mutable linked-list implementation somewhat tricky. (You'd need to wrap the references in objects that you can re-crate when you want to change the reference).
There's also no way to set a NULL value on a reference, so representing the ends of your list would require some imagination.
Probably better to stick to pointers in a linked list, or even better, use std::list<>.
Lvalue references can't replace pointers; they do different things.
An lvalue reference must be initialized with an lvalue and the lvalue reference will refer to that object for the rest of it's lifetime. It cannot be rebound. This presents two immediate problems for your list node.
How do you start the list? You want to construct a node that has no "previous" yet the prev member must be initialized with a Node object. You could conceivably use a Node whose prev is it self to represent the head of a list, but this is working around the poor choice of lvalue reference. (E.g. Node<T> emptylist = { T(), emptylist, emptylist }; //eurgh)
Second, how do you manipulate the list? You can't change the bindings of next and prev meaning that the only way to alter the list would be to construct a completely new set of nodes and copy every single data element.
int const& cr = 5; int&& rv = 5;