自定义C++ Growable Array类调用sort报_Sort_unchecked匹配错误

我在用C++实现带模板的可增长数组类GA，内部包含仅支持前向遍历的iterator子类。调用sort(Aint.begin(), Aint.end());时出现错误：_Sort_unchecked: no matching overloaded function found，以下是我的头文件和main函数代码：

头文件代码 #

#pragma once
template<typename T>
class GA
{
    int size;
    T* Vs;
public:
    GA(int _size = 1)
    {
        size = _size;
        Vs = new T[size]{};
    }
    // suggestion by PaulMcKenzie but still the error remains
    GA(const GA& other)
    {
        size = other.size;
        Vs = new T[size];
        for (int i = 0; i < size; i++)
        {
            Vs[i] = other.Vs[i];
        }
    }
    T& operator[](int i)
    {
        return Vs[i];
    }
    int length()
    {
        return size;
    }
    const T& operator[](int i)const
    {
        return Vs[i];
    }
    friend ostream& operator<<(ostream&, const GA<T>& G)
    {
        for (int i = 0; i < G.size; i++)
        {
            cout << G[i] << " ";
        }
        return cout;
    }
    void push_back(T v)
    {
        T* HA = new T[size + 1];
        for (int i = 0; i < size; i++)
            HA[i] = Vs[i];
        HA[size] = v;
        delete[] Vs;
        Vs = HA; size++;
    }
    ~GA()
    {
        delete[]Vs;
    }

    class iterator
    {
        T* p;
        friend class GA;

        iterator(T* _p)
        {
            p = _p;
        }

    public:
        /* Yksisarvinen suggested this and I tried but still got the same error I hope I did it correctly*/ 
        T& operator->()
        {
             return *p;
        }
        int operator - (const iterator& s) const
        {
            return s.p - this->p;
        }
        bool operator == (const iterator& s)
        {
            return this->p == s.p;
        }
        bool operator != (const iterator& s)
        {
            return this->p != s.p;
        }
        const iterator operator++(int)
        {
            iterator temp = *this;
            this->p++;
            return temp;
        }
        iterator& operator++()
        {
            this->p++;
            return *this;
        }
        T& operator*()
        {
            return *p;
        }
    };


    iterator begin()
    {
        return iterator(Vs);
    }
    iterator end()
    {
        return iterator(Vs + size);
    }

    iterator find(T v)
    {
        for (int i = 0; i < size; i++)
        {
            if (Vs[i] == v)
                return iterator(Vs + i);
        }
        return end();
    }

    void replaceAt(iterator& i, T v)
    {
        *i = v;
    }
    void insertBefore(iterator& t, T v)
    {
        T* HA = new T[size + 1];
        for (int vi = 0, hi = 0; vi < size; vi++, hi++)
        {
            if (&Vs[vi] == t.p)
            {
                HA[hi] = v;
                hi++;
            }
            HA[hi] = Vs[vi];
        }

        delete[]Vs;
        Vs = HA;
        size++;
    }
};

main函数代码 #

#include <iostream>
#include <algorithm>
using namespace std;
#include "GA.h"

void initAint(GA<int>& Aint)
{
    for (int i = 0; i < Aint.length(); i++)
    {
        Aint[i] = (rand() % 6 + 1) * 100;
    }
}
void print(const char* msg, const GA<int>& Aint)
{
    cout << msg << " : {";
    cout << Aint << "}" << endl;
}
int main()
{
    GA<int> Aint(10);
    initAint(Aint);
    print("Aint [] ", Aint);

    /*
    for (GA<int>::iterator i = Aint.begin(); i != Aint.end(); i++)
    {
    // (*i).do something to the i'th value'
    cout << *i << " ";
    }
    */

    auto fi = Aint.find(500);
    if (fi == Aint.end())
    {
        cout << "500 not found..." << endl;
    }
    else
    {
        cout << "500 is found..." << endl;
        (*fi) /= 100;

        Aint.insertBefore(fi, 1000);
    }
    print("\n\n\nmodified Aint [] ", Aint);

    sort(Aint.begin(), Aint.end());
    print("\n\n\nSorted Aint [] ", Aint);


    /*for (auto ri = Aint.rbegin(); ri != Aint.rend(); ri++)
    {
        cout << *ri;
    }*/

    return 0;
}

问题原因 #

std::sort要求迭代器满足随机访问迭代器的标准，而当前的iterator仅实现了前向迭代器的部分操作，缺少随机访问迭代器必需的运算符，同时还有几处实现错误：

1. operator->返回值错误：箭头运算符需要返回指针，而非引用
2. operator-的差值计算方向颠倒，且返回类型应为标准的ptrdiff_t而非int
3. 缺少随机访问迭代器必需的运算符：operator+=、operator-=、operator+、operator[]以及比较运算符<、<=、>、>=
4. 比较运算符==、!=未添加const修饰，无法支持const迭代器
5. 未定义迭代器的关联类型（如iterator_category、value_type等），导致标准库无法识别迭代器特性

修改方案 #

更新GA<T>::iterator类，补全所有随机访问迭代器的要求：

class iterator
{
    T* p;
    friend class GA;

    iterator(T* _p) : p(_p) {}

public:
    // 定义迭代器关联类型，让标准库识别迭代器特性
    using iterator_category = std::random_access_iterator_tag;
    using value_type = T;
    using difference_type = ptrdiff_t;
    using pointer = T*;
    using reference = T&;

    // 修正operator->：返回指针
    pointer operator->() const
    {
        return p;
    }

    // 修正operator-：返回正确的差值，类型为ptrdiff_t
    difference_type operator-(const iterator& s) const
    {
        return p - s.p;
    }

    // 补全随机访问迭代器的运算符
    iterator& operator+=(difference_type n)
    {
        p += n;
        return *this;
    }

    iterator& operator-=(difference_type n)
    {
        p -= n;
        return *this;
    }

    iterator operator+(difference_type n) const
    {
        return iterator(p + n);
    }

    iterator operator-(difference_type n) const
    {
        return iterator(p - n);
    }

    reference operator[](difference_type n) const
    {
        return *(p + n);
    }

    // 补全比较运算符
    bool operator<(const iterator& s) const
    {
        return p < s.p;
    }

    bool operator<=(const iterator& s) const
    {
        return p <= s.p;
    }

    bool operator>(const iterator& s) const
    {
        return p > s.p;
    }

    bool operator>=(const iterator& s) const
    {
        return p >= s.p;
    }

    // 修正比较运算符的const修饰
    bool operator==(const iterator& s) const
    {
        return p == s.p;
    }

    bool operator!=(const iterator& s) const
    {
        return p != s.p;
    }

    // 原有迭代器操作保留（已正确实现）
    const iterator operator++(int)
    {
        iterator temp = *this;
        p++;
        return temp;
    }

    iterator& operator++()
    {
        p++;
        return *this;
    }

    reference operator*() const
    {
        return *p;
    }
};

另外，需要在头文件开头添加以下依赖头文件：

#include <iterator>
#include <ostream>

说明 #

1. 关联类型的定义是标准库识别迭代器类型的关键，std::random_access_iterator_tag告诉std::sort可以使用高效的排序算法
2. 所有运算符的实现都遵循随机访问迭代器的标准行为，确保和原生指针的行为一致
3. 修正后的迭代器完全满足std::sort的要求，能够正常完成排序操作

内容的提问来源于stack exchange，提问作者M Hamza Naveed