我有一个c ++ 11函数，它返回一个：
std::vector<const T*> f();
T是一个c ++类，我用class_暴露给python。所有T实例都驻留在静态存储中，这些存储将在python进程的实时中存在。
我试图将f作为python函数公开
getAllTs()
会返回T周围的python对象包装器。我选择T *作为类_的保持类型。
我正在使用这个糟糕的半泛型函数将std :: vector转换为python元组：
template <typename Cont>
struct stdcont_to_python_tuple
{
static PyObject* convert(const Cont& container)
{
boost::python::list lst;
for (const auto& elt: container)
lst.append(elt);
return boost::python::incref( boost::python::tuple(lst).ptr() );
}
static PyTypeObject const* get_pytype()
{
return &PyTuple_Type;
}
};
我无法从容器构造元组目录。这可能吗？
我需要在UI表中显示这些Ts，执行排序，过滤。
T实例的最大数量为30000个奇数。在c ++ 11中：
sizeof(T) = 24 bytes
在python3中：
sys.getsizeof(t) = 72 bytes
我可以使用什么退货策略来定义getAllTs以最大限度地减少重复，即通过python添加最少的额外内容？
由于
答案 0 :(得分：1)
std::vector<const T*>公开给Python 公开std::vector<...>的最简单方法是将其公开为boost::python::class_，并使用vector_indexing_suite提供类似接口的Python序列。
std::vector<const spam*> get_spams() { ... }
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
// Expose `spam`
python::class_<spam, spam*>("Spam");
// Expose `std::vector<const spam*>`
python::class_<std::vector<const spam*>>("Spams")
.def(python::vector_indexing_suite<std::vector<const spam*>>())
;
python::def("get_spams", &get_spams);
}
但是，使用类型const spam*可能不如人们希望的那样富有成效。首先，Python没有const的概念。此外，当spam类被spam*保持时，自动to-python和from-python转换器用于spam*，而不是const spam*。由于索引编制套件在索引期间返回代理，这可能不会立即显现，但在迭代时它将变得明显，因为迭代器的值将尝试转换为Python。
spams = example.get_spams()
# Access by index returns a proxy. It does not perform a
# spam-to-python conversion.
spams[0].perform()
# The iterator's value will be returned, requiring a
# spam-to-python conversion.
for spam in spams:
pass
要解决此问题，可以为const spam*注册显式的to-python转换。我强烈考虑重新审核是否有必要使用const spam*，或者将spam暴露为不同类型的内容会更容易（例如boost::shared_ptr使用空删除器）。无论如何，这是一个完整的示例demonstrating此功能：
#include <iostream>
#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
/// Mocks...
struct spam
{
spam() { std::cout << "spam() " << this << std::endl; }
~spam() { std::cout << "~spam() " << this << std::endl; }
void perform() { std::cout << "spam::perform() " << this << std::endl; }
};
namespace {
std::array<spam, 3> spams;
} // namespace
std::vector<const spam*> get_spams()
{
std::vector<const spam*> result;
for (auto& spam: spams)
{
result.push_back(&spam);
}
return result;
}
/// @brief Convert for converting `const spam*` to `Spam`.
struct const_spam_ptr_to_python
{
static PyObject* convert(const spam* ptr)
{
namespace python = boost::python;
python::object object(python::ptr(ptr));
return python::incref(object.ptr());
}
};
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
// Enable `const spam*` to `Spam` converter.
python::to_python_converter<const spam*, const_spam_ptr_to_python>();
// Expose `spam`.
python::class_<spam, spam*>("Spam", python::no_init)
.def("perform", &spam::perform)
;
// Expose `std::vector<const spam*>`.
python::class_<std::vector<const spam*>>("Spams")
.def(python::vector_indexing_suite<std::vector<const spam*>>())
;
python::def("get_spams", &get_spams);
}
交互式使用：
>>> import example
spam() 0x7ffbec612218
spam() 0x7ffbec612219
spam() 0x7ffbec61221a
>>> spams = example.get_spams()
>>> for index, spam in enumerate(spams):
... spams[index].perform()
... spam.perform()
...
spam::perform() 0x7ffbec612218
spam::perform() 0x7ffbec612218
spam::perform() 0x7ffbec612219
spam::perform() 0x7ffbec612219
spam::perform() 0x7ffbec61221a
spam::perform() 0x7ffbec61221a
~spam() 0x7ffbec61221a
~spam() 0x7ffbec612219
~spam() 0x7ffbec612218
可以从序列构建boost::python::tuple。如果提供了C ++对象，则需要将其转换为实现Python迭代器协议的Python类型。例如，在上面的示例中，当std::vector<const spam*>被公开并通过vector_indexing_suite提供类似接口的序列时，可以将get_spams()写为：
boost::python::tuple get_spams()
{
std::vector<const spam*> result;
for (auto& spam: spams)
{
result.push_back(&spam);
}
return boost::python::tuple(result);
}
或者，可以使用boost/python/iterator.hpp文件提供的类型和函数从C ++容器或迭代器创建Python迭代器。这些示例演示了将std::pair迭代器（开始和结束）公开给Python。由于std::pair将提供to-python转换，因此可以从boost::python::tuple构建std::pair。
这是一个竞争示例demonstrating这种方法：
#include <boost/python.hpp>
/// @brief Returns a tuple, constructing it form a range.
template <typename Container>
boost::python::tuple container_to_tuple(Container& container)
{
namespace python = boost::python;
return python::tuple(std::make_pair(
container.begin(), container.end()));
}
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
// Expose an int range.
typedef std::vector<int>::iterator vector_int_iterator;
typedef std::pair<vector_int_iterator, vector_int_iterator> vector_int_range;
python::class_<vector_int_range>("IntRange")
.def("__iter__", python::range(
&vector_int_range::first, &vector_int_range::second))
;
// Return a tuple of ints.
python::def("get_ints", +[] {
std::vector<int> result;
result.push_back(21);
result.push_back(42);
return container_to_tuple(result);
});
}
交互式使用：
>>> import example
>>> ints = example.get_ints()
>>> assert(isinstance(ints, tuple))
>>> assert(ints == (21, 42))
如果C ++对象已经存在，可以通过指针使python::object引用它，这将减少重复一些整体内存使用。但是，没有选项可以减少Boost.Python类的实例的基本占用空间，这些类来自新式类，可变长度数据的大小，C ++对象，vtable指针，指向实例持有者的指针以及实例持有者的填充对准。如果您需要更小的占用空间，那么请考虑直接使用Python / C API进行类型创建，并使用Boost.Python与对象进行交互。