swig：如何使QList可<T>迭代，如std：：vector

你所要求的——一个 qlist.i swig 文件，它实现了与 std_vector.i 对 std::vector 相同的 Python QList集成级别——是一项不平凡的任务。

我提供了一个非常基本的扩展qlist.i文件（和qlisttest.i向您展示如何使用它），并将尝试解释需要哪些步骤。

qlist.i ：

%{
#include <QList>
%}
%pythoncode %{
class QListIterator:
    def __init__(self, qlist):
        self.index = 0
        self.qlist = qlist
    def __iter__(self):
        return self
    def next(self):
        if self.index >= self.qlist.size():
            raise StopIteration;
        ret = self.qlist.get(self.index)
        self.index += 1
        return ret
    __next__ = next
%}
template<class T> class QList {
public:
class iterator;
typedef size_t size_type;
typedef T value_type;
typedef const value_type& const_reference;
QList();
size_type size() const;
void reserve(size_type n);
%rename(isEmpty) empty;
bool empty() const;
void clear();
%rename(add) push_back;
void push_back(const value_type& x);
%extend {
    const_reference get(int i) throw (std::out_of_range) {
    int size = int(self->size());
    if (i>=0 && i<size)
        return (*self)[i];
    else
        throw std::out_of_range("QList index out of range");
    }
    void set(int i, const value_type& val) throw (std::out_of_range) {
    int size = int(self->size());
    if (i>=0 && i<size)
        (*self)[i] = val;
    else
        throw std::out_of_range("QList index out of range");
    }
    int __len__() {
    return self->size();
    }
    const_reference __getitem__(int i) throw (std::out_of_range) {
    int size = int(self->size());
    if (i>=0 && i<size)
        return (*self)[i];
    else
        throw std::out_of_range("QList index out of range");
    }
    %pythoncode %{
    def __iter__(self):
        return QListIterator(self)
    %}
}
};
%define %qlist_conversions(Type...)
%typemap(in) const QList< Type > & (bool free_qlist)
{
free_qlist = false;
if ((SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 0)) == -1) {
    if (!PyList_Check($input)) {
    PyErr_Format(PyExc_TypeError, "QList or python list required.");
    SWIG_fail;
    }
    Py_ssize_t len = PyList_Size($input);
    QList< Type > * qlist = new QList< Type >();
    free_qlist = true;
    qlist->reserve(len);
    for (Py_ssize_t index = 0; index < len; ++index) {
    PyObject *item = PyList_GetItem($input,index);
    Type* c_item;
    if ((SWIG_ConvertPtr(item, (void **) &c_item, $descriptor(Type *),0)) == -1) {
        delete qlist;
        free_qlist = false;
        PyErr_Format(PyExc_TypeError, "List element of wrong type encountered.");
        SWIG_fail;
    }
    qlist->append(*c_item);
    }
    $1 = qlist;
}
}
%typemap(freearg) const QList< Type > &
{ if (free_qlist$argnum and $1) delete $1; }    
%enddef

qlisttest.i ：

%module qlist;
%include "qlist.i"
%inline %{
class Foo {
public:
    int foo;
};
%}
%template(QList_Foo) QList<Foo>;
%qlist_conversions(Foo);
%inline %{  
int sumList(const QList<Foo> & list) {
    int sum = 0;
    for (int i = 0; i < list.size(); ++i) {
        sum += list[i].foo;
    }
    return sum;
}
%}

1. 包装QList，使其及其方法可从 python
   访问这是通过使（部分）类定义可用于 swig 来实现的。这就是你当前qlist.i所做的。
   注意：您可能需要为QList<T*> typedefs const T* const_reference的情况添加"模板专用化"，因为您使用的是QList指针。否则，QList<T*>::const_reference将被const T*&，这显然可能会混淆swig。（见swig/Lib/std/std_vector.i）

