3

Typeコピーできないクラスがあり、デフォルトのコンストラクターが含まれています。A上記のクラスのセットとして機能する2番目のクラスがあります。この 2 番目のクラスはイテレータを介してアクセスを提供し、私のイテレータには逆参照演算子があります。

class A {
    class iterator {
        [...]
      public:
        Type & operator*()
        { 
            return instance;
        }
      private:
        Type instance;
    }
    [...]
};

boost::pythonここで、次のようなコードを書いたことを明らかにします。

class_<A>("A", [...])
    .def("__iter__", iterator<A, return_internal_reference<> >())
    .def("__len__", container_length_no_diff<A, A::iterator>)
;

コード Python のすべてのイテレータ操作 (構築、代入、逆参照、破棄) に出力メッセージを追加した後、次のようにします。

for o in AInstance:
    print o.key

出力を取得します（重要な部分にトリミングされています）：

construct 0xffffffff7fffd3e8
dereference: 0xffffffff7fffd3e8
destroy 0xffffffff7fffd3e8
get key 0xffffffff7fffd3e8

上記のコードでは、これらのアドレスはinstanceメンバー (またはthisメソッド呼び出し) のアドレスです。最初の 3 行は によって生成されiterator、4 行目は の getter メソッドによって出力されTypeます。したがって、どういうわけかboost::python、次のような方法ですべてをラップします。

  1. イテレータを作成します
  2. イテレータを逆参照し、参照を格納します
  3. イテレータ (およびそれに含まれるオブジェクト) を破棄します
  4. ステップ 2 で取得した参照を使用

したがって、メソッド呼び出しの結果が参照されている限り、オブジェクトを保持する必要がある場合は、明らかにreturn_internal_reference述べたように動作しません (実際には typedef over であることに注意してください)。with_custodian_and_ward_postcall<>

だから私の質問は、そのようなイテレータをPythonにどのように公開するのboost::pythonですか?

編集：

指摘されたように、明確ではないかもしれません: 元のコンテナには type のオブジェクトが含まれていませんType。BaseTypeオブジェクトを構築/変更できるいくつかのオブジェクトが含まれていTypeます。したがってiterator、上記の例では のように動作しtransform_iteratorます。

4

3 に答える 3

1

Aがのインスタンスを所有するコンテナの場合、：ではなくへのハンドルを含めることTypeを検討してください。A::iteratorTypeType

class iterator {
  [...]
private:
  Type* instance; // has a handle to a Type instance.
};

それ以外の：

class iterator {
  [...]
private:
  Type instance; // has a Type instance.
};

Pythonでは、イテレーターには、イテレーターが反復するコンテナーへの参照が含まれます。これにより、反復可能オブジェクトの寿命が延び、反復中に反復可能オブジェクトがガベージコレクションされるのを防ぐことができます。

>>> from sys import getrefcount
>>> x = [1,2,3]
>>> getrefcount(x)
2 # One for 'x' and one for the argument within the getrefcount function.
>>> iter = x.__iter__()
>>> getrefcount(x)
3 # One more, as iter contains a reference to 'x'.

boost::pythonこの動作をサポートします。これはサンプルプログラムで、Fooコピーできない単純なタイプです。FooContainer反復可能なコンテナであること。FooContainer::iteratorイテレータであること：

#include <boost/python.hpp>
#include <iterator>

// Simple example type.
class Foo
{
public:
  Foo()  { std::cout << "Foo constructed: " << this << std::endl; }
  ~Foo() { std::cout << "Foo destroyed:   " << this << std::endl; }
  void set_x( int x ) { x_ = x;    }
  int  get_x()        { return x_; }
private:
  Foo( const Foo& );            // Prevent copy.
  Foo& operator=( const Foo& ); // Prevent assignment.
private:
  int x_;  
};

// Container for Foo objects.
class FooContainer
{
private:
  enum { ARRAY_SIZE = 3 };
public:
  // Default constructor.
  FooContainer()
  {
    std::cout << "FooContainer constructed: " << this << std::endl;
    for ( int i = 0; i < ARRAY_SIZE; ++i )
    {
      foos_[ i ].set_x( ( i + 1 ) * 10 );
    }
  }

