C++ 更改C+中的参数值+/Python代码

我的问题如下： 我有一个C++代码，我不能修改我想要的（不是我写的，在一些知识产权限制下）。我必须通过Python main将其与Python代码链接。 我使用boost:：python进行反射。 在代码的某个点，C++函数使用一个C++函数的Python重载函数来修改参数。在Python中使用此函数时效果非常好。但是当用C++函数调用时，参数的修改将不考虑在C++中。 为了模拟这个问题，我编写了一个简化版本，旨在隔离我的问题

这里是C++类：

#include <iostream>
using namespace std;
#include <boost/ref.hpp>

//Class aimed at modeling a C++ user's type that should be used in Python
class C
{
public:
    double myC;
    C(){}
    ~C(){}

    void setValue(double val) {
        myC = val;
    }

    double getValue() {
        return myC;
    }
};

/*
    This class will be derived in Python
    We want to be sure that:
    - void (g) and non void (f) functions are properly reflected and extended in Python
    - a function (h) with a local type (C) will properly use the python overloaded     function of a C++ function (g)
*/

class A
{
public:
    A(){int A_x=0;}
    virtual ~A(){}
    virtual int f(int Ivar){
        Ivar = 0;
        return Ivar;
    }
    virtual void g(C * myC){
        C calledC;
        cout << "I should not be here" << endl;   //When B::setparam call g, it should be the Python g, not the virtual function from base class
        calledC.setValue(0.);
        //return *myC;
    }
    C h(){                  //This function wont be overloaded in Python
        C myC;
        //myC.setValue(0.);
        this->g(&myC);      //We want myC to be modified, and the python overloaded version of g to be used
        cout << "Value back in C++: " << myC.getValue() << endl; //We want to verify if myC has been modified back in C++
        return myC;
    }
};

/*
    This class will be called from a main in Python.
    It's function setparam is aimed at ensuring that Python extension of a C++ class is supported properly
*/

class B
{
public:
    B(A & a){
        setparam(a); 
    }
    B(){
        int u;
        u = 0;
    }
    virtual ~B(){}
    void setparam(A & a){
        a.h();              //Here the code should call the h overloaded function of the derived class of A in Python
    }
};

---

当我运行代码时，print（“value in Python:+repr（myC.getValue（）））print 7，但是cout这里的问题是，当您在调用

g（myC）

中将

C

实例转换为Python时，Boost.Python使用按值转换器而不是浅层转换器（即，它复制

C

实例），即使你传递了一个指针

这是设计的：当你传递一个C++指针到Python，Boosi.python想确保Python代码不必担心其他C++代码删除它，而Python层仍然可以访问它，因为这可能导致危险的内存错误。确保这一点的唯一方法是复制对象

如果您想强制Boost.Python通过引用传递

myC

对象，请使用

g（Boost:：Python:：ptr（myC））

（或者

g（Boost:：ref（*myC））

，如果您知道它不是空的，但请注意这是危险的；您需要确保

g（）

的Python实现在其生命周期之后不会试图保留其参数

您可以在此处找到更多信息：

您还可以使用

boost:：shared_ptr

向Python传递参数，而无需安全复制：

---

很抱歉，无法及时编辑我的答案。非常感谢你的回答。我刚刚在类包装器的if部分使用了g（boost:：python:：ptr（myC）），现在它工作得非常好。

#include <boost/python.hpp>
#include <Python.h>
#include <object.h>
#include "ClassA.h"

#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python/implicit.hpp>
#include <iostream>
using namespace std;

using namespace boost::python;

/*
    A wrapper is used to allow overload of virtual A function
*/
struct WrapperClassA : A, boost::python::wrapper<A>{
    int f(int Ivar){
        if(override f = this->get_override("f")){
            return f(Ivar);
        }
        else {
            return A::f(Ivar);
        }
    }
    int default_f(int Ivar){
        return this->A::f(Ivar);
    }

    void g(C * myC){
        if(override g = this->get_override("g")){
                    g(myC);
        }
        else {
            A::g(myC);
        }
    }
    void default_g(C * myC){
        this->A::g(myC);
    }
};

/*
    Refection of necessary classes and functions for Python
*/
BOOST_PYTHON_MODULE(myWrapper){
    class_<WrapperClassA, boost::noncopyable>("A", init<>())
    .def("f", &A::f, &WrapperClassA::default_f)
    .def("g", &A::g, &WrapperClassA::default_g)
    ;

    class_<B, boost::noncopyable>("B", init<>())
    .def("setparam", &B::setparam)
    ;

    class_<C>("C", init<>())
    .def("setValue", &C::setValue)
    .def("getValue", &C::getValue)
    .def_readwrite("myC", &C::myC)
    ;
}

from math import *
# C++ library
from myWrapper import *

"""
    Extension of C++ class A
    APy should be used when A type argument is called
    g should be able to use a C++ C type object and to modify it
    The constructor call g in order to verify that myC is treated as mutable within Python
"""
class APy(A):
    def __init__(self):
        A.__init__(self)
        n = 0
        x = 0.
        myC = C()
        self.g(myC)
        print("value after a 1st call within Python: " + repr(myC.getValue()))

    def f(self, n):
        n = 5
        return n

    def g(self, myC):
        x = 7.0
        myC.setValue(x)
        print("value in Python: " + repr(myC.getValue()))

"""
    Main
    myB.setparam should be able to pass a APy argument
"""
myA = APy()
myB = B()
myB.setparam(myA)