Pybind11中C++函数修改Python传入列表元素的持久化问题及解决方案

// my_module.cpp
#include <pybind11/pybind11.h>
#include <pybind11/stl.h> // 用于支持STL容器，如std::vector
#include <vector>

namespace py = pybind11;

// 定义一个简单的C++类A
class A {
public:
    int n = 0;
    double val = 0.0;
    A() = default; // 默认构造函数
};

// Pybind11绑定代码
PYBIND11_MODULE(my_module, m) {
    m.doc() = "Pybind11 tutorial module";

    py::class_<A>(m, "A")
        .def(py::init<>()) // 暴露默认构造函数
        .def_readwrite("n", &A::n) // 暴露成员变量n的读写权限
        .def_readwrite("val", &A::val); // 暴露成员变量val的读写权限

    // 接下来的函数绑定将在此处添加
}

// my_module.cpp (接上文)
// ...

// 函数B_single_ref：通过引用修改单个A对象
inline void B_single_ref(A& a) {
    a.n = 1;
    a.val = 0.1;
}

PYBIND11_MODULE(my_module, m) {
    // ...
    m.def("B_single_ref", &B_single_ref, "Modifies a single A object by reference.");
}

import my_module

# 创建一个A对象
a_obj = my_module.A()
print(f"Before B_single_ref: n={a_obj.n}, val={a_obj.val}")

# 调用C++函数进行修改
my_module.B_single_ref(a_obj)
print(f"After B_single_ref: n={a_obj.n}, val={a_obj.val}")

# 预期输出：
# Before B_single_ref: n=0, val=0.0
# After B_single_ref: n=1, val=0.1

// my_module.cpp (接上文)
// ...

// 函数B_vector_ref：通过引用修改std::vector<A>中的A对象
// 注意：这种方式对内部元素的修改不会反映到Python
inline void B_vector_ref(std::vector<A>& alist) {
    for (auto& a : alist) {
        a.n = 1;
        a.val = 0.1;
    }
}

PYBIND11_MODULE(my_module, m) {
    // ...
    m.def("B_vector_ref", &B_vector_ref, "Attempts to modify A objects within a std::vector<A> by reference.");
}

import my_module

# 创建一个包含A对象的Python列表
list_of_a = [my_module.A() for _ in range(2)]
print(f"Before B_vector_ref: {[f'n={obj.n}, val={obj.val}' for obj in list_of_a]}")

# 调用C++函数
my_module.B_vector_ref(list_of_a)
print(f"After B_vector_ref: {[f'n={obj.n}, val={obj.val}' for obj in list_of_a]}")

# 预期输出：
# Before B_vector_ref: ['n=0, val=0.0', 'n=0, val=0.0']
# After B_vector_ref: ['n=0, val=0.0', 'n=0, val=0.0']

// my_module.cpp (接上文)
// ...

// 函数B_vector_ptr：通过指针修改std::vector<A*>中的A对象
// 这种方式可以确保修改反映到Python
inline void B_vector_ptr(std::vector<A*> alist) {
    for (auto a_ptr : alist) { // 遍历指针
        if (a_ptr) { // 良好的实践：检查指针是否为空
            a_ptr->n = 1; // 通过指针修改对象
            a_ptr->val = 0.1;
        }
    }
}

PYBIND11_MODULE(my_module, m) {
    // ...
    m.def("B_vector_ptr", &B_vector_ptr, "Modifies A objects within a std::vector<A*> by pointer.");
}

import my_module

# 创建一个包含A对象的Python列表
list_of_a_ptr = [my_module.A() for _ in range(2)]
print(f"Before B_vector_ptr: {[f'n={obj.n}, val={obj.val}' for obj in list_of_a_ptr]}")

# 调用C++函数，现在修改将生效
my_module.B_vector_ptr(list_of_a_ptr)
print(f"After B_vector_ptr: {[f'n={obj.n}, val={obj.val}' for obj in list_of_a_ptr]}")

# 预期输出：
# Before B_vector_ptr: ['n=0, val=0.0', 'n=0, val=0.0']
# After B_vector_ptr: ['n=1, val=0.1', 'n=1, val=0.1']