  ~FooContainer()
  {
    std::cout << "FooContainer destroyed:   " << this << std::endl;
  }

  // Iterator for Foo types.  
  class iterator
    : public std::iterator< std::forward_iterator_tag, Foo >
  {
    public:
      // Constructors.
      iterator()                      : foo_( 0 )        {} // Default (empty).
      iterator( const iterator& rhs ) : foo_( rhs.foo_ ) {} // Copy.
      explicit iterator(Foo* foo)     : foo_( foo )      {} // With position.

      // Dereference.
      Foo& operator*() { return *foo_; }

      // Pre-increment
      iterator& operator++() { ++foo_; return *this; }
      // Post-increment.     
      iterator  operator++( int )
      {
        iterator tmp( foo_ );
        operator++();
        return tmp;
      }

      // Comparison.
      bool operator==( const iterator& rhs ) { return foo_ == rhs.foo_; }
      bool operator!=( const iterator& rhs )
      {
        return !this->operator==( rhs );
      }

    private:
      Foo* foo_; // Contain a handle to foo; FooContainer owns Foo.
  };

  // begin() and end() are requirements for the boost::python's 
  // iterator< container > spec.
  iterator begin() { return iterator( foos_ );              }
  iterator end()   { return iterator( foos_ + ARRAY_SIZE ); }
private:
  FooContainer( const FooContainer& );            // Prevent copy.
  FooContainer& operator=( const FooContainer& ); // Prevent assignment.
private:
  Foo foos_[ ARRAY_SIZE ];
};

BOOST_PYTHON_MODULE(iterator_example)
{
  using namespace boost::python;
  class_< Foo, boost::noncopyable >( "Foo" )
    .def( "get_x", &Foo::get_x )
    ;
  class_< FooContainer, boost::noncopyable >( "FooContainer" )
    .def("__iter__", iterator< FooContainer, return_internal_reference<> >())
    ;
}

出力例は次のとおりです。

>>> from iterator_example import FooContainer
>>> fc = FooContainer()
Foo constructed: 0x8a78f88
Foo constructed: 0x8a78f8c
Foo constructed: 0x8a78f90
FooContainer constructed: 0x8a78f88
>>> for foo in fc:
...   print foo.get_x()
... 
10
20
30
>>> fc = foo = None
FooContainer destroyed:   0x8a78f88
Foo destroyed:   0x8a78f90
Foo destroyed:   0x8a78f8c
Foo destroyed:   0x8a78f88
>>> 
>>> fc = FooContainer()
Foo constructed: 0x8a7ab48
Foo constructed: 0x8a7ab4c
Foo constructed: 0x8a7ab50
FooContainer constructed: 0x8a7ab48
>>> iter = fc.__iter__()
>>> fc = None
>>> iter.next().get_x()
10
>>> iter.next().get_x()
20
>>> iter = None
FooContainer destroyed:   0x8a7ab48
Foo destroyed:   0x8a7ab50
Foo destroyed:   0x8a7ab4c
Foo destroyed:   0x8a7ab48
于 2012-07-02T19:12:17.047 に答える
1

iterator全体的な問題は、クラスが提供すべきセマンティクスを完全に理解していなかったことだと思います。イテレータではなく、コンテナが存在する限り、イテレータによって返される値は有効でなければならないようです。

これはboost::pythonが正しく動作することを意味し、それには 2 つの解決策があります。

  • 使用するboost::shared_ptr
  • 値で返す

私がやろうとした方法よりも少し効率の悪いアプローチですが、他に方法がないようです。

編集: 私は解決策を考え出しました(可能であるだけでなく、うまく機能しているようです): Boost python container、iterator、およびitemのライフタイム

于 2012-07-02T16:07:49.317 に答える
0

関連するサンプルは次のとおりです: https://wiki.python.org/moin/boost.python/iterator。const / non const referenceでイテレータ値を返す
ことができます:

...
.def("__iter__"
     , range<return_value_policy<copy_non_const_reference> >(
           &my_sequence<heavy>::begin
         , &my_sequence<heavy>::end))

あなたが述べたように、戻り値のイテレータの有効期間ではなく、コンテナの有効期間にバインドする必要があるという考えです。

于 2014-01-11T06:10:20.623 に答える