C包装函数，崩溃Python？ [英] C Wrapper Function, crashing Python?
问题描述
static PyObject * wrap_doStuff（PyObject * self，PyObject * args）{
//这会将结果存储在Python对象中
PyObject * finalResult;
//从Python获取参数
char * result = 0;
char * in = 0;
char * aString = 0;
char * bString = 0;
MY_NUM * a;
MY_NUM * b;
int ok = PyArg_ParseTuple（args，" sss"，& in，& aString，& bString）;
if（！ok）返回0;
//努力获得a和b
// count - 返回一个int; GetVal - 返回一个字符*
a = GetVal（aString，count（aString，"，"））;
b = GetVal（bString，count（bString，"） ，）;;
// make函数调用，返回char *
result = doStuff（in，a，b）;
//将结果保存在Python字符串中
finalResult = PyString_FromString（result）;
//可用内存
PyMem_Free（结果）;
PyMem_Free（a）;
PyMem_Free（b）;
/ /返回结果作为Python字符串
返回finalResult;
}
....来自python我可以称之为功能4次......工作正常。当我第二次调用它时，python.exe崩溃了。即时思考一些内存
问题在包装函数中也许......但我不确定。
实际上是C函数，doStuff可以被称为5,6,7 ...... N次没有
问题
所以我知道它的必须是我的包装。
任何想法？谢谢！
static PyObject *wrap_doStuff(PyObject *self, PyObject *args) {
// this will store the result in a Python object
PyObject *finalResult;
// get arguments from Python
char *result = 0;
char *in= 0;
char *aString = 0;
char *bString = 0;
MY_NUM *a;
MY_NUM *b;
int ok = PyArg_ParseTuple(args, "sss", &in, &aString, &bString);
if (!ok) return 0;
// do work to get a and b
// count - returns an int; GetVal - returns a char *
a = GetVal(aString, count(aString, ","));
b = GetVal(bString, count(bString, ","));
// make function call, which returns a char *
result = doStuff(in, a, b);
// save result in Python string
finalResult = PyString_FromString(result);
// free memory
PyMem_Free(result);
PyMem_Free(a);
PyMem_Free(b);
// return the result as a Python string
return finalResult;
}
....from python I can call this function 4 times...works fine. WHen I
call it for the fifth time python.exe crashes. im thinking some memory
problem in the wrapper function perhaps...but I am not sure. The
actually C function, doStuff can be called 5, 6,7...N times without a
problem
so i know its gotta be my wrapper.
Any ideas? Thanks!
推荐答案
更新：
如果我使用C'的免费（结果），免费（a）免费（b）而不是PyMem_Free ......我只需要一个成功使用/调用doStuff即可。
即
//这个有效
doStuff（...）
// python在这里崩溃
doStuff（.. 。）
Java和Swing写道：
update:
if I use C''s free(result), free(a) free(b) instead of PyMem_Free...I
only get one successfuly use/call of doStuff.
i.e.
// this works
doStuff(...)
// python crashes here
doStuff(...)
Java and Swing wrote:
static PyObject * wrap_doStuff（PyObject * self，PyObject * args）{
//这将存储Python对象中的结果
PyObject * finalResult;
//从Python获取参数
char * result = 0;
char * in = 0;
char * aString = 0;
char * bString = 0;
MY_NUM * a;
MY_NUM * b;
int ok = PyArg_ParseTuple（args，" sss"， & in，& aString，& bString）;
if（！ok）返回0;
//努力获得a和b
//计数 - 返回一个int; GetVal - 返回一个char *
a = GetVal（aString，count（aString，"，"））;
b = GetVal（bString，count（bString，"，"））;
//进行函数调用，返回一个char *
result = doStuff（in，a，b）;
//将结果保存在Python字符串
finalResult = PyString_FromString（结果）;
//可用内存
PyMem_Free（结果）;
PyMem_Free（a）;
PyMem_Free（b）; < //返回结果作为Python字符串
返回finalResult;
}
...来自python我可以调用这个函数4次.. 。工作良好。我第五次调用它时python.exe崩溃了。我在包装函数中思考一些记忆问题或许......但我不确定。实际上是C函数，doStuff可以被称为5,6,7 ...... N次没有问题
所以我知道它必须是我的包装。
有什么想法吗？谢谢！
static PyObject *wrap_doStuff(PyObject *self, PyObject *args) {
// this will store the result in a Python object
PyObject *finalResult;
// get arguments from Python
char *result = 0;
char *in= 0;
char *aString = 0;
char *bString = 0;
MY_NUM *a;
MY_NUM *b;
int ok = PyArg_ParseTuple(args, "sss", &in, &aString, &bString);
if (!ok) return 0;
// do work to get a and b
// count - returns an int; GetVal - returns a char *
a = GetVal(aString, count(aString, ","));
b = GetVal(bString, count(bString, ","));
// make function call, which returns a char *
result = doStuff(in, a, b);
// save result in Python string
finalResult = PyString_FromString(result);
// free memory
PyMem_Free(result);
PyMem_Free(a);
PyMem_Free(b);
// return the result as a Python string
return finalResult;
}
...from python I can call this function 4 times...works fine. WHen I
call it for the fifth time python.exe crashes. im thinking some memory
problem in the wrapper function perhaps...but I am not sure. The
actually C function, doStuff can be called 5, 6,7...N times without a
problem
so i know its gotta be my wrapper.
Any ideas? Thanks!
还有一个更新...
如果我删除PyMem_Free并且免费（ ...）...所以没有记忆清理......我可以
仍然只调用doStuff 4次，第5次尝试崩溃Python。
Java和Swing写道：
one more update...
if I remove PyMem_Free and free(...) ...so no memory clean up...I can
still only call doStuff 4 times, the 5th attemp crashes Python.
Java and Swing wrote:
更新：
如果我使用C'的免费（结果），免费（a）免费（b）而不是PyMem_Free ...我
只有一个成功使用/调用doStuff。
//这个工作
doStuff（...）
// python在这里崩溃
doStuff（...）
Java和Swing写道：
update:
if I use C''s free(result), free(a) free(b) instead of PyMem_Free...I
only get one successfuly use/call of doStuff.
i.e.
// this works
doStuff(...)
// python crashes here
doStuff(...)
Java and Swing wrote:
static PyObject * wrap_doStuff（PyObject * self，PyObject * args）{
/ /这会将结果存储在Python对象中。
PyObject * finalResult;
//从Python获取参数
char * result = 0;
char * in = 0;
char * aString = 0;
char * bString = 0;
MY_NUM * a;
MY_NUM * b;
int ok = PyArg_ParseTuple（args， " sss"，& in，& aString，& bString）;
if if（！ok）返回0;
//做工作得到a和b
// count - 返回一个int; GetVal - 返回一个char *
a = GetVal（aString，count（aString，"，"））;
b = GetVal（bString，count（bString，"，"））;
//进行函数调用，返回一个char *
result = doStuff（in，a，b）;
//将结果保存在Python字符串
finalResult = PyString_FromString（结果）;
//可用内存
PyMem_Free（结果）;
PyMem_Free（a）;
PyMem_Free（b）; < //返回结果作为Python字符串
返回finalResult;
}
...来自python我可以调用这个函数4次.. 。工作良好。我第五次调用它时python.exe崩溃了。我在包装函数中思考一些记忆问题或许......但我不确定。实际上是C函数，doStuff可以被称为5,6,7 ...... N次没有问题
所以我知道它必须是我的包装。
有什么想法吗？谢谢！
static PyObject *wrap_doStuff(PyObject *self, PyObject *args) {
// this will store the result in a Python object
PyObject *finalResult;
// get arguments from Python
char *result = 0;
char *in= 0;
char *aString = 0;
char *bString = 0;
MY_NUM *a;
MY_NUM *b;
int ok = PyArg_ParseTuple(args, "sss", &in, &aString, &bString);
if (!ok) return 0;
// do work to get a and b
// count - returns an int; GetVal - returns a char *
a = GetVal(aString, count(aString, ","));
b = GetVal(bString, count(bString, ","));
// make function call, which returns a char *
result = doStuff(in, a, b);
// save result in Python string
finalResult = PyString_FromString(result);
// free memory
PyMem_Free(result);
PyMem_Free(a);
PyMem_Free(b);
// return the result as a Python string
return finalResult;
}
...from python I can call this function 4 times...works fine. WHen I
call it for the fifth time python.exe crashes. im thinking some memory
problem in the wrapper function perhaps...but I am not sure. The
actually C function, doStuff can be called 5, 6,7...N times without a
problem
so i know its gotta be my wrapper.
Any ideas? Thanks!
Op 2005-10-12，Java and Swing schreef< co ******* @ gmail.com>：
Op 2005-10-12, Java and Swing schreef <co*******@gmail.com>:
static PyObject * wrap_doStuff（PyObject * self，PyObject * args）{
//这会将结果存储在Python对象中
PyObject * finalResult ;
//从Python获取参数
char * result = 0;
char * in = 0;
char * aString = 0;
char * bString = 0;
MY_NUM * a;
MY_NUM * b;
int ok = PyArg_ParseTuple（args，" sss"，& in，& aString，& bString）;
如果（！ok）返回0;
//做工作得到a和b
// count - 返回一个int; GetVal - 返回一个char *
a = GetVal（aString，count（aString，"，"））;
b = GetVal（bString，count（bString，"，"））;
//进行函数调用，返回一个char *
result = doStuff（in，a，b）;
//将结果保存在Python字符串
finalResult = PyString_FromString（结果）;
//可用内存
PyMem_Free（结果）;
PyMem_Free（a）;
PyMem_Free（b）; < //返回结果作为Python字符串
返回finalResult;
}
...来自python我可以调用这个函数4次.. 。工作良好。我第五次调用它时python.exe崩溃了。我在包装函数中思考一些记忆问题或许......但我不确定。实际上是C函数，doStuff可以被称为5,6,7 ...... N次没有问题
所以我知道它必须是我的包装。
有什么想法吗？谢谢！
static PyObject *wrap_doStuff(PyObject *self, PyObject *args) {
// this will store the result in a Python object
PyObject *finalResult;
// get arguments from Python
char *result = 0;
char *in= 0;
char *aString = 0;
char *bString = 0;
MY_NUM *a;
MY_NUM *b;
int ok = PyArg_ParseTuple(args, "sss", &in, &aString, &bString);
if (!ok) return 0;
// do work to get a and b
// count - returns an int; GetVal - returns a char *
a = GetVal(aString, count(aString, ","));
b = GetVal(bString, count(bString, ","));
// make function call, which returns a char *
result = doStuff(in, a, b);
// save result in Python string
finalResult = PyString_FromString(result);
// free memory
PyMem_Free(result);
PyMem_Free(a);
PyMem_Free(b);
// return the result as a Python string
return finalResult;
}
...from python I can call this function 4 times...works fine. WHen I
call it for the fifth time python.exe crashes. im thinking some memory
problem in the wrapper function perhaps...but I am not sure. The
actually C function, doStuff can be called 5, 6,7...N times without a
problem
so i know its gotta be my wrapper.
Any ideas? Thanks!
假设你的doStuff是一个对python一无所知的C函数。
它可能是PyMem_Free（结果）。
http://docs.python.org/api/memoryInterface.html 说出以下内容：
void PyMem_Free（void * p）
释放p指向的内存块，必须是
由之前调用PyMem_Malloc（）或PyMem_Realloc（）返回。
否则，或者之前调用了PyMem_Free（p），未定义
行为发生。如果p为NULL，则不执行任何操作。
但是你的结果不是由PyMem_Malloc分配的，而是由C返回给你的是
功能。
-
Antoon Pardon
Well assuming your doStuff is a C function that knows nothing of python.
it might be the PyMem_Free(result).
http://docs.python.org/api/memoryInterface.html says the following:
void PyMem_Free(void *p)
Frees the memory block pointed to by p, which must have been
returned by a previous call to PyMem_Malloc() or PyMem_Realloc().
Otherwise, or if PyMem_Free(p) has been called before, undefined
behavior occurs. If p is NULL, no operation is performed.
But your result wasn''t allocated by a PyMem_Malloc, it was returned
to you by a C function.
--
Antoon Pardon
这篇关于C包装函数，崩溃Python？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
