Analisis Mekanisme Lulus Rujukan Pybind11 dan C

Apabila menggunakan Pybind11 untuk mendedahkan kod C ke Python, adalah penting untuk memahami bagaimana parameter yang dilalui dalam C (mengikut nilai, dengan rujukan, dengan penunjuk) peta untuk membantah tingkah laku dalam Python. Kekeliruan yang sama adalah sama ada bahagian Python dapat mengesan perubahan ini apabila fungsi C mengubah objek dengan rujukan.

1. Tingkah laku lulus rujukan objek tunggal

Pertama, mari kita lihat kelas asas C dan fungsi yang mengubah kandungannya.

Contoh kod C:

 // mymodule.cpp
#include <pybind11>
#include <vector>

ruang nama py = pybind11;

// Tentukan kelas C yang sederhana a
Kelas A {
awam:
    int n = 0;
    double val = 0.0;
    A () = lalai; // pembina lalai};

// Fungsi b: Lulus objek dengan nilai sebaris void b_by_value (a) {
    an = 1;
    A.VAL = 0.1;
}

// Fungsi b: Lulus objek A dengan rujukan inline void b_by_reference (a & a) {
    AN = 2;
    A.Val = 0.2;
}

// pybind11 mengikat kod pybind11_module (mymodule, m) {
    m.doc () = "Pybind11 Contoh untuk lulus rujukan";

    py :: class_ <a> (m, "a")
        .def (py :: init  ())
        .def_readWrite ("n", & a :: n)
        .def_readWrite ("val", & a :: val);

    m.def ("b_by_value", & b_by_value, "mengubah nilai dengan nilai (tiada perubahan dalam python)");
    m.def ("b_by_reference", & b_by_reference, "mengubah suai dengan rujukan (perubahan yang dicerminkan dalam python)");
}</a></vector></pybind11>

Contoh Interaktif Python:

 import mymodule

# 1. Lulus a_val dengan nilai = myModule.a ()
cetak (f "sebelum b_by_value: a_val.n = {a_val.n}, a_val.val = {a_val.val}")
mymodule.b_by_value (a_val)
cetak (f "selepas b_by_value: a_val.n = {a_val.n}, a_val.val = {a_val.val}")
# Hasil: a_val belum diubah suai # 2. Pass a_ref dengan rujukan = myModule.a ()
cetak (f "sebelum b_by_reference: a_ref.n = {a_ref.n}, a_ref.val = {a_ref.val}")
mymodule.b_by_reference (a_ref)
cetak (f "selepas b_by_reference: a_ref.n = {a_ref.n}, a_ref.val = {a_ref.val}")
# Hasil: A_REF berjaya diubah suai

Seperti yang dapat dilihat dari contoh di atas, apabila fungsi C menerima objek tunggal melalui rujukan tidak konsisten, PYBIND11 dapat memetakan objek Python dengan betul ke rujukan C, yang membolehkan pengubahsuaian di sisi C dapat dicerminkan pada sisi python.

2. Perangkap objek lulus dengan rujukan

Walau bagaimanapun, keadaan menjadi rumit apabila fungsi C perlu mengubah suai senarai yang mengandungi pelbagai objek (seperti STD :: vektor ). Jika fungsi C menerima std :: vektor & sebagai parameter dan mengubah elemen dalamannya, pengubahsuaian ini mungkin tidak dapat dilihat dalam objek senarai yang sepadan di sisi python.

Contoh kod C (Versi Masalah):

 // kemudian mymodule.cpp di atas
// ... (kod mengikat antara kelas A dan py :: class_ <a> kekal tidak berubah)

// Fungsi C: Lulus senarai objek dengan rujukan sebaris void c_list_by_reference (std :: vector </a><a> & alist) {
    untuk (auto & a: alist) {
        an = 3;
        A.VAL = 0.3;
    }
}

// pybind11 mengikat kod pybind11_module (mymodule, m) {
    // ... (mengikat antara Kelas A dan B_By_Value, b_by_reference kekal tidak berubah)
    m.def ("c_list_by_reference", & c_list_by_reference, "mengubah senarai dengan rujukan (elemen mungkin tidak dikemas kini dalam python)");
}</a>

Contoh interaktif Python (pembiakan masalah):

 import mymodule

# Buat senarai python yang mengandungi objek list_a = [myModule.a (), myModule.a ()]
cetak (f "sebelum c_list_by_reference:")
Untuk saya, OBJ dalam Enumerate (list_a):
    cetak (f "list_a [{i}]: n = {obj.n}, val = {obj.val}")

mymodule.c_list_by_reference (list_a)

cetak (f "selepas c_list_by_reference:")
Untuk saya, OBJ dalam Enumerate (list_a):
    cetak (f "list_a [{i}]: n = {obj.n}, val = {obj.val}")
# Hasil: unsur -unsur dalam list_a belum diubah suai

Walaupun fungsi C c_list_by_reference secara dalaman mengubah setiap objek dalam std :: vektor Dengan rujukan, pengubahsuaian ini tidak dapat dilihat pada objek A dalam list_a python. Ini biasanya kerana pybind11, apabila menukar senarai python ke std :: vektor &, mungkin telah membuat salinan objek A, atau mekanisme dalamannya, walaupun ia adalah rujukan, gagal memetakan perubahan kepada unsur -unsur dalam vektor C kembali ke unsur -unsur asal senarai Python.

