在C嵌入式python中刷新导入

我有一个C代码，它使用“python.h”将python嵌入其中，它运行良好，没有任何错误，但它并没有完全实现我想要的功能

它的作用：在C代码开始运行后，它会忽略我对python文件所做的所有更改，直到我重新启动C代码

我想要什么：当C代码运行时，如果我更改python文件，它应该开始运行新代码

每次调用函数之前，我都尝试使用函数

PyImport\u ReloadModule

，但它不起作用。我做错什么了吗

我当前的代码：

#include "Strategy.h"
#undef _DEBUG /* Link with python24.lib and not python24_d.lib */
#include <Python.h>
#include <stdlib.h>
#include <iostream>

using namespace std;
PyObject *pName, *pModule, *pDict, *pFunc;
PyObject *pArgs, *pValue;

void import_py() {
    pName = PyString_FromString("main");
    pModule = PyImport_Import(pName);
    Py_DECREF(pName);
    if (pModule == NULL) {
        cout << "ERR : Unable to load main.py\n";
        return;
    } else {
        cout << "OK : Loaded main.py\n";
    }
    if ( PyObject_HasAttrString(pModule, "main") ) {
        cout << "OK : main.py has function main\n";
    } else {
        cout << "ERR : main.py has no function main\n";
        return;
    }
    pFunc = PyObject_GetAttrString(pModule, "main");
    if ( pFunc == NULL ) {
        cout << "OK : main.py's function main gave NULL when trying to take it\n";
        return;
    }
}

void remove_py() {  
    Py_XDECREF(pArgs);
    Py_XDECREF(pModule);
    Py_XDECREF(pFunc);
    Py_Finalize();
}

void Construct() {
    Py_Initialize();
    import_py();
}

void Destruct() {
    if ( pModule || pFunc ) {
        remove_py();
    }
}


void Loop () {
    if ( ! ( pModule && pFunc ) ) {
        cout << "Looped. But python values are null\n";
        return;
    }
    cout << "Loop : ";

    pArgs = PyTuple_New(2); // Create a tuple to send to python - sends 1,2
    PyTuple_SetItem(pArgs, 0, PyInt_FromLong(1));
    PyTuple_SetItem(pArgs, 1, PyInt_FromLong(2));

    pValue = PyObject_CallObject(pFunc, pArgs);
    Py_DECREF(pArgs);

    double t = 0; // Get the 2 return values
    t = PyFloat_AsDouble(PyTuple_GetItem(pValue, 0));
    cout << t << ", ";
    t = PyFloat_AsDouble(PyTuple_GetItem(pValue, 1));
    cout << t;

    cout << "\n";
}

void main() {
    Construct();
    while(1) { // Using an infinite loop for now - to test
        pModule = PyImport_ReloadModule(pModule);
        Loop();
    }
    Destruct();
}

#包括“Strategy.h”
#使用python24.lib而不是python24\u d.lib的undf _DEBUG/*链接*/
#包括
#包括
#包括
使用名称空间std；
PyObject*pName、*pModule、*pDict、*pFunc；
PyObject*pArgs，*pValue；
无效导入_py（）{
pName=PyString_FromString（“main”）；
pModule=PyImport\u Import（pName）；
Py_DECREF（pName）；
if（pModule==NULL）{
我发现了这个问题

即使在使用
pModule=PyImport\u重新加载模块（pModule）
p
变量pFunc不会自动更新。因此，变量pFunc仍然引用旧模块

因此，每个变量都需要重新获取。如下所示：

void main() {
    Construct();
    while(1) { // Using an infinite loop for now - to test
        pModule = PyImport_ReloadModule(pModule);
        pFunc = PyObject_GetAttrString(pModule, "main");
        Loop();
    }
    Destruct();
}

这里我不确定的一点是，是否应该对引用旧pModule的pFunc进行DECREF。
它是如何工作的？PyImport_reloadmule

是否返回

NULL

？