Bien le bonjour !

Je cherche et hélas ne trouve pas le moyen de passer un pointeur c++ comme argument à l'appel d'une fonction python avec l'api C.
Pour l'explication, j'ai une application C++ qui intègre un interpréteur python et fait donc des appels vers des scripts python externes.

De la sorte :

Py_Initialize();

PyObject *pName, *pModule, *pDict, *pFunc;
PyObject *pArgs, *pValue;

pName = PyString_FromString("module");
    /* Error checking of pName left out */

    pModule = PyImport_Import(pName);
    Py_DECREF(pName);

    if (pModule != NULL) {
        pFunc = PyObject_GetAttrString(pModule, "main");
        /* pFunc is a new reference */

        if (pFunc && PyCallable_Check(pFunc)) {
            pArgs = PyTuple_New(1);
            pValue = PyInt_FromLong(452);
            if (!pValue) {
                Py_DECREF(pArgs);
                Py_DECREF(pModule);
                std::cout << "Cannot convert argument << std::endl;
            }
            // pValue reference stolen here: 
            PyTuple_SetItem(pArgs, i, pValue);
        }

            pValue = PyObject_CallObject(pFunc, pArgs);
            Py_DECREF(pArgs);
            if (pValue != NULL) {
		return PyInt_AsLong(pValue);
                Py_DECREF(pValue);
            }
            else {
                Py_DECREF(pFunc);
                Py_DECREF(pModule);
                PyErr_Print();
		std::cout << "Call failed" << std::endl;
            }
        }
        else {
            if (PyErr_Occurred())
                PyErr_Print();
		std::cout << "Cannot find function main" << std::endl;
        }
        Py_XDECREF(pFunc);
        Py_DECREF(pModule);
    }
    else {
        PyErr_Print();
	std::cout << "Failed to load " << "module.py" << std::endl;
    }

Py_Finalize();

Bref. Dans tout ce bout de code qui n'est présent que pour expliquer un peu mieux mon soucis, j'utilise :

pValue = PyInt_FromLong(452);

Qui me sert donc à wrapper un objet de type long c++ en objet de type int python. Je cherche à faire la même chose avec un pointeur c++, mettons un pointeur sur string que je pourrais envoyer en paramètre à l'appel de la fonction main de mon script. Le but étant de pouvoir modifier la valeur pointé depuis le script sans avoir de retour à faire de sa part.

Hélas, je ne trouve pas comment faire.

Si quelqu'un a une idée, merci d'avance =)

Tu as regardé dans la doc ?

En effet. Et si j'y avais trouvé mon bonheur, je ne posterais pas ici.

Mon problème est peut être mal exposé.

Pour faire simple. J'aimerais pouvoir modifier un objet créé dans l'application C++ dans le script python appelé et du coup, récupérer sa valeur sans avoir recours au return. Le but étant de garder le return libre pour un éventuel message d'erreur.

Donc typiquement, que le principe des pointeurs puisse s'étendre à mon script python.

Bien le bonjour,

Je reviens vers vous, toujours en quête de réponses.

Jusqu'à maintenant, je faisais des tests en envoyant en paramètres de ma fonction un int ou une string. Hors, j'ai remarqué plus tard que ces deux éléments étaient imutable. Il me faudrait donc passer par une liste par exemple.

J'ai donc tenté ceci :

PyObject *a = Py_BuildValue("[i]:ref", 10);

PySys_SetPath("..\\Plugin;..\\lib;..\\lib\\site-packages");
pName = PyString_FromString(CStringA(vPluginAdr[count]));

pModule = PyImport_Import(pName);
if (pModule != NULL) {
    pFunc = PyObject_GetAttrString(pModule, "GetInfo");
    if (pFunc && PyCallable_Check(pFunc)) {
        pArgs = PyTuple_New(1);
        PyTuple_SetItem(pArgs, 0, a);
        pValue = PyObject_CallObject(pFunc, pArgs);
    }
}

Mais une exception est levée à l'appel de PyObject_CallObject.