Move constructor implementation in linked list - c++

Question

I have the following List class that's supposed to hold a linked list. I'm experimenting and trying to learn more about move semantics.
I was wondering if I have implemented the move constructor and assignment operator properly.
What I want to achieve at the end, is have all contents emptied from an object to another.
template<typename T>
class List
{
public:
class Node {
public:
Node(T value, Node* prev, Node* next) : value_(value), prev_(prev), next_(next) {}
T value_;
Node* next_;
Node* prev_;
};
Node* head_;
Node* tail_;
//! Move constructor
List(List&& list) {
std::swap(head_, list.head_);
std::swap(tail_, list.tail_);
}
//! Move assignment operator
List& operator= (List&& list) {
std::swap(head_, list.head_);
std::swap(tail_, list.tail_);
return *this;
}
};
main.cpp
#include <iostream>
#include "List.h"
#include <string>
int main(){
List<int> l1;
List<int> l2;
//or calling the constructor: List<int> l2(std::move(l1));
l1.push_front(4);
l1.push_front(3);
l2 = std::move(l1); //all contents of l1 object are dumped into l2
}

Answer 1

For the class shown here, there are no members except tail and head, hence I'd say
You must initialize your tail and head before making the moving in the move ctor
List(List&& list) noexcept : head{ nullptr }, tail{ nullptr } {
std::swap(head_, list.head_);
std::swap(tail_, list.tail_);
}
The constructor and the assignment operator should be noexcept because the compiler may ignore them.
You may check for self-assignment in the beginning of the assignment operator, as follows
if (this == &rhs) {
return *this;
}

Answer 2

During a move operation, the object/variable being moved from must be left in a "valid but indeterminate state". However, in your move constructor, head_ and tail_ have not been initialized before swapping them into the source list that is being moved, thus leaving the source list in an invalid state after the move.
You need to change these declarations:
Node* head_;
Node* tail_;
To this:
Node* head_ = nullptr;
Node* tail_ = nullptr;
Also, you need to add a copy constructor, too:
//! Copy constructor
List(const List& list) {
Node **n = &head_;
for (Node *ptr = list.head_; ptr; ptr = ptr->next_) {
*n = new Node(ptr->value_, tail_, nullptr);
if (tail_) tail_->next_ = *n;
tail_ = *n;
n = &(tail_->next_);
}
}
Also, although your move assignment operator will "work", it is generally not a good idea to make the source object being moved to take ownership of the old data, since you don't know how the caller is using the source object. Just because you take an rvalue reference as input does not ensure the caller is passing in an actual temporary object 1 (case in point, your own example does not).
1: Though, the general rule of thumb is to never use an object after it is moved from, other than to reassign or reset it.
A safer option, which will also allow you to support copy assignment and move assignment in a single implementation, is to take the input parameter by value. This way, any assignment will construct a temp object utilizing your existing move constructor or copy constructor as needed, thus leaving the source object in a valid moved-from or copied-from state, and then you swap ownership of data with your temp object:
List& operator= (List list) {
std::swap(head_, list.head_);
std::swap(tail_, list.tail_);
return *this;
}