标签: reverse-iterator

这是什么的论述仅正是在C++标准意味着什么？这是否意味着标记的私人/受保护成员只需要按标准存在,或者它们只是实施的"建议",并不是必需的？

例子包括:

std::error_code::val_
std::wstring_convert::byte_err_string
std::array::elems
std::move_iterator::current
std::reverse_iterator::current
std::ostream_iterator::delim
// And a lot of others

昨天我有机会以相反的顺序迭代一个集合.我发现了这个reverse函数,但这并没有返回迭代器,但实际上创建了一个反向集合.

显然,曾经有一个Reverse迭代器,几年前被删除了.我也可以找到被称为某种东西(类型？)的引用Order.Reverse,但这似乎不适用于我的问题.

该Iterators.jl包具有许多有趣的迭代模式,但显然不是反向迭代.

我当然可以使用该reverse函数,在某些情况下,例如reverse(eachindex(c)),它返回一个反向迭代器,但我更喜欢一般的反向迭代器.

有这样的事吗？

在C++ 11中std::map,是否有一些有效的迭代器x使得++ x保证相等map::begin()？我想检测一下我刚刚调用的函数(我的)是否已经从函数前面走了一个迭代器.该函数将迭代器向后移动一个位置.

答案是否适用于图书馆的其他部分？

我编写了一些代码来获取迭代器,但是必须按相反的顺序进行比较,

template<class ConstBiIter>
bool func(ConstBiIter seq_begin, ConstBiIter seq_end)
{
    ConstBiIter last = std::prev(seq_end);
    while (--last != std::prev(seq_begin)) // --> I need to compare the beginning data
    {
        ......
    }
    return true;
}

在VS2013中,当在调试模式下运行时,--last != std::prev(seq_begin)将导致调试器断言失败并显示错误消息

Expression:string iterator + offset out of range.

但是在Release模式下运行并给出正确的结果是完全可以的,因为在Released模式下没有边界检查.

我的问题是:

1. std::prev(some_container.begin())像哨兵一样使用安全some_container.rend()吗？

2. 我怎么能直接比较一个reverse_iterator用iterator？如果我编写代码: std::cout << (std::prev(some_container.begin())==some_container.rend()) << std::endl;它将无法编译,即使你是reinterpret_cast他们.

我很好奇,如果身体prev(some_container.begin())平等some_container.rend()吗？

已经搜索了很多网,但找不到问题的答案.

我使用reverse_iterator将值插入std :: list.虽然插入发生在预期的适当位置,但我注意到用于插入的原始reverse_iterator的值发生了变化.此外,完全不相关的reverse_iterator的值也会发生变化.我已经能够在一个简单的例子中重现这一点

#include <iostream>
#include <list>
#include <string>

