The big five / writing resource owning classes

#include <iostream>
#include <algorithm>
class Leon
{
public:
    int* data = nullptr; //default member initialization
    int length = 0;
    //default construction (container-friendly!)
    Leon() {}
    //custom construction. Single argument constructor should always be explicit!
    explicit Leon(int length) : data(new int[length]), length(length){  }
    //copy construction
    Leon(const Leon& other) : data(new int[other.length]), length(other.length) {
        std::copy(other.data, other.data + other.length, data);
    }
    //move constructor
    Leon(Leon&& other) {
        data = other.data;
        length = other.length;
        other.data = nullptr;
        other.length = 0;
    }
    //copy-assignment
    Leon& operator= (const Leon& other) {
        if (&other == this) {
            return *this;
        }
        if (nullptr != data) {
            delete[] data;
        }
        length = other.length;
        data = new int[other.length];
        std::copy(other.data, other.data + other.length, data);
        return *this;
    }
    Leon& operator= (Leon&& other){
        std::swap(other.length, length);
        std::swap(other.data, data);
        return *this;
    }
    ~Leon() {
        if (nullptr != data){
            delete[] data;
        }
    }
};
//argument by copy, return value by copy. Potentially large objects, expensive!
Leon doSomethingExpensive(Leon p_leon) {
    return p_leon; //will copy (expensive!) but *can* move, if available! (RVO almost always saves us though)
}
int main(int argc, int* argv[]){
    Leon a;     //default constructible == container support
    Leon b(10); //custom construction (explicit!)
    Leon c(b);  //copy construction
    Leon d(20);
    d = b; //copy assignment (remember to clean out the content of d!)
    d = doSomethingExpensive(b); //b is an lvalue (named!) so it will be copied to the argument
    d = doSomethingExpensive(Leon(50)); //Leon is an rvalue (no name!), and will *move* to the argument if the move constructor exist
    d = std::move(b); //move-assign - give d the content of b, if move assignment operator exists.
            // b is left valid but undefined (don't use after move!)
    return 0;
}

//Here is an ideal implementation of the big five:
    // https://stackoverflow.com/a/12653520
// notice how beautifully short and compact the boiler plate can be. :)
// especially this neat hack: instead of writing two assignment operators,
// you could write just one that takes its argument by value. That one can
// be used for both copy and move assignment!