Question

我正在使用Python绑定（使用boost :: python）表示存储在文件中的数据的C ++库。我的大多数半技术用户将使用Python与之交互，因此我需要尽可能将其设为Pythonic。但是，我也会让C ++程序员使用API，所以我不想在C ++方面妥协以适应Python绑定。

图书馆的很大一部分将由容器制成。为了让python用户看起来很直观，我希望它们的行为类似于python列表，即：

# an example compound class
class Foo:
    def __init__( self, _val ):
        self.val = _val

# add it to a list
foo = Foo(0.0)
vect = []
vect.append(foo)

# change the value of the *original* instance
foo.val = 666.0
# which also changes the instance inside the container
print vect[0].val # outputs 666.0

测试设置

#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
#include <boost/python/register_ptr_to_python.hpp>
#include <boost/shared_ptr.hpp>

struct Foo {
    double val;

    Foo(double a) : val(a) {}
    bool operator == (const Foo& f) const { return val == f.val; }
};

/* insert the test module wrapping code here */

int main() {
    Py_Initialize();
    inittest();

    boost::python::object globals = boost::python::import("__main__").attr("__dict__");

    boost::python::exec(
        "import test\n"

        "foo = test.Foo(0.0)\n"         // make a new Foo instance
        "vect = test.FooVector()\n"     // make a new vector of Foos
        "vect.append(foo)\n"            // add the instance to the vector

        "foo.val = 666.0\n"             // assign a new value to the instance
                                        //   which should change the value in vector

        "print 'Foo =', foo.val\n"      // and print the results
        "print 'vector[0] =', vect[0].val\n",

        globals, globals
    );

    return 0;
}

`shared_ptr`

的方式

使用shared_ptr，我可以获得与上面相同的行为，但这也意味着我必须使用共享指针来表示C ++中的所有数据，从许多角度来看这都不是很好。

BOOST_PYTHON_MODULE( test ) {
    // wrap Foo
    boost::python::class_< Foo, boost::shared_ptr<Foo> >("Foo", boost::python::init<double>())
        .def_readwrite("val", &Foo::val);

    // wrap vector of shared_ptr Foos
    boost::python::class_< std::vector < boost::shared_ptr<Foo> > >("FooVector")
        .def(boost::python::vector_indexing_suite<std::vector< boost::shared_ptr<Foo> >, true >());
}

在我的测试设置中，它产生与纯Python相同的输出：

Foo = 666.0
vector[0] = 666.0

`vector<Foo>`

的方式

直接使用向量可以在C ++端提供一个很好的干净设置。但是，结果的行为方式与纯Python不同。

BOOST_PYTHON_MODULE( test ) {
    // wrap Foo
    boost::python::class_< Foo >("Foo", boost::python::init<double>())
        .def_readwrite("val", &Foo::val);

    // wrap vector of Foos
    boost::python::class_< std::vector < Foo > >("FooVector")
        .def(boost::python::vector_indexing_suite<std::vector< Foo > >());
}

这会产生：

Foo = 666.0
vector[0] = 0.0

这是＆＃34;错误＆＃34; - 更改原始实例并未更改容器内的值。

我希望我不要太多

有趣的是，无论我使用哪两种封装，这段代码都能正常工作：

footwo = vect[0]
footwo.val = 555.0
print vect[0].val

这意味着boost :: python能够处理＆＃34;假共享所有权＆＃34; （通过其 by_proxy 返回机制）。插入新元素时有没有办法实现同样的目标？

但是，如果答案是否定的，我很乐意听到其他建议 - Python工具包中是否有一个示例，其中实现了类似的集合封装，但其行为不像python列表？

非常感谢你阅读这篇文章：）

Answer 1

不幸的是，答案是否定的，你不能做你想做的事。在python中，一切都是指针，列表是指针的容器。共享指针的C ++向量起作用，因为底层数据结构或多或少等同于python列表。你要求的是让分配的内存的C ++向量像一个指针向量，这是不可能完成的。

让我们看看python列表中发生了什么，使用C ++等效的伪代码：

foo = Foo(0.0)     # Foo* foo = new Foo(0.0)
vect = []          # std::vector<Foo*> vect
vect.append(foo)   # vect.push_back(foo)

此时，foo和vect[0]都指向相同的已分配内存，因此更改*foo会更改*vect[0]。

现在使用vector<Foo>版本：

foo = Foo(0.0)      # Foo* foo = new Foo(0.0)
vect = FooVector()  # std::vector<Foo> vect
vect.append(foo)    # vect.push_back(*foo)

这里，vect[0]拥有自己分配的内存，并且是* foo的副本。从根本上说，你不能使vect [0]与* foo的内存相同。

