C++仅移动迭代器后置++实现及Recordset迭代器end()合理性疑问

现有一个仅移动（move-only）的Recordset类定义如下：

class Recordset
{
public:

    Recordset(const Recordset&) = delete;

    Recordset& operator = (const Recordset&) = delete;

    Recordset(Recordset&& other) noexcept = default;

    Recordset& operator = (Recordset&&) = default;

    //Moves to the next record. Returns false if the end is reached.
    bool Next();

    //Gets the current record as an instance of type T.
    template <class T>
    void Get(T& val);
};

尝试为其实现C++风格迭代器，代码如下：

template <class T>
class Iterator
{
public:

    using iterator_category = std::forward_iterator_tag;

    using value_type = T;

    using difference_type = std::ptrdiff_t;

    using pointer = value_type*;

    using reference = value_type&;

    Iterator() = default;
    
    Iterator(Recordset s) : m_i(std::move(s))
    {
        try_next();
    }

    Iterator(const Iterator&) = delete;

    Iterator& operator = (const Iterator&) = delete;

    Iterator(Iterator&& other) = default;

    Iterator& operator = (Iterator&& other) = default;

    T* operator-> () { return cur(); }

    T* operator* () { return cur(); }

    bool operator== (const Iterator& other) const noexcept
    {
        //They both are end().
        return !m_v && !other.m_v;
    }

    bool operator!= (const Iterator& other) const noexcept
    {
        return !operator==(other);
    }

    Iterator& operator++ ()
    {
        this->try_next();

        return *this;
    }

    Iterator operator++ (int)
    {
        Iterator tmp = *this; //would not compile.

        this->try_next();

        return tmp;
    }

private:

    bool try_next()
    {
        if (m_i.Next())
        {
            T val;
            m_i.Get(val);

            m_v = val;

            return true;
        }

        return false;
    }

    T* cur()
    {
        T& val = *m_v;

        return &val;
    }

    Recordset m_i;

    std::optional<T> m_v;
};

template <class T>
std::ranges::subrange<Iterator<T>> make_range(Recordset& s)
{
    return std::ranges::subrange(Iterator<T>(s), Iterator<T>{});
}

使用方式示例：

struct Record { int x; std::string y; };

int main()
{
    Recordset s;

    for (Record& r : make_range(s))
    {
        std::cout << r.x << r.y << std::endl;
    }

    return 0;
}

存在两个技术疑问：

1. 由于Recordset和Iterator均为仅移动类型，上述代码中后置++运算符（Iterator operator++(int)）无法编译，该如何实现？C++20是否要求必须实现此运算符？
2. 当前使用空std::optional表示end()迭代器的方式是否合理？

问题1：仅移动迭代器的后置实现及C20要求 #

实现方案 #

因为Iterator是仅移动类型，无法拷贝构造，所以后置++需要通过移动构造临时对象的方式实现，修改后的代码如下：

Iterator operator++(int)
{
    Iterator tmp = std::move(*this); // 移动构造临时对象，绕过拷贝限制
    this->try_next();
    return tmp;
}

利用std::move将当前迭代器的所有权转移给临时对象，之后对原迭代器执行前置++，最后返回临时对象，完全符合仅移动类型的特性。

C++20的要求 #

• 对于输入迭代器（InputIterator），C++标准仅强制要求实现前置++和相等比较，后置++是可选的；
• 若要让迭代器满足**前向迭代器（ForwardIterator）**的完整要求，则必须实现后置++；
• 在C++20范围（ranges）体系中，范围for循环仅依赖前置++，因此即便不实现后置++，范围for也能正常运行，但如果需要迭代器适配更多标准库算法，建议补全后置++实现。

问题2：用空std::optional表示end()的合理性 #

这种方式是合理的，但需要注意部分细节：

合理性分析 #

• 空std::optional<T>可以清晰标记迭代器到达末尾：当try_next()返回false时，m_v会被置为空，与默认构造的end()迭代器状态完全一致；
• 当前的operator==逻辑（!m_v && !other.m_v）能正确识别两个end()迭代器，符合迭代器相等性的核心要求。

需要注意的细节 #

1. 非end迭代器的相等性缺失：当前的operator==仅判断两个end()的情况，对于非end()的迭代器，即便指向同一记录也会返回false，不符合前向迭代器的完整要求。若需要满足前向迭代器特性，需补充非end场景的相等判断逻辑（比如为Recordset增加位置标识）；
2. 悬空引用/指针风险：operator*和operator->返回的是std::optional<T>内部对象的指针/引用，当迭代器被移动或销毁后，这些指针/引用会悬空，使用时需确保迭代器生命周期长于引用/指针的使用周期。

内容的提问来源于stack exchange，提问作者Alexey Starinsky