我应该怎么做才能使我的容器与范围一起工作？

Question

我有一个简单的容器：

template <class T, class Allocator = std::allocator<T>>
class ring
{
public:

    using value_type = T;
    using allocator_type = Allocator;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = T &;
    using const_reference = const T &;
    using pointer = T *;
    using const_pointer = const T *;

private:

    template <class E>
    class ring_iterator
    {
    public:

        using iterator_category = std::random_access_iterator_tag;
        using value_type = E;
        using difference_type = std::ptrdiff_t;
        using reference = E &;
        using pointer = E *;

        ring_iterator(const ring_iterator& other) = default;
        ring_iterator(ring_iterator&& other) = default;

        ring_iterator& operator = (const ring_iterator& other);

        pointer operator-> () const;

        reference operator* () const;

        ring_iterator& operator++ ();

        ring_iterator operator++ (int);

        ring_iterator& operator-- ();

        ring_iterator operator-- (int);

        ring_iterator& operator += (difference_type diff);

        ring_iterator& operator -= (difference_type diff);

        ring_iterator operator + (difference_type diff) const;

        ring_iterator operator - (difference_type diff) const;

        difference_type operator - (const ring_iterator& other) const;

        bool operator == (const ring_iterator& other) const;

        bool operator != (const ring_iterator& other)  const;

        bool operator < (const ring_iterator& other) const;

        operator ring_iterator<const E>() const;
    };

public:

    using iterator = ring_iterator<T>;
    using const_iterator = ring_iterator<const T>;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;

    ring(Allocator alloc = {});

    ring(size_type cap, Allocator alloc = {});

    ring(const ring& other);

    ring(ring&& other);

    ring& operator = (const ring& other);

    ring& operator = (ring&& other);

    ~ring();

    reference front();
    reference back();

    const_reference front() const;
    const_reference back() const;

    void push_front(const value_type& val);

    void push_front(value_type&& val);

    void push_back(const value_type& val);

    void push_back(value_type&& val);

    void pop_front();

    void pop_back();

    void reserve(size_t);

    void clear();

    size_type size() const;
    
    size_type capacity() const;
    
    bool empty() const;
    
    bool full() const;

    reference operator[](size_type index);

    const_reference operator[](size_type index) const;

    reference at(size_type index);

    const_reference at(size_type index) const;

    iterator begin();
    const_iterator begin() const;
    const_iterator cbegin() const;

    iterator end();
    const_iterator end() const;
    const_iterator cend() const;

    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const;
    const_reverse_iterator crbegin() const;

    reverse_iterator rend();
    const_reverse_iterator rend() const;
    const_reverse_iterator crend() const;
};

我应该怎么做才能使下面的代码编译？

#include <vector>
#include <ranges>

//std::vector<int> v; //compiles
ring<int> v;     //does not compile

auto range = v | std::views::transform([](int n) { return n * n; });

MSVC编译器错误：

error C2678: binary '|': no operator found which takes a left-hand operand of type 'ring<int,std::allocator<int>>' (or there is no acceptable conversion)

Answer 1

所以..。经过大量调查后：

迭代器必须有一个公共的默认构造函数。

，我应该做什么来使我的容器与范围一起工作？

它应该满足std::ranges::range的概念

static_assert(std::ranges::range<ring<int>>);

但事实并非如此，错误信息也没有用。所以我们来看看这个概念本身：

template<类T>概念范围=要求(T& t) {范围：：begin (t)；//对前向迭代器范围保持等式：：end(T)；}；

ranges::begin(v)是定义良好的，但是ranges::end(v)给出了错误" error :不匹配对'(const std::ranges::__cust_access::_End) (ring&)‘的调用“，并且也没有提供有用的错误消息。

所以现在我们来看看std::ranges::end

template< class T >
    requires /* see below */
constexpr std::sentinel_for<ranges::iterator_t<T>> auto end(T&& t);

这里的文档有点模糊，但是这里失败的要求是：

static_assert(
    std::sentinel_for<ring<int>::iterator, ring<int>::iterator>
);

也就是说，结束迭代器应该是开始迭代器的前哨。

在这里，我们到达了第一个有用的错误消息：

错误:静态断言失败

89，std::sentinel_for，~^~

注:未满足的限制条件

..。

opt/compiler-explorer/gcc-trunk-20210906/include/c++/12.0.0/concepts:137:30:注意:计算为'false‘的表达式is_constructible_v<_Tp, _Args ...> [with _Tp = ring<int, std::allocator<int> >::ring_iterator<int>; _Args = {}]

137-137= destructible<_Tp> & is_constructible_v<_Tp，_Args...>；_Args...>^

因此，您可以使用它，ring<int>::ring_iterator<int>必须有一个公开可用的默认构造函数。

Answer 2

，我应该做什么来使我的容器与范围一起工作？

您应该设计符合“范围”概念的容器。

简而言之，容器应该提供成员函数begin和end，它们应该返回迭代器和哨兵。end哨兵必须可以从begin迭代器到达。前哨类型可能与迭代器相同。迭代器类型必须符合" iterator“概念。

，我应该怎么做才能使下面的代码编译？

在您的尝试中，ring_iterator不是默认的可初始化的，因此它不是一个Iterator，因此容器不是一个范围。添加一个默认构造函数来解决这个问题。