I am not quite sure what the way to go here is; if I have a class with pointer members and a move constructor that sets the pointer members to
if memberpointer == nullptr
C& operator=(C& src)
if (this != &src)
if (memberpointer == nullptr)
*memberpointer = *src.memberpointer;
No, there's no need for all those tests, any more than if you didn't have move semantics at all. If it's illegal to use your object before calling some sort of initialization function, then you should also consider it illegal to use the object after moving. Your object should be left in a state that can be properly destructed, but there are no other rules specifying what that state should be.
Foo foo; foo.Init(); // required // foo is now allowed to be used Foo bar = std::move( foo ); // No guarantees on whether foo is now initialised or not.
Move semantics do not stipulate what state the object moved from will be in after the move. It only requires the object is in some internally consistent state. So, your move constructor or assignment operator is perfectly entitled to swap the members if it wishes... Provided all the other internal states of the object are consistent with that. That is, it's perfectly okay to have this situation:
Foo foo, bar; foo.Init(); bar.Init(); bar = std::move( foo ); // foo and bar contents now swapped. // caveat: you should not use foo again
However, you must not expect this. The rule is that after a move, you should not attempt to use the object again.