Rule of Five

CppUG_Rule_of_Five.h

#include <cstring>
#include <iostream>

class foo
{
    public:
        // Constructor
        explicit foo(const char* arg) : cstring{new char[std::strlen(arg)+1]}
        {
            std::strcpy(cstring, arg);
            std::cout << "constructed\n";
        }
        // Destructor
        ~foo() {
            delete[] cstring;
            std::cout << "destructed\n";
        }
        // Copy constructor
        foo(const foo& other) : cstring{new char[std::strlen(other.cstring) + 1]} 
        {
            std::strcpy(cstring, other.cstring);
            std::cout << "copy constructed\n";
        }
        // Move constructor
        foo(foo&& other) noexcept : cstring{std::move(other.cstring)} 
        {
            other.cstring = nullptr;
            std::cout << "move constructed\n";
        }
        // Copy assignment
        foo& operator=(const foo& other) {
            foo tmp{other};         // re-use copy-constructor
            *this = std::move(tmp); // re-use move-assignment
            std::cout << "copy assigned\n";
            return *this;
        }
        // move assignment
        foo& operator=(foo&& other) noexcept {
            delete[] cstring;
            cstring = std::move(other.cstring);
            other.cstring = nullptr;
            std::cout << "move assigned\n";
            return *this;
        }
    private:
        char* cstring; // raw pointer used as a handle to a dynamically-allocated memory block
};