Как написать свой reverse_iterator, чтобы работал с std функциями?

пишу итераторы для стэка-массива (да, просмотр стэка). Должны быть итератор из конца в начало (в случае стэка у меня это называется iterator) и из начала в конец (reverse_iterator). Хочется, чтобы работали с std функциями (например, sort). Но обычный итератор (то бишь из начала в конец) сделать не получается. Заранее спасибо.

class reverse_iterator : public std::iterator < std::random_access_iterator_tag,

        T,
        ptrdiff_t,
        T*,
        T&>
    {

    private:

        T* ptr;

    public:
        
        reverse_iterator(T* _ptr = nullptr) {
            ptr = _ptr; 
        }

        reverse_iterator(const reverse_iterator& it) = default;

        ~reverse_iterator() {}

        reverse_iterator& operator=(const reverse_iterator& other) = default;
        
        reverse_iterator& operator=(T* _ptr) {
            
            ptr = _ptr; 
            
            return *this; 
        }

        operator bool() const {

            return ptr;
        }

        bool operator== (const reverse_iterator& other) const {
            
            return ptr == other.ptr; 
        }

        bool operator!= (const reverse_iterator& other) const {
            
            return ptr != other.ptr; 
        }

        reverse_iterator& operator+= (const ptrdiff_t& movement) {
            
            ptr += movement; 
            
            return *this; 
        }

        reverse_iterator& operator-= (const ptrdiff_t& movement) {
            
            ptr -= movement; 
            
            return *this; 
        }

        reverse_iterator& operator++ () {
            
            ++ptr; 
            
            return *this; 
        }
        
        reverse_iterator& operator-- () {
            
            --ptr; 
            
            return *this; 
        }
        
        reverse_iterator operator++(int) {
            
            auto temp(*this); 
            
            ++ptr; 
            
            return temp; 
        }

        reverse_iterator operator--(int) {
            
            auto temp(*this); 
            
            --ptr; 
            
            return temp; 
        }
        
        reverse_iterator operator+(const ptrdiff_t& movement) {
            
            auto oldPtr = ptr; 
            
            ptr += movement; 
            
            auto temp(*this); 
            
            ptr = oldPtr; 
            
            return temp; 
        }

        reverse_iterator operator-(const ptrdiff_t& movement) {
            
            auto oldPtr = ptr; 
            
            ptr -= movement; 
            
            auto temp(*this); 
            
            ptr = oldPtr; 
            
            return temp; 
        }

        ptrdiff_t operator-(const reverse_iterator& other) {
            
            return std::distance(other.ptr, ptr); 
        }

        T& operator*() { 
            
            return *ptr; 
        }

        const T& operator*()const { 
            
            return *ptr; 
        }
        
        T* operator->() { 
            
            return ptr; 
        }

        T* getPtr() const { 
            
            return ptr; 
        }
        
        const T* getConstPtr() const { 
            
            return ptr; 
        }
    };

    class iterator : public std::iterator < std::random_access_iterator_tag,

        T,
        ptrdiff_t,
        T*,
        T&>
    {

    private:

        T* ptr;

    public:

        iterator(T* _ptr = nullptr) {
            ptr = _ptr;
        }

        iterator(const iterator& it) = default;

        ~iterator() {}

        iterator& operator=(const iterator& other) = default;

        iterator& operator=(T* _ptr) {

            ptr = _ptr;

            return *this;
        }

        operator bool() const {

            return ptr;
        }

        bool operator==(const iterator& other) const {

            return ptr == other.ptr;
        }

        bool operator!= (const iterator& other) const {

            return ptr != other.ptr;
        }

        ptrdiff_t operator-(const reverse_iterator& other) {

            return std::distance(ptr, other.ptr);
        }

        ptrdiff_t operator-(const iterator& other) {

            return std::distance(other.ptr, ptr);
        }

        iterator& operator+= (const ptrdiff_t& movement) {

            ptr -= movement;

            return *this;
        }

        iterator& operator-= (const ptrdiff_t& movement) {

            ptr += movement;

            return *this;
        }

        iterator& operator++ () {

            --ptr;

            return *this;
        }

        iterator& operator-- () {

            ++ptr;

            return *this;
        }

        iterator operator++(int) {

            auto temp(*this);

            --ptr;

            return temp;
        }

        iterator operator--(int) {

            auto temp(*this);

            ++ptr;

            return temp;
        }

        iterator operator+(const ptrdiff_t& movement) {

            auto oldPtr = ptr;

            ptr -= movement;

            auto temp(*this);

            ptr = oldPtr;

            return temp;
        }

        iterator operator-(const ptrdiff_t& movement) {

            auto oldPtr = ptr;

            ptr += movement;

            auto temp(*this);

            ptr = oldPtr;

            return temp;
        }

        T& operator*() {

            return *ptr;
        }

        const T& operator*()const {

            return *ptr;
        }

        T* operator->() {

            return ptr;
        }

        T* getPtr() const {

            return ptr;
        }

        const T* getConstPtr() const {

            return ptr;
        }
    };

    reverse_iterator rbegin() {
        return stk_arr;
    }

    reverse_iterator rend() {
        return stk_arr + sz;
    }

    iterator begin() {
        return stk_arr + sz - 1;
    }

    iterator end() {
        return stk_arr - 1;
    }