另外，在使用footwo时，请注意std::vector<Foo>的生命周期管理：

footwo = vect[0]    # Foo* footwo = &vect[0]

后续附加可能需要移动已分配的向量存储，并且可能使footwo无效（＆amp; vect [0]可能会更改）。

Answer 2

由于语言之间存在语义差异，因此在涉及集合时，将单个可重用解决方案应用于所有方案通常非常困难。最大的问题是，虽然Python集合直接支持引用，但C ++集合需要一定程度的间接，例如具有shared_ptr元素类型。如果没有这种间接性，C ++集合将无法支持与Python集合相同的功能。例如，考虑两个引用同一对象的索引：

s = Spam()
spams = []
spams.append(s)
spams.append(s)

如果没有类似指针的元素类型，则C ++集合不能有两个引用同一对象的索引。然而，根据使用情况和需求，可能有一些选项允许Python用户使用Pythonic-ish接口，同时仍然为C ++维护单个实现。

最Pythonic解决方案是使用自定义转换器将Python可迭代对象转换为C ++集合。有关实施详细信息，请参阅this答案。如果符合以
- 集合的元素复制起来很便宜。
- C ++函数仅对rvalue类型（即std::vector<>或const std::vector<>&）起作用。此限制可防止C ++对Python集合或其元素进行更改。
增强vector_indexing_suite功能，重用尽可能多的功能，例如安全处理索引删除和底层集合重新分配的代理：
- 使用自定义HeldType公开模型，该自定义get_pointer()用作智能指针，并委托给从vector_indexing_suite返回的实例或元素代理对象。
- Monkey修补了将元素插入集合的集合方法，以便将自定义HeldType设置为委托给元素代理。

将类暴露给Boost.Python时，HeldType是嵌入Boost.Python对象中的对象类型。访问包装类型对象时，Boost.Python会为HeldType调用def_visitor。下面的object_holder类提供了将句柄返回给它拥有的实例或元素代理的能力：

/// @brief smart pointer type that will delegate to a python
///        object if one is set.
template <typename T>
class object_holder
{
public:

  typedef T element_type;

  object_holder(element_type* ptr)
    : ptr_(ptr),
      object_()
  {}

  element_type* get() const
  {
    if (!object_.is_none())
    {
      return boost::python::extract<element_type*>(object_)();
    }
    return ptr_ ? ptr_.get() : NULL;
  }

  void reset(boost::python::object object)
  {
    // Verify the object holds the expected element.
    boost::python::extract<element_type*> extractor(object_);
    if (!extractor.check()) return;

    object_ = object;
    ptr_.reset();
  }

private:
  boost::shared_ptr<element_type> ptr_;
  boost::python::object object_;
};

/// @brief Helper function used to extract the pointed to object from
///        an object_holder.  Boost.Python will use this through ADL.
template <typename T>
T* get_pointer(const object_holder<T>& holder)
{
  return holder.get();
}

在支持间接的情况下，唯一剩下的就是修补集合以设置object_holder。一种干净且可重复使用的方法是使用make_function()。这是一个通用接口，允许class_对象以非侵入方式进行扩展。例如，vector_indexing_suite使用此功能。

下面的custom_vector_indexing_suite类修补了append()方法以委托给原始方法，然后使用代理调用object_holder.reset()新设置的元素。这导致object_holder引用集合中包含的元素。

/// @brief Indexing suite that will resets the element's HeldType to
///        that of the proxy during element insertion.
template <typename Container,
          typename HeldType>
class custom_vector_indexing_suite
  : public boost::python::def_visitor<
      custom_vector_indexing_suite<Container, HeldType>>
{
private:

  friend class boost::python::def_visitor_access;

  template <typename ClassT>
  void visit(ClassT& cls) const
  {
    // Define vector indexing support.
    cls.def(boost::python::vector_indexing_suite<Container>());

    // Monkey patch element setters with custom functions that
    // delegate to the original implementation then obtain a 
    // handle to the proxy.
    cls
      .def("append", make_append_wrapper(cls.attr("append")))
      // repeat for __setitem__ (slice and non-slice) and extend
      ;
  }

  /// @brief Returned a patched 'append' function.
  static boost::python::object make_append_wrapper(
    boost::python::object original_fn)
  {
    namespace python = boost::python;
    return python::make_function([original_fn](
          python::object self,
          HeldType& value)
        {
          // Copy into the collection.
          original_fn(self, value.get());
          // Reset handle to delegate to a proxy for the newly copied element.
          value.reset(self[-1]);
        },
      // Call policies.
      python::default_call_policies(),
      // Describe the signature.
      boost::mpl::vector<
        void,           // return
        python::object, // self (collection)
        HeldType>()     // value
      );
  }
};

