Move, Copy assignment, Copy constructor seems to work without definition

Question

I am working on a simple matrix template class for practice purposes, I have defined my constructor and destructor but on testing the class, I found out that Move and copy operations works without any flaws and I didn't define them. I really do not understand what's going and I don't trust what is happening.

#ifndef MATRIX_H_
#define MATRIX_H_

#include <cstdlib>
#include <iostream>

namespace mat
{
    template<class T>
    class Matrix
    {
        public:
            Matrix(size_t row, size_t column, const T& val)
                : row_{row}, column_{column}, elem_{static_cast<T*>(::operator new(row_ * column_))} 
                {
                    for(size_t i = 0; i != size(); ++i )
                        elem_[i] = val;
                }
            Matrix(size_t row, size_t column)
                :  row_{row}, column_{column}, elem_{static_cast<T*>(::operator new(row_ * column_))} {}
            
            size_t size() const { return row_ * column_; }

            ~Matrix()
            {
                for(size_t i = size(); i != 0; --i)
                {
                    elem_[i].~T();
                    delete elem_;
                }
            }
        private:
            size_t row_;
            size_t column_; 
            T *elem_;
    };
}

#endif

#include <iostream>
#include "Matrix.h"

using namespace mat;

class SomeClass
{
    int s_;
    public:
        SomeClass(int s ) : s_{s} {} 
};

template<class T>
Matrix<T> fn(const Matrix<T> A)
{
    return A;
}

int main()
{
    SomeClass s{1};
    Matrix<SomeClass> my_mat(2, 3, s);
    Matrix<int> my_mat2(2, 3, 4);
    Matrix<SomeClass> my_mat3{2, 3};
    Matrix<int> copy_mat(my_mat2);
}

Answer 1

If you don't declare a special member function, then sometimes the compiler implicitly declares and/or defines the functions.

See the table in this answer for more detail.

Your code causes undefined behaviour in several ways; one possible upshot of undefined behaviour is appearing to work correctly -- for now. You should run into more obvious issues when using a matrix element type which has a destructor with side-effects.

---

Some problems:

• ::operator new expects a number of bytes, but you provided a number of elements.
• In the constructor you assign to elements that have not been constructed. (In C++20 this might work for trivial element types, but not when the constructor has side-effects). You should use placement-new instead of the assignment operator.
• The constructor version taking no initial value leaves the memory uninitialized (and no objects created), you still have to call placement-new on every element in this version.
• In the destructor you call ~T() for elements that have never had a constructor called. Also it seems to have an off by one error as you start by calling destructor for elem_[size()], and don't call it for elem[0].
• delete elem; is called size() number of times, it should be called zero times. Use ::operator delete outside the loop to deallocate memory. (delete expression should be paired with new expression, while ::operator delete function paired with ::operator new function).
• The copy constructor, move constructor, copy assignment, and move assignment, should be defined by you and provide correct behaviour. (Which in the case of copy-operations will be calls to placement-new for each element, if you are intending to continue with the plan of individually destroying each element).