the special member functions
Every C++ class needs answers to a few basic questions: how do I create one, how do I make a copy, how do I move one, and how do I clean it up? You can write those answers yourself, but if you don't, the compiler quietly writes them for you. These compiler-managed operations are the special member functions, and understanding which ones exist (and when they appear or vanish) is essential to getting resource management right.
There are six of them: the default constructor (create with no arguments), the destructor (clean up), the copy constructor and copy assignment operator (duplicate an existing object), and the move constructor and move assignment operator (steal the guts of an existing object that is about to die). The compiler generates each one as a memberwise default — for example, the default copy constructor copies each member in turn. The subtle and often-painful rule is that declaring some of these suppresses the automatic generation of others: notably, if you declare a destructor (or any copy/move operation), the move operations are not generated, and the compiler may quietly fall back to copying.
These six are exactly the hooks RAII hangs on. The constructor acquires resources, the destructor releases them, and copy versus move decides whether duplicating an object should deep-copy a held resource or transfer ownership of it. The whole rule of zero / rule of five guidance is about handling this set coherently. The honest pitfall, again: the compiler-generated copy is a member-by-member (shallow) copy — perfect for a struct of ints, catastrophic for a class holding a raw owning pointer, because both copies will try to free the same memory.
struct P { P(); ~P(); P(const P&); P& operator=(const P&); P(P&&); P& operator=(P&&); }; // the six special members, by signature
Default ctor, destructor, copy ctor + copy assign, move ctor + move assign — the compiler supplies any you don't, subject to suppression rules.
The double-ampersand && in the move signatures is an rvalue reference, not 'reference to a reference'. It is the language's way of saying 'this argument is a temporary or an object you've agreed to cannibalize', which is what makes a cheap move safe.