需要在运行时进行换行，并且无法通过def()在类上直接定义自定义函子对象，因此必须使用CallPolicies函数。对于仿函数，它需要MPL front-extensible sequence和demonstrates代表签名。

以下是{{3}}使用object_holder委托代理人和custom_vector_indexing_suite来修补集合的完整示例。

#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>

/// @brief Mockup type.
struct spam
{
  int val;

  spam(int val) : val(val) {}
  bool operator==(const spam& rhs) { return val == rhs.val; }
};

/// @brief Mockup function that operations on a collection of spam instances.
void modify_spams(std::vector<spam>& spams)
{
  for (auto& spam : spams)
    spam.val *= 2;
}

/// @brief smart pointer type that will delegate to a python
///        object if one is set.
template <typename T>
class object_holder
{
public:

  typedef T element_type;

  object_holder(element_type* ptr)
    : ptr_(ptr),
      object_()
  {}

  element_type* get() const
  {
    if (!object_.is_none())
    {
      return boost::python::extract<element_type*>(object_)();
    }
    return ptr_ ? ptr_.get() : NULL;
  }

  void reset(boost::python::object object)
  {
    // Verify the object holds the expected element.
    boost::python::extract<element_type*> extractor(object_);
    if (!extractor.check()) return;

    object_ = object;
    ptr_.reset();
  }

private:
  boost::shared_ptr<element_type> ptr_;
  boost::python::object object_;
};

/// @brief Helper function used to extract the pointed to object from
///        an object_holder.  Boost.Python will use this through ADL.
template <typename T>
T* get_pointer(const object_holder<T>& holder)
{
  return holder.get();
}

/// @brief Indexing suite that will resets the element's HeldType to
///        that of the proxy during element insertion.
template <typename Container,
          typename HeldType>
class custom_vector_indexing_suite
  : public boost::python::def_visitor<
      custom_vector_indexing_suite<Container, HeldType>>
{
private:

  friend class boost::python::def_visitor_access;

  template <typename ClassT>
  void visit(ClassT& cls) const
  {
    // Define vector indexing support.
    cls.def(boost::python::vector_indexing_suite<Container>());

    // Monkey patch element setters with custom functions that
    // delegate to the original implementation then obtain a 
    // handle to the proxy.
    cls
      .def("append", make_append_wrapper(cls.attr("append")))
      // repeat for __setitem__ (slice and non-slice) and extend
      ;
  }

  /// @brief Returned a patched 'append' function.
  static boost::python::object make_append_wrapper(
    boost::python::object original_fn)
  {
    namespace python = boost::python;
    return python::make_function([original_fn](
          python::object self,
          HeldType& value)
        {
          // Copy into the collection.
          original_fn(self, value.get());
          // Reset handle to delegate to a proxy for the newly copied element.
          value.reset(self[-1]);
        },
      // Call policies.
      python::default_call_policies(),
      // Describe the signature.
      boost::mpl::vector<
        void,           // return
        python::object, // self (collection)
        HeldType>()     // value
      );
  }

  // .. make_setitem_wrapper
  // .. make_extend_wrapper
};

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;

  // Expose spam.  Use a custom holder to allow for transparent delegation
  // to different instances.
  python::class_<spam, object_holder<spam>>("Spam", python::init<int>())
    .def_readwrite("val", &spam::val)
    ;

  // Expose a vector of spam.
  python::class_<std::vector<spam>>("SpamVector")
    .def(custom_vector_indexing_suite<
      std::vector<spam>, object_holder<spam>>())
    ;

  python::def("modify_spams", &modify_spams);
}

交互式使用：

>>> import example
>>> spam = example.Spam(5)
>>> spams = example.SpamVector()
>>> spams.append(spam)
>>> assert(spams[0].val == 5)
>>> spam.val = 21
>>> assert(spams[0].val == 21)
>>> example.modify_spams(spams)
>>> assert(spam.val == 42)
>>> spams.append(spam)
>>> spam.val = 100
>>> assert(spams[1].val == 100)
>>> assert(spams[0].val == 42) # The container does not provide indirection.

由于仍在使用vector_indexing_suite，因此只能使用Python对象的API修改底层C ++容器。例如，在容器上调用push_back可能会导致重新分配底层内存并导致现有Boost.Python代理出现问题。另一方面，可以安全地修改元素本身，例如通过上面的modify_spams()函数完成。

使用boost :: python vector_indexing_suite包装std :: vector

测试设置

`shared_ptr`

`vector<Foo>`

我希望我不要太多

2 个答案: