为什么 boost::python 迭代器跳过第一个元素？

Question

当我尝试在 C++ 中为 Python 实现可迭代对象（使用 boost::python）时，我遇到了一个奇怪的问题。 Python 似乎总是取消引用前面的一个元素，因此，结果它跳过第一个元素并取消引用 "end" 元素。我也不确定我的 return 值策略是否正确选择，但如果我将 int 替换为 std::string 作为元素类型，它似乎是唯一可以正常工作的策略。特意选择了迭代器标签——我打算实现可迭代对象来访问只能遍历一次的资源。

C++代码：

#include <Python.h>
#include <boost/python.hpp>

#include <iostream>
#include <iterator>

int nextInstance{0};

class Foo
{
public:
    class iterator : public std::iterator<std::input_iterator_tag, int>
    {
    public:
        iterator() = delete;
        iterator& operator=(const iterator&) = delete;

        iterator(const iterator& other)
        :
            instance_(nextInstance++),
            pos_(other.pos_)
        {
            std::cout << instance_ << " copy ctor " << other.instance_ << " (" << pos_ << ")\n";
        }

        explicit iterator(int pos)
        :
            instance_(nextInstance++),
            pos_(pos)
        {
            std::cout << instance_ << " ctor (" << pos_ << ")\n";
        }

        bool operator==(iterator& other)
        {
            std::cout << instance_ << " operator== " << other.instance_ << " (" << pos_ << ", " << other.pos_ << ")\n";

            return pos_ == other.pos_;
        }

        int& operator*()
        {
            std::cout << instance_ << " operator* (" << pos_ << ")\n";

            return pos_;
        }

        iterator operator++(int)
        {
            ++pos_;

            std::cout << instance_ << " operator++ (" << pos_ << ")\n";

            return *this;
        }

        ~iterator()
        {
            std::cout << instance_ << " dtor\n";
        }

    private:
        const int instance_;
        int       pos_{0};

    };

    iterator begin()
    {
        std::cout << "begin()\n";

        return iterator(0);
    }

    iterator end()
    {
        std::cout << "end()\n";

        return iterator(3);
    }
};

BOOST_PYTHON_MODULE(pythonIterator)
{
    boost::python::class_<Foo, boost::noncopyable>("Foo", boost::python::init<>())
        .def("__iter__", boost::python::iterator<Foo, boost::python::return_value_policy<boost::python::copy_non_const_reference>>{});
}

Python代码：

#!/usr/bin/python

import pythonIterator

foo = pythonIterator.Foo()

for i in foo:
    print i

输出：

end()
0 ctor (3)
begin()
1 ctor (0)
2 copy ctor 1 (0)
3 copy ctor 0 (3)
1 dtor
0 dtor
4 copy ctor 2 (0)
5 copy ctor 3 (3)
3 dtor
2 dtor
4 operator== 5 (0, 3)
4 operator++ (1)
6 copy ctor 4 (1)
6 operator* (1)
6 dtor
1
4 operator== 5 (1, 3)
4 operator++ (2)
7 copy ctor 4 (2)
7 operator* (2)
7 dtor
2
4 operator== 5 (2, 3)
4 operator++ (3)
8 copy ctor 4 (3)
8 operator* (3)
8 dtor
3
4 operator== 5 (3, 3)
5 dtor
4 dtor

Answer 1

您的 post 增量运算符存在错误。具体来说，你实现的是pre-increment，而不是post-increment:

iterator operator++(int)
{
    ++pos_;
    return *this;  // return value *after* having incremented it
}

正确的实施方式是：

iterator operator++(int)
{
    iterator tmp(*this);
    ++pos_;
    return tmp; // return saved tmp *before* having incremented it
}

修复之后：

>>> list(pythonIterator.Foo())
... snip lots of output ...
[0, 1, 2]

Answer 2

哇哦。感谢您终于向我展示了第一个独立的 Boost Python 示例。

所以，让我通过建议使用 Boost Iterator 来为您处理迭代器的复杂性来回报您的服务：

Live On Coliru

#include <Python.h>
#include <boost/python.hpp>
#include <boost/iterator/iterator_facade.hpp>

class Foo
{
public:
    struct iterator : boost::iterator_facade<iterator, int, boost::single_pass_traversal_tag, int>
    {
        iterator(int i) : current_(i) {}

        bool equal(iterator const& other) const { return current_ == other.current_; }
        int dereference() const { return current_; }
        void increment() { ++current_; }
    private:
        int current_;
    };

    iterator begin() { return 0; }
    iterator end()   { return 3; }
};

BOOST_PYTHON_MODULE(pythonIterator)
{
    boost::python::class_<Foo, boost::noncopyable>("Foo", boost::python::init<>())
        .def("__iter__", boost::python::iterator<Foo, boost::python::return_value_policy<boost::python::return_by_value>>{});
}

打印：

$ ./test.py 
0
1
2

当然，制作迭代器 return 副本的选择是受到缺少源范围的启发。（显然 iterator_facade 完全适合左值引用，如果你需要的话）

为什么 boost::python 迭代器跳过第一个元素？

why boost::python iterator skips first element?

c++

python

boost

iterator

boost-python