3. Penyelesaian: Gunakan senarai penunjuk lulus

Untuk menyelesaikan masalah std :: vektor & pengubahsuaian tidak berkuatkuasa, kunci adalah untuk memastikan bahawa fungsi C beroperasi pada contoh objek C yang sama yang dirujuk oleh objek Python. Ini boleh dicapai dengan lulus std :: vektor (iaitu senarai petunjuk kepada objek).

Contoh kod C (penyelesaian):

 // kemudian mymodule.cpp di atas
// ... (kod mengikat antara kelas A dan py :: class_ <a> kekal tidak berubah)

// Fungsi D: Lulus senarai penunjuk objek dengan rujukan inline void d_list_by_pointer_reference (std :: vector </a><a> & alist_ptrs) {
    untuk (a* a_ptr: alist_ptrs) {
        jika (a_ptr) {// semak jika penunjuk itu kosong a_ptr-> n = 4;
            a_ptr-> val = 0.4;
        }
    }
}

// pybind11 mengikat kod pybind11_module (mymodule, m) {
    // ... (mengikat antara kelas A dan B_By_Value, b_by_reference, c_list_by_reference kekal tidak berubah)
    m.def ("d_list_by_pointer_reference", & d_list_by_pointer_reference, "Mengubah senarai menggunakan petunjuk (perubahan yang ditunjukkan dalam python)");
}</a>

Contoh Interaktif Python (Penyelesaian Pengesahan):

 import mymodule

# Buat senarai python yang mengandungi objek list_a_solution = [myModule.a (), myModule.a ()]
cetak (f "sebelum d_list_by_pointer_reference:")
Untuk saya, OBJ dalam Enumerate (list_a_solution):
    cetak (f "list_a_solution [{i}]: n = {obj.n}, val = {obj.val}")

mymodule.d_list_by_pointer_reference (list_a_solution) # pybind11 secara automatik akan menukar objek dalam senarai python ke*

cetak (f "selepas d_list_by_pointer_reference:")
Untuk saya, OBJ dalam Enumerate (list_a_solution):
    cetak (f "list_a_solution [{i}]: n = {obj.n}, val = {obj.val}")
# Hasil: unsur -unsur dalam list_a_solution berjaya diubah suai

Apabila fungsi C menerima std :: vektor , pybind11 melangkah melalui senarai python, mendapat penunjuk kepada contoh asas C setiap objek A, dan membina std :: vektor untuk lulus ke fungsi c. Fungsi C secara langsung mengubah objek asal C melalui petunjuk ini, dan pengubahsuaian ini secara semulajadi dapat dilihat dalam objek yang sepadan di sisi python.

Nota dan ringkasan

1. Pemilihan Jenis Parameter:
   • Untuk objek tunggal, adalah sah untuk menggunakan T & sebagai jenis parameter jika fungsi C perlu mengubahnya.
   • Untuk bekas yang mengandungi pelbagai objek (seperti std :: vektor ), jika fungsi C perlu mengubahsuai unsur -unsur dalam bekas, std :: vektor harus digunakan sebagai jenis parameter. Jika fungsi C hanya mengubah bekas itu sendiri (seperti menambahkan atau mengeluarkan unsur -unsur), maka STD :: vektor & boleh berfungsi, tetapi menyedari masalah kitaran hayat dan penyegerakan senarai Python.
2. Pemeriksaan penunjuk null: Apabila mengendalikan std :: vektor Dalam fungsi C, ia sentiasa disyorkan untuk melakukan pemeriksaan penunjuk null (jika (a_ptr)) untuk mengelakkan kesilapan runtime yang berpotensi.
3. Pengurusan Pemilikan: Dalam senario tutorial ini, objek dalam senarai Python mempunyai kitaran hayatnya yang diuruskan oleh Python. F Fungsi hanya mengakses dan mengubahsuai objek sedia ada ini melalui petunjuk, dan tidak melibatkan peruntukan memori atau pelepasan, jadi tidak perlu bimbang tentang isu pemilikan memori di sisi C. Tetapi dalam senario yang lebih kompleks, jika fungsi C perlu membuat objek baru dan mengembalikannya atau menguruskan kitaran hayatnya, anda perlu berhati -hati mempertimbangkan dasar pemilikan pybind11 (py :: Keep_alive, py :: return_value_policy, dll.).
4. Kejelasan dan kebolehbacaan: Walaupun menggunakan senarai petunjuk menyelesaikan masalah, ia juga memperkenalkan konsep petunjuk, yang mungkin sedikit rumit untuk pemaju Python yang tidak biasa dengan C. Apabila merancang API, anda harus menimbang prestasi, keperluan berfungsi, dan kemudahan penggunaan API.

Dengan memahami tingkah laku pybind11 apabila berurusan dengan jenis parameter C yang berbeza, terutamanya untuk senario di mana unsur -unsur dalam bekas diubahsuai, kita boleh memilih jenis parameter C yang betul (seperti STD :: vektor ) untuk memastikan tingkah laku yang dijangkakan penyegerakan data antara python dan C.