Использование std::sort с пользовательским «векторным» контейнером

Я пытаюсь использовать std:sort с пользовательским вектором C++, как вы можете видеть, итератор реализован и протестирован с использованием цикла for на основе диапазона для печати векторного содержимого. но std::sort выдает ошибку сборки:

'_Sort_unchecked': no matching overloaded function found

отсутствуют ли в моем коде какие-либо требования для использования std::sort?

это полный код:

#include <iostream>
#include<exception>
#include<algorithm>

template <typename T>
class CustomVector {

private:

    T* m_data;
    int m_size ;
    int m_capacity ;

public:

    class Iterator
    {
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
        using iterator_category = std::random_access_iterator_tag;

    public:
        Iterator() = default;
        Iterator(T* pData) : m_ptr(pData) {}

        reference       operator*() { return *m_ptr; }
        const reference& operator*()            const { return *m_ptr; }
        pointer         operator->() { return m_ptr; }
        const pointer   operator->()            const { return m_ptr; }
        reference       operator[](int offset) { return m_ptr[offset]; }
        const reference operator[](int offset)  const { return m_ptr[offset]; }

        Iterator& operator++() { ++m_ptr; return *this; }
        Iterator& operator--() { --m_ptr; return *this; }
        Iterator operator++(int) { Iterator it(*this); ++m_ptr; return *this; }
        Iterator operator--(int) { Iterator it(*this); --m_ptr; return *this; }

        Iterator& operator+=(int offset) { m_ptr += offset; return *this; }
        Iterator& operator-=(int offset) { m_ptr -= offset; return *this; }

        Iterator operator+(int offset) const { Iterator it(*this); return it += offset; }
        Iterator operator-(int offset) const { Iterator it(*this); return it -= offset; }

        difference_type operator-(const Iterator& other) const { return m_ptr - other.m_ptr; }

        bool operator<  (const Iterator& other) const { return m_ptr < other.m_ptr; }
        bool operator<= (const Iterator& other) const { return m_ptr <= other.m_ptr; }
        bool operator>  (const Iterator& other) const { return m_ptr > other.m_ptr; }
        bool operator>= (const Iterator& other) const { return m_ptr >= other.m_ptr; }
        bool operator== (const Iterator& other) const { return m_ptr == other.m_ptr; }
        bool operator!= (const Iterator& other) const { return m_ptr != other.m_ptr; }

    private:
        T* m_ptr{ nullptr };
    };


    Iterator begin() { return Iterator(m_data); }
    Iterator end() { return Iterator(m_data + m_size); }

    CustomVector() :m_size(0), m_capacity(2), m_data(new T[m_capacity]) { std::cout << "constructor called" << std::endl; }
    CustomVector(const int & size)  {

        m_size = size;
        m_capacity = 2 * size;
        m_data = new T[m_capacity];
        std::cout << "constructor called" << std::endl; 
    }

    CustomVector(const CustomVector& other) {

        m_size = other.m_size;
        m_capacity = other.m_capacity;
        m_data = new T[m_capacity];

       for (int i = 0; i < m_size; i++) {
            m_data[i] = other.m_data[i];
       }
    }

    ~CustomVector() { delete[] m_data; std::cout << "destructor called" << std::endl; }

    int size() { return m_size; }
    int capacity() { return m_capacity; }

    void reserve(int newcapacity) {

        T* newData = new T[newcapacity];

            for (int i = 0; i < m_size; i++) {
                newData[i] = m_data[i];
            }

        if (m_data != nullptr)delete[]m_data;

        m_data = newData;
        m_capacity = newcapacity;
    }

    void push_back(const T& val) {

        if (m_size < m_capacity) {
            reserve(m_capacity * 2);
        }

        m_data[m_size++] = val;
    }

    void print_data() { 

       Iterator iter(m_data);
        for (iter = this->begin(); iter != this->end(); iter++) {

            std::cout << "data  = " << *iter << std::endl;
        }
    }

    void pop_back() {

        if (m_size > 0) {

            (reinterpret_cast<T*>(m_data)[m_size - 1]).~T();
            m_size--;
        }
    }

    void clear() {

        if (m_size > 0) {

            delete[]m_data;
            m_data = nullptr;
            m_size = 0;
            m_capacity = 2;
        }
    }

    bool empty() {
        return (m_size == 0);
    }

    const T& operator [] (int index) const {
        if (index > m_size || index < 0) {
            throw std::out_of_range("index is out of range (Custom vector class)");
        }
        
        return  m_data[index];
    }

    CustomVector<T>& operator = (const CustomVector<T>& V) {

        m_size = V.m_size;
        m_capacity = V.m_capacity;
        m_data = new T[m_size];

        for (int i = 0; i < m_size; i++) {
            m_data[i] = V.m_data[i];
        }
    }

    CustomVector<T>& operator>(const CustomVector<T>& other) {
        
        return *this;
    }

    CustomVector<T>& operator<(const CustomVector<T>& other) {
        
        return *this;
    }

};


int main() {

    try {

        CustomVector<double>somevector;
        somevector.push_back(16666);
        somevector.push_back(55);
        somevector.push_back(100);
        somevector.push_back(300000);

        for (auto& val : somevector) {
            std::cout << "val = " << val << std::endl;
        }

        //double min = *std::min_element(somevector.begin(), somevector.end()); // build error
        //double max = *std::max_element(somevector.begin(), somevector.end()); // build error 
        std::sort(somevector.begin(), somevector.end() );  // build error

        std::fill(somevector.begin(), somevector.end(), 100); // working

    }
    catch (std::exception& e) {
        std::cout << "exception : " << e.what() << std::endl;
    }


    return 0;
}