如何比较将指针包装到现有 C++ 的 Python 对象结构?

发布于 2024-12-01 00:21:45 字数 765 浏览 0 评论 0原文

我有一个类方法,它返回一个指向内部数据结构的指针(其中数据结构保证比它在 python 代码中的使用更长久)。它看起来像:

class MyClass {
    ...

    some_structure* get() {
        return inner_structure_;
    }

    private:
    some_structure* inner_structure_;
};

我想在 Boost::Python 中包装这个 get() 方法,这样如果这个类的两个不同对象返回相同的指针,则关联的 some_struct 对象在Python中比较相等。

class_ 定义中,我尝试使用 return_value_policy()return_inner_reference包装 get() 。 >() 调用策略,但在这两种情况下,在不同的 python“MyClass”对象上调用 get() 返回不同的结果some_struct 对象,即使它们在 C++ 中都指向相同的内存地址。

我该如何解决这个问题?包装对象内部是否有一个隐藏属性来存储指针的地址,以便我可以比较它们?

I have a class method that returns a pointer to an inner data structure (where the data structure is guaranteed to outlive its use in python code). It looks like:

class MyClass {
    ...

    some_structure* get() {
        return inner_structure_;
    }

    private:
    some_structure* inner_structure_;
};

I want to wrap this get() method in Boost::Python so that if two different objects of this class return the same pointer, the associated some_structure objects in python compare equal.

Inside the class_<MyClass> definition I've tried wrapping get() with both return_value_policy<reference_existing_object>() and return_inner_reference<>() call policies, but in both cases, calling get() on different python "MyClass" objects returns different some_structure objects even though all point to the same memory address in C++.

How would I get around this? Might there be a hidden property inside the wrapper object that stores the pointer's address, so I can compare those instead?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(1

半暖夏伤 2024-12-08 00:21:45

找到了一种方法来做到这一点,尽管它仍然感觉很黑客,并且应该有一些更简单的方法。但这里是:

1)定义您自己的比较指针的方法。

template <typename T>
bool eq(const T* self, const T* rhs) {                
  return self == rhs;                                                           
}                                                                               

template <typename T>                                                           
bool ne(const T* self, const T* rhs) {                
  return !eq<T>(self, rhs);                                              
}

2) 在包装类中手动声明 __eq__ 和 __ne__ 来指向这些方法:

class_<smth>("smth", no_init)
  ...
  .def("__eq__", &eq<smth>)
  .def("__ne__", &ne<smth>);

Figured out a way to do it, although it still feels hackish and that there should be some easier way. But here goes:

1) Define your own methods that compare the pointers.

template <typename T>
bool eq(const T* self, const T* rhs) {                
  return self == rhs;                                                           
}                                                                               

template <typename T>                                                           
bool ne(const T* self, const T* rhs) {                
  return !eq<T>(self, rhs);                                              
}

2) Manually declare the __eq__ and __ne__ inside the wrapper class to point to those methods:

class_<smth>("smth", no_init)
  ...
  .def("__eq__", &eq<smth>)
  .def("__ne__", &ne<smth>);
~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文