int main()
{
    // Creating a list of values 1, 2, 4, 5
    std::list<int> myList;
    myList.push_back(1);
    myList.push_back(2);
    myList.push_back(4);
    myList.push_back(5);

    // Changing it to 1, 2, 3, 4, 5 by inserting 3
    std::list<int>::reverse_iterator revIter = myList.rbegin();
    while(2 != *revIter)
    {
        std::cout << *revIter << "\t";
        ++revIter;
    }

    std::cout << "\n" << "Reverse iterator now points to " << *revIter;
    // Creating a copy of the reverse Iter before inserting.
    std::list<int>::reverse_iterator newRevIter …

我实现了一个双向迭代器,但它不是对数据结构进行操作,而是返回一个数学系列,可以在两个方向上迭代计算.事实上,我正在迭代整数,使用++和 - 在int上.这意味着数据不存储在不同的结构中,因此当迭代器超出范围时,值也是如此.

尽管如此,我希望下一个代码(最小失败示例)示例能够正常工作,因为迭代器始终保持在范围内.但它不起作用:(

#include <iostream>
#include <iterator>
#include <vector>

class my_iterator : public std::iterator<std::bidirectional_iterator_tag, int> {
  int d_val = 12;
public:
  my_iterator  operator--(int) { std::cout << "decrement--\n"; return my_iterator(); }
  my_iterator &operator--()    { std::cout << "--decrement\n"; return *this; }
  my_iterator  operator++(int) { std::cout << "increment++\n"; return my_iterator(); }
  my_iterator &operator++()    { std::cout << "++increment\n"; return *this; }

  int &operator*() { std::cout << "*dereference\n"; return d_val; }

  bool operator==(my_iterator const  &o) { return false; }
  bool operator!=(my_iterator const  &o) { …

以下代码可在 C++11、C++14 和 C++17 中编译，但不能在 C++20 中编译。标准的什么变化破坏了这段代码？

#include <vector>
#include <utility>

template<typename T>
struct bar
{
    typename T::reverse_iterator x;
};

struct foo
{
    bar<std::vector<std::pair<foo, foo>*>> x;
};

int main()
{
    foo f;
}

错误很长，但可以总结为：

模板参数必须是一个完整的类

我正在研究一个实现自己的迭代器的容器,我正在使用它与std :: reverse_iterator <>来获得反向迭代功能.我可以将反向迭代器分配给rend或rbegin,但是当我尝试访问它的任何功能(例如!=或==)时,我得到:

1   IntelliSense: more than one operator "!=" matches these operands:
        function template "bool std::operator!=(const std::reverse_iterator<_RanIt1> &_Left, const std::reverse_iterator<_RanIt2> &_Right)"
        function template "bool avl::operator!=(const tree &left, const tree &right)"
        operand types are: std::reverse_iterator<avl::avl_iterator<avl::avltree<char, int, std::less<char>, std::allocator<std::pair<const char, int>>>>> != std::reverse_iterator<avl::avl_iterator<avl::avltree<char, int, std::less<char>, std::allocator<std::pair<const char, int>>>>>

我的迭代器运算符重载:

bool operator == ( const avl_iterator& rhs ) const { return ( _node == rhs._node); }
    bool operator != ( const avl_iterator& rhs ) const { return ( _node != rhs._node); …

我注意到下面示例中的使用std::map::reverse_iterator不适用于 C++20，但适用于所有编译器中的 C++17。

演示

演示MSVC

#include <map>
class C; //incomplete type 

class Something
{
    
    //THIS WORKS IN C++17 as well as C++20 in all compilers
    std::map<int, C>::iterator obj1;
    
    //THIS DOESN'T WORK in C++20 in all compilers but works in C++17 in all compilers
    std::map<int, C>::reverse_iterator  obj2;
};

int main()
{
    Something s;
    return 0;
}

我的问题是so(such)发生了什么变化，导致所有编译器中的C++20使用停止工作。std::map::reverse_iteratorC++20

我正在尝试编写一个重载方法，仅当调用它的对象是非常量并且参数中传递的迭代器是非常量时才返回非常量结果。（可以将其视为标准方法begin()，并且begin() const还采用迭代器参数。）

我为普通迭代器制作了一个版本，没有任何问题。但是，由于某种原因，当我尝试对反向迭代器执行相同操作时，我收到有关不明确函数调用的编译错误。

这是一个最小的例子：

#include <vector>

class Foo
{
public:
    void bar(std::vector<int>::iterator x) {}
    void bar(std::vector<int>::const_iterator x) const {}

    void baz(std::vector<int>::reverse_iterator x) {}
    void baz(std::vector<int>::const_reverse_iterator x) const {}
};

int main()
{
    std::vector<int> v;
    Foo foo;
    foo.bar(v.cbegin());  // OK
    foo.baz(v.crbegin()); // ambiguous
}

由于某种原因，如果我const从第二种方法中删除它，它就会编译baz。它也适用于 C++20，但目前我无法使用该版本。

现场演示

如何使该函数baz以与该函数类似的方式工作bar？