2. 在python列表和QList
   之间自动转换这通常是通过使用 swig 类型图来实现的。例如，如果您希望函数f(const QList<int>& list)能够接受 python 列表，则需要指定一个输入类型映射来执行从 python 列表到QList<int>的转换：

   %typemap(in) const QList<int> &
   {
       PyObject * py_list = $input;
       [check if py_list is really a python list of integers]
       QList<int>* qlist = new QList<int>();
       [copy the data from the py_list to the qlist]
       $1 = qlist;
   }
   %typemap(freearg) const QList<int> &
   { if ($1) delete $1; }
   

   在这里，情况在几个方面更加困难：

   • 您希望能够传递python列表或包装QList：为此，您需要在类型图中处理这两种情况。
   • 您想将包装类型的 python 列表转换为T QList<T>：
     这还涉及将列表中的每个元素从包装类型T转换为普通T。这是通过 swig 函数SWIG_ConvertPtr 实现的。
   • 我不确定您是否可以使用模板参数指定类型图。因此，我编写了一个 swig 宏%qlist_conversions(Type)，您可以使用它来将类型图附加到特定Type的QList<Type>。

   对于另一个转换方向（QList -> python 列表），您应该首先考虑您想要什么。考虑一个返回QList<int>的C++函数。从 python 调用它，它应该返回一个包装的 QList 对象，还是应该自动将QList转换为 python 列表？

3. 将包装的QList作为 python 序列访问，即从 python
   进行len和[]工作为此，您需要使用 %extend { ... } 扩展 qlist.i 文件中的 QList 类，并实现__len__和__getitem__方法。

   如果切片也应该有效，则需要提供一个__getitem__(PySliceObject *slice)__成员方法和输入以及PySliceObject的"类型检查"类型图。

   如果你想能够使用 python 的[]修改包装QList中的值，你需要实现__setitem__ .

   有关可以实现

   以实现更好集成的所有有用方法的列表，请参阅有关"内置类型"和"容器的抽象基类"的 python 文档。

   注意：如果您使用 swig -builtin 功能，则需要将上述功能额外注册到相应的"插槽"，

   例如

   %feature("python:slot", "sq_length", functype="lenfunc") __len__;
   

4. 使包装QList可从 python
   迭代为此，您需要扩展 QList 类并实现一个返回 python 迭代器对象的 __iter__() 方法。

   python 迭代器对象是提供方法__iter__()和__next__()的对象（对于较旧的 python，next()），其中 __next__() 返回下一个值并引发 python 异常StopIteration以表示结束。

   如前所述，您可以在 python 或 C++ 中实现迭代器对象。我展示了一个在python中执行此操作的示例。

我希望这有助于您调整所需功能的基础。

你回答了"如何使python对象可迭代"的问题，但我问的是"我需要如何扩展QList接口文件以使我的QList可迭代？"这更像是一个SWIG，而不是一个与python相关的问题。

我用Java，C#和Python测试了 http://www.swig.org/Doc1.3/Library.html#Library_nn15 的例子。只有 Python 和 C# 提供迭代器。Java生成的接口没有实现Iterable或类似的东西。据我所知，您的问题与目标语言有关。

也许扩展可变序列是你的一个选择。你必须实现的唯一方法是__getitem__、__setitem__、__delitem__、__len__和insert，将它们委托给相应的QList方法。之后，生成的类是可迭代的。

如文档中所述，您需要以下内容：

• QList 应该在 python __iter__() 中有一个返回迭代器对象的方法（如果你用 C 实现它，tp_iter）。
• 迭代器对象应实现__iter__()并返回自身
• 迭代器对象应实现返回下一项或在完成后引发StopIteration的next()。

这可能是在python中最容易做到的，但你也可以用C实现它。

另一种选择是使用 python 生成器来避免实现迭代器类型。为此，QList 需要实现__iter__()但不是返回迭代器，而是简单地yield值。

提到的方法只需要对python可见。您不必在C/Java中提供它们。

另请参阅将 C 库连接到 Python 的 SWIG（从 C 'sequence' 结构创建 'iterable' Python 数据类型）