Класс и сортировка

template<class T>
class MyClass
{
public:
    MyClass();
    MyClass(size_t size);
    MyClass(const MyClass<T> &other);
    ~MyClass() {
        delete[] arr;
    }
    T operator[](size_t index) const;
    T& operator[](size_t index);
 
    friend ostream &operator<<(ostream &out, const MyClass<T> &other)
    {
        for (int i = 0; i < other.size; i++)
        {
            out << other.arr[i] << ' ';
        }
        return out;
    }
 
private:
    size_t size;
    T *arr;
};

template<class T>
void quickSortR(T* a, long N) {
 
 
    long i = 0, j = N;     
    T temp, p;
 
    p = a[ N>>1 ];      
    do {
        while ( a[i] < p ) i++;
        while ( a[j] > p ) j--;
 
        if (i <= j) {
            temp = a[i]; a[i] = a[j]; a[j] = temp;
            i++; j--;
        }
    } while ( i<=j );
    if ( j > 0 ) quickSortR(a, j);
    if ( N > i ) quickSortR(a+i, N-i);
}

template<class T>
class MyClass
{
public:
    MyClass() : size(0), arr(nullptr) {}
    MyClass(size_t size) : size(size), arr(new T[size]) {}
    MyClass(std::initializer_list<T> l) : size(l.size()), arr(new T[size]) {
        std::copy(l.begin(), l.end(), arr);
    }
    MyClass(const MyClass<T> &other) : size(other.size), arr(new T[other.size]) {
        std::copy(other.arr, other.arr + other.size, arr);
    }
    MyClass(MyClass<T> &&other) noexcept : size(other.size), arr(std::exchange(other.arr, nullptr)) {
    }
    MyClass<T> &operator=(const MyClass<T> &other) {
        if (this != &other) {
            if (arr != nullptr) {
                delete[] arr;
            }
            size = other.size;
            arr = new T[size];
            std::copy(other.arr, other.arr + other.size, arr);
        }
        return *this;
    }
    MyClass<T> &operator=(MyClass<T> &&other) {
        if (this != &other) {
            size = other.size;
            arr = std::exchange(other.arr, nullptr);
        }
        return *this;
    }
    virtual ~MyClass() {
        if (arr != nullptr) {
            delete[] arr;
        }
    }
    const size_t getSize() const { return size; }
    const T& operator[](size_t index) const { return arr[index]; }
    T& operator[](size_t index) { return arr[index]; }
 
private:
    size_t size;
    T *arr;
};
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const MyClass<T> &other)
{
    out << "[ ";
    for (size_t i = 0; i < other.getSize(); i++) {
        out << other[i] << ' ';
    }
    return out << "]";
}
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<MyClass<T>> &other)
{
    out << "[ ";
    for (size_t i = 0; i < other.size(); i++) {
        out << other[i] << ' ';
    }
    return out << "]";
}
 
 
template <typename Iterator, typename Compare>
void QuickSort(Iterator first, Iterator last, Compare isLess)
{
    if (std::distance(first, last) > 1) {
        Iterator bound = Partition(first, last, isLess);
        QuickSort(first, bound, isLess);
        QuickSort(bound + 1, last, isLess);
    }
}
 
template <typename Iterator, typename Compare>
Iterator Partition(Iterator first, Iterator last, Compare isLess)
{
    auto pivot = std::prev(last, 1);
    auto i = first;
    for (auto j = first; j != pivot; ++j) {
        if (isLess(*j, *pivot)) {
            std::swap(*i++, *j);
        }
    }
    std::swap(*i, *pivot);
    return i;
}
 
 
int main(int argc, char** argv) {
    std::vector<MyClass<int>> vector{ MyClass<int>{1, 2, 3, 4, 5}, MyClass<int>{1, 2, 3}, MyClass<int>{1, 2, 3, 4} };
 
    std::cout << vector << std::endl;
 
    auto less = [](const auto &a, const auto &b)->bool { return a.getSize() < b.getSize(); };
    QuickSort(vector.begin(), vector.end(), less);
 
    std::cout << vector << std::endl;
    return 0;
}

 if ( j > 0 ) quickSortR(a, j);
 if ( N > i ) quickSortR(a+i, N-i);