ro5

// Template for the Rule Of 5

class Ro5 {
    private:
        A classA;
        B *classBptr;
        C *malloc_ptr;
        int private1;
        std::container private2;

    public:
        // default constructor, happens in places where you make delarations without initialization. eg:
        // Ro5 my_class;
        // Now, if don't want invoking your default constructor without initialization, you need to
        // replace the next line with: "Ro5() = delete;" If you do that, statements like
        // Ro5 my_class; will throw compilation error, but statement like
        // Ro5 my_class{arg1, arg2, ..., argk}; would not

Ro5() : classA({}), classBptr(new B{}), malloc_ptr(new C{}), private1(0), private2(std::container{}) {};

        // parameterized constructor
        Ro5(const A &anotherClassA, const B *anotherClassBptr, C *anotherMallocPtr, int i, std::container anotherContainer) : 
            classA(anotherClassA), // will invoke copy constructor of A
            classBptr(new B(*anotherClassBptr)),
            malloc_ptr(std::memcpy(std::malloc(sizeof(C)), anotherMallocPtr, sizeof(C))),
            private1{i},
            private2{anotherContainer} // std::container will automatically initialized with anotherContainer values
        {};

        ~Ro5() {
            del malloc_ptr;
            del classBptr;
            // remaining members are automatically freed
        }

        // Copy constructor
        Ro5(const Ro5 &other) : 
            classA(other.classA),  // will invoke copy constructor of A
            classBptr(new B(*other.classBptr)),
            malloc_ptr(std::memcpy(std::malloc(sizeof(C)), other.malloc_ptr, sizeof(C))),
            private1{other.private1}, 
            private2{other.private2} // std containers will auto-initialize
        {};

        // Move Constructor
        Ro5(Ro5 &&other) :
            classA(other.classA),  // will invoke move constructor of A
            classBptr{other.classBptr}; // copy the pointer to heap address
            malloc_ptr{other.malloc_ptr}, // copy the pointer to heap address
            private1{other.private1},
            private2{other.private2}, // invoke move constructor of std container
            
        {
            other.classBptr = nullptr; // release the other heap allocated mem
            other.malloc_ptr = nullptr; // release the other heap allocated mem
        };

        // Copy assignment Operator
        Ro5 &operator=(const Ro5 &other) {
            if (this != other) {
                classA = other.classA; // will invoke copy assignment operator of A

                delete classBptr; // always do for heap allocated mem
                classBptr = new B(*other.classBptr); // use 'new' for class pointer

                delete malloc_ptr; // always do for heap allocated mem
                malloc_ptr = std::memcpy(std::malloc(sizeof(C)), other.malloc_ptr, sizeof(C));

                private1 = other.private1;
                private2 = other.private2; // will invoke copy assignment operator of standard container
            }
            return *this;
        };

        // Move assignment Operator
        Ro5 &operator=(Ro5 &&other) {
            if (this != other) {
                classA = std::exchange(other.classA, std::nullptr);

                delete classBptr; // delete previous heap mem allocation
                classBptr = other.classBptr; // point it to new heap location
                other.classBptr = std::nullptr; // release previous hold on this heap

                delete malloc_ptr // delete previous heap mem allocation
                malloc_ptr = other.malloc_ptr; // point it to new heap location
                other.malloc_ptr = std::nullptr; // release previous hold on this heap
            }
            return *this;
        };

};