在项目开发中遇到了，python需要去调用一个动态链接库dll中的c++方法。这个方法的参数为一个指针类型的参数,一个bool类型参数，
在python中并未对数字类型进行区分。
int LP_Agc
( double *
所以在调用这个方法之前，
第一步要将python中的类型转换为c语言类型。
这个应该是python自带的 &
a = c_double(1.0)
b = c_double(True)
#python中还有c_int()，c_float()等。需要什么用什么。可以在 _init_.py中找到这些方法。
第二步 ，lgc中的第一个参数为 double类型的指针类型。。
在pythong中同样有使用指针的方法。pointer（）
pcdi = pointer(c_double(1.0))即：
dll.LP_Agc(pointer(c_double(1.0),c_bool(True))
就可以成功调用方法。
byref(n)返回的相当于C的指针右值&n，本身没有被分配空间：所以他只能作为参数。
pointer返回的相当于指针左值T* p=&n，可以改变，可以取地址:
阅读(...) 评论()博主最新文章
博主热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)浅谈Python程序与C++程序的联合使用
转载 & & 投稿：goldensun
这篇文章主要介绍了浅谈Python程序与C++程序的联合使用,主要包括6中方案,需要的朋友可以参考下
作为Python程序员，应该能够正视Python的优点与缺点。众所周之，Python的运行速度是很慢的，特别是大数据量的运算时，Python会慢得让人难以忍受。对于这种情况，“专业”的解决方案是用上numpy或者opencl。不过有时候为了一点小功能用上这种重型的解决方案很不划算，或者有时候想要实现的操作在numpy里面没有，需要我们自己用C语言来编写。总之，我们使用Python与C++的混合编程能够加快程序热点的运算速度。
首先要提醒大家注意的是，在考虑联合编程之前一定要找到程序运行的热点。简单一点地，使用标准库的profile或者cProfile模块找到最消耗CPU的位置，如果这个位置只简单的消耗IO时间，通常换成C++程序的意义也不会很大，此时做联合编程可能是事倍功半，起不到多大的效果。
还有些情况，Python程序员们想要使用操作系统或者外部模块提供的函数。这些模块一般是为C/C++程序员提供的。这时候也是Python与C++联合编程的用武之地。
Python语言可以说是最好的胶水语言。仅就与C++联合编程这个问题来讲，依使用难度与功能来排列，Python社区提供了以下几种解决方案：
1.使用标准库ctypes直接调用C/C++编写的动态链接库。这是最简单易用的方案。C/C++程序员使用自己的丰富的经验，把预定的功能实现为动态链接库。而Python程序员只要知道这些动态链接库函数的名称、参数类型与返回值类型就能简单地调用它。当你传入参数时，ctypes模块会自动地把Python的对象成为C/C++所对应的参数类型。比如以下调用Windows的API:
#定义参数类型与函数名称
from ctypes.wintypes import UINT, DWORD
GetLastInputInfo = ctypes.windll.user32.GetLastInputInfo
class LASTINPUTINFO(ctypes.Structure):
_fields_ = [("cbSize", UINT),
("dwTime", DWORD)]
#开始调用DLL导出的函数
def getLastInputTime_nt():
info = LASTINPUTINFO()
info.cbSize = ctypes.sizeof(info)
info.dwTime = 0
if not GetLastInputInfo(ctypes.byref(info)):
raise WindowsError("")
return info.dwTime
&&& 在这里展示了如何构造Windows的API所需要的结构体，如何填充结构体并分析返回值。
&&& ctypes还能将Python函数提供给C/C++代码作为回调函数。
&&& 与其它解决方案相比。ctypes不需要程序员熟悉C/C++语言，不需要安装一个C/C++的编译器，它通过操作系统的接口直接操作C/C++代码。而且ctypes是标准库的一部分，只要安装了Python就可以直接使用。这几个原因使得它深受Python程序员的喜爱。
&&& 而它的劣势呢。首先，ctypes不能简单调用C++程序，因为C++在编译的时候使用了name mangling这个技术来实现函数的重载。C++会自动地为类的成员函数加上类名前缀。所以，C++程序员需要以C语言的调用约定来提供接口，没有类，没有重载函数，没有模板，没有C++异常。不能直接调用现有的C++代码可能是这个方案最大的缺点。
&&& 另外，对于list, set之类的数据类型，ctypes不能识别并自动地在Python与C/C++数据类型之间转换。C/C++部分不能识别Python数据类型，这时候只能用Python语言来编写转换代码。如果数据量较大，或者调用很频繁，转换代码反而会浪费很多的资源。这或许是ctypes的另一个劣势之一了。
2.如果你使用的是Jython或者IronPython的话，它们也提供了类似于ctypes之类的模块，能够直接访问Java或者.Net语言编写的模块。其优势与劣势大致与ctypes相似。因为其使用范围有限，这里不再详述。
3.使用Cython语言，一种类似于Python语言的一种新型语言编写预定功能的代码，然后将这些代码转换成为C语言编译成为Python语言可以直接调用的二进制模块。Cython语言是融合Python语言与C语言的一种新型语言。它本身能够理解Python语言的语法，然后在其基础上增加了某些C语言的语法，以便更精细地控制数据类型与指针。基本兼容Python语法是这个解决方案最大的特点。很多时候，Python程序员只要在旧的代码中简单地声明一下代码中所使用的参数、变量的类型，就能把立即为旧的Python程序提速。
&&& Cython提供了一个名为pyximporter的工具，能够在安装了C/C++编译器的计算机上面为简单的Cython程序直接生成相应的Python模块。这使得Cython的使用与普通的Python程序一样简单。比如下面这段代码，直接保存为myhello.pyx即可被调用。
#myhello.pyx
def sayHelloTenTimes():
cdef int i #只要简单地为变量标识类型即可加速循环。
for i in range(0, 10):
print("hello, world!")
&&& pyximport.install()
&&& import myhello
&&& myhello.sayHelloTenTimes()
&&& 由此可见，Cython非常容易使用。而且不仅能够处理C语言的模块，还能处理C++的模块——虽然没有直接支持虚函数之类的完整C++特性。因为它不直接使用C/C++语法，而是另外设计比C/C++更简洁优雅的新型语法，因此，对于不熟悉C/C++的程序员来说有很大的吸引力。相比ctypes来说，因为参数类型转换更加智能与高效，所以通常能够提升更多的效率。
&&& 劣势呢，所谓用Python程序员所熟练的语法来编写高速的运算代码，乍一听相当地有吸引力。但是如果想要更深入地控制内存与数据结构时，程序员可能会发现，现在他不得不熟练地掌握C/C++语言，然后用Cython的语法写出来。以程序员们懒惰的性格，这反而是件难以忍受的事件。这或许是Cython本身并不大流行的主要原因吧。
4.使用boost.python。有意思的是，与ctypes/Cython形成鲜明的对比，boost.python倾向于让C++程序员拥有更熟悉的编程环境。它让C++程序员使用他所熟悉的C++语法直接控制Python的数据结构，调用Python的解释器。它没有像Cython那样发明新的语法，而是直接使用C++的语法，编写供Python使用的接口。与Cython同样的道理，它的效率优胜于ctypes。
&&& 与Cython/SWIG/SIP等方案相比，程序员只需要学习C/C++与Python两种语言。另外，与本文提到的几种解决方案相比，它非常适合在主要由C++编写的程序中控制Python代码。不仅功能更强大、效率还更高。如此神奇的解决方案会有什么劣势呢？某些人可能不同意吧，老鱼一听说它依赖于boost就蔫了，感觉编译与学习庞大又奇怪的boost非常浪费生命。
5.使用SWIG或者SIP，通过编写一个接口文件，使用类似于C/C++语法——声明函数、类型的信息，然后使用特殊的工具为C/C++的代码生成Python的接口代码。这些接口代码能够在Python与C/C++之间的数据结构转换。最终编译这些接口代码，成为Python的二进制模块。SWIG与SIP的接口文件与C/C++的头文件非常相似。
&&& 这两种工具差不多，因为。本质上，他们都与Cython类似，都使用了中间语言来生成转换代码。但SWIG/SIP能够在他们的接口文件中嵌入C/C++，能够让程序员仔细地调节数据类型的转换过程。在使用上，它比Cython的层次更低，更接近于Python本身提供的API。
&&& SWIG能够为多种脚本语言生成转换代码。而SIP则专门针对Python与C++。此外，SIP本身是作为PyQt的专门工具来开发的，因此它能够理解Qt的signal/slot。从应用项目上来看，SWIG似乎会更广泛一点。而SIP，目前所见的项目基本都与PyQt相关。据说SWIG对于C++的支持不好，不知道有没有人来说一下呢。相比之下,SIP对于C++的支持非常完善，诸如虚函数、protected member function、模版、析构函数、异常等特性都得到良好的支持。而且SIP支持Python的GIL，还拥有一个使用Python编写的编译系统。可能会更方便一点。
&&& 然而这种方案毕竟要学习一种新的语言，所以从表面上来看不如Cython和boost.python讨喜。当程序员想要仔细地调节类型转换代码的时候，需要学习SWIG/SIP的内部机制，被限定使用特殊的变量名。这使得这种方案的学习曲线相对较高。
6.直接使用Python的API，可以称之为最终解决方案。Cython, SWIG, SIP的接口文件转换后所生成的C/C++代码实际上都使用Python的API。与其它方案相比，这种方案相当地繁复，必须为每次函数调用编写数据转换代码，还要操心Python对象的引用计数。我觉得这种方案一无是处，这时就不再多讲了。其它的工具pybindgen不知道什么情况。有兴趣的话可以看看。
好了。题外话一句吧，我一直觉得ctypes与xmlrpc并列Python语言的两大神器，最能体现Python的生产效率。
希望本文在大家选择一种技术路线时能提供一点点帮助。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具& &&&&Python模块和C/C++的动态库间相互调用在实际的应用中会有所涉及，在此作一总结。
二、Python调用C/C++
1、Python调用C动态链接库
&&&&&&& Python调用C库比较简单，不经过任何封装打包成so，再使用python的ctypes调用即可。（1）C语言文件：pycall.c
/***gcc -o libpycall.so -shared -fPIC pycall.c*/
#include &stdio.h&
#include &stdlib.h&
int foo(int a, int b)
printf("you input %d and %d\n", a, b);
return a+b;
（2）gcc编译生成动态库libpycall.so：gcc -o libpycall.so -shared -fPIC pycall.c。使用g++编译生成C动态库的代码中的函数或者方法时，需要使用extern "C"来进行编译。
（3）Python调用动态库的文件：pycall.py
import ctypes
ll = ctypes.cdll.LoadLibrary
lib = ll("./libpycall.so")
lib.foo(1, 3)
print '***finish***'
（4）运行结果：
2、Python调用C++(类)动态链接库&
&&&&&& 需要extern "C"来辅助，也就是说还是只能调用C函数，不能直接调用方法，但是能解析C++方法。不是用extern "C"，构建后的动态链接库没有这些函数的符号表。（1）C++类文件：pycallclass.cpp
#include &iostream&
using namespace
class TestLib
void display();
void display(int a);
void TestLib::display() {
cout&&"First display"&&
void TestLib::display(int a) {
cout&&"Second display:"&&a&&
extern "C" {
void display() {
obj.display();
void display_int() {
obj.display(2);
（2）g++编译生成动态库libpycall.so：g++ -o libpycallclass.so -shared -fPIC pycallclass.cpp。
（3）Python调用动态库的文件：pycallclass.py
import ctypes
so = ctypes.cdll.LoadLibrary
lib = so("./libpycallclass.so")
print 'display()'
lib.display()
print 'display(100)'
lib.display_int(100)
（4）运行结果：
3、Python调用C/C++可执行程序
（1）C/C++程序：main.cpp
#include &iostream&
using namespace
int test()
int a = 10, b = 5;
return a+b;
int main()
cout&&"---begin---"&&
int num = test();
cout&&"num="&&num&&
cout&&"---end---"&&
（2）编译成二进制可执行文件：g++ -o testmain main.cpp。
（3）Python调用程序：main.py
import commands
main = "./testmain"
if os.path.exists(main):
rc, out = commands.getstatusoutput(main)
print 'rc = %d, \nout = %s' % (rc, out)
print '*'*10
f = os.popen(main)
data = f.readlines()
print data
print '*'*10
os.system(main)
（4）运行结果：
4、扩展Python（C++为Python编写扩展模块）
&&&&&& 所有能被整合或导入到其它python脚本的代码，都可以被称为扩展。可以用Python来写扩展，也可以用C和C++之类的编译型的语言来写扩展。Python在设计之初就考虑到要让模块的导入机制足够抽象。抽象到让使用模块的代码无法了解到模块的具体实现细节。Python的可扩展性具有的优点：方便为语言增加新功能、具有可定制性、代码可以实现复用等。&&&&&& 为 Python 创建扩展需要三个主要的步骤：创建应用程序代码、利用样板来包装代码和编译与测试。（1）创建应用程序代码
#include &stdio.h&
#include &stdlib.h&
#include &string.h&
int fac(int n)
if (n & 2) return(1); /* 0! == 1! == 1 */
return (n)*fac(n-1); /* n! == n*(n-1)! */
char *reverse(char *s)
register char t,
*q = (s + (strlen(s) - 1)); /* bwd */
while (p & q)
/* if p & q */
/* swap & move ptrs */
*p++ = *q;
return(s);
int main()
char s[BUFSIZ];
printf("4! == %d\n", fac(4));
printf("8! == %d\n", fac(8));
printf("12! == %d\n", fac(12));
strcpy(s, "abcdef");
printf("reversing 'abcdef', we get '%s'\n", \
reverse(s));
strcpy(s, "madam");
printf("reversing 'madam', we get '%s'\n", \
reverse(s));
& & & &上述代码中有两个函数，一个是递归求阶乘的函数fac()；另一个reverse()函数实现了一个简单的字符串反转算法，其主要目的是修改传入的字符串，使其内容完全反转，但不需要申请内存后反着复制的方法。
（2）用样板来包装代码&&&&&&& 接口的代码被称为&样板&代码，它是应用程序代码与Python解释器之间进行交互所必不可少的一部分。样板主要分为4步：a、包含Python的头文件；b、为每个模块的每一个函数增加一个型如PyObject* Module_func()的包装函数；c、为每个模块增加一个型如PyMethodDef ModuleMethods[]的数组；d、增加模块初始化函数void initModule()。
#include &stdio.h&
#include &stdlib.h&
#include &string.h&
int fac(int n)
if (n & 2) return(1);
return (n)*fac(n-1);
char *reverse(char *s)
register char t,
*q = (s + (strlen(s) - 1));
while (s && (p & q))
*p++ = *q;
return(s);
int test()
char s[BUFSIZ];
printf("4! == %d\n", fac(4));
printf("8! == %d\n", fac(8));
printf("12! == %d\n", fac(12));
strcpy(s, "abcdef");
printf("reversing 'abcdef', we get '%s'\n", \
reverse(s));
strcpy(s, "madam");
printf("reversing 'madam', we get '%s'\n", \
reverse(s));
#include "Python.h"
static PyObject *
Extest_fac(PyObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "i", &num))
return NULL;
return (PyObject*)Py_BuildValue("i", fac(num));
static PyObject *
Extest_doppel(PyObject *self, PyObject *args)
char *orig_
char *dupe_
if (!PyArg_ParseTuple(args, "s", &orig_str))
return NULL;
retval = (PyObject*)Py_BuildValue("ss", orig_str,
dupe_str=reverse(strdup(orig_str)));
free(dupe_str);
#防止内存泄漏
static PyObject *
Extest_test(PyObject *self, PyObject *args)
return (PyObject*)Py_BuildValue("");
static PyMethodDef
ExtestMethods[] =
{ "fac", Extest_fac, METH_VARARGS },
{ "doppel", Extest_doppel, METH_VARARGS },
{ "test", Extest_test, METH_VARARGS },
{ NULL, NULL },
void initExtest()
Py_InitModule("Extest", ExtestMethods);
& & & & Python.h头文件在大多数类Unix系统中会在/usr/local/include/python2.x或/usr/include/python2.x目录中，系统一般都会知道文件安装的路径。
&&&&&&& 增加包装函数，所在模块名为Extest，那么创建一个包装函数叫Extest_fac()，在Python脚本中使用是先import Extest，然后调用Extest.fac()，当Extest.fac()被调用时，包装函数Extest_fac()会被调用，包装函数接受一个 Python的整数参数，把它转为C的整数，然后调用C的fac()函数，得到一个整型的返回值，最后把这个返回值转为Python的整型数做为整个函数调用的结果返回回去。其他两个包装函数Extest_doppel()和Extest_test()类似。&&&&&&&& 从Python到C的转换用PyArg_Parse*系列函数，int PyArg_ParseTuple()：把Python传过来的参数转为C；int PyArg_ParseTupleAndKeywords()与PyArg_ParseTuple()作用相同，但是同时解析关键字参数；它们的用法跟C的sscanf函数很像，都接受一个字符串流，并根据一个指定的格式字符串进行解析，把结果放入到相应的指针所指的变量中去，它们的返回值为1表示解析成功，返回值为0表示失败。从C到Python的转换函数是PyObject* Py_BuildValue()：把C的数据转为Python的一个对象或一组对象，然后返回之；Py_BuildValue的用法跟sprintf很像，把所有的参数按格式字符串所指定的格式转换成一个Python的对象。&&&&&&& C与Python之间数据转换的转换代码：&&&&&&& 为每个模块增加一个型如PyMethodDef ModuleMethods[]的数组，以便于Python解释器能够导入并调用它们，每一个数组都包含了函数在Python中的名字，相应的包装函数的名字以及一个METH_VARARGS常量，METH_VARARGS表示参数以tuple形式传入。 若需要使用PyArg_ParseTupleAndKeywords()函数来分析命名参数的话，还需要让这个标志常量与METH_KEYWORDS常量进行逻辑与运算常量 。数组最后用两个NULL来表示函数信息列表的结束。&&&&&&&& 所有工作的最后一部分就是模块的初始化函数，调用Py_InitModule()函数，并把模块名和ModuleMethods[]数组的名字传递进去，以便于解释器能正确的调用模块中的函数。（3）编译&&&&&&& 为了让新Python的扩展能被创建，需要把它们与Python库放在一起编译，distutils包被用来编译、安装和分发这些模块、扩展和包。&&&&&&& 创建一个setup.py 文件，编译最主要的工作由setup()函数来完成：
#!/usr/bin/env python
from distutils.core import setup, Extension
MOD = 'Extest'
setup(name=MOD, ext_modules=[Extension(MOD, sources=['Extest2.c'])])
& & & & Extension()第一个参数是(完整的)扩展的名字，如果模块是包的一部分的话，还要加上用'.'分隔的完整的包的名字。上述的扩展是独立的，所以名字只要写"Extest"就行；sources参数是所有源代码的文件列表，只有一个文件Extest2.c。setup需要两个参数：一个名字参数表示要编译哪个内容；另一个列表参数列出要编译的对象，上述要编译的是一个扩展，故把ext_modules参数的值设为扩展模块的列表。
&&&&&&& 运行setup.py build命令就可以开始编译我们的扩展了，提示部分信息：
creating build/lib.linux-x86_64-2.6
gcc -pthread -shared build/temp.linux-x86_64-2.6/Extest2.o -L/usr/lib64 -lpython2.6 -o build/lib.linux-x86_64-2.6/Extest.so
（4）导入和测试
&&&&&&&& 你的扩展会被创建在运行setup.py脚本所在目录下的build/lib.*目录中，可以切换到那个目录中来测试模块，或者也可以用命令把它安装到Python中：python setup.py install，会提示相应信息。&&&&&&&& 测试模块：（5）引用计数和线程安全&&&& Python对象引用计数的宏：Py_INCREF(obj)增加对象obj的引用计数，Py_DECREF(obj)减少对象obj的引用计数。Py_INCREF()和Py_DECREF()两个函数也有一个先检查对象是否为空的版本，分别为Py_XINCREF()和Py_XDECREF()。&&&&& 编译扩展的程序员必须要注意，代码有可能会被运行在一个多线程的Python环境中。这些线程使用了两个C宏Py_BEGIN_ALLOW_THREADS和Py_END_ALLOW_THREADS，通过将代码和线程隔离，保证了运行和非运行时的安全性，由这些宏包裹的代码将会允许其他线程的运行。
三、C/C++调用Python
&&&&&& C++可以调用Python脚本，那么就可以写一些Python的脚本接口供C++调用了，至少可以把Python当成文本形式的动态链接库，&需要的时候还可以改一改，只要不改变接口。缺点是C++的程序一旦编译好了，再改就没那么方便了。（1）Python脚本：pytest.py
#test function
def add(a,b):
print "in python function add"
print "a = " + str(a)
print "b = " + str(b)
print "ret = " + str(a+b)
def foo(a):
print "in python function foo"
print "a = " + str(a)
print "ret = " + str(a * a)
class guestlist:
def __init__(self):
print "aaaa"
print "bbbbb"
def __getitem__(self, id):
return "ccccc"
def update():
guest = guestlist()
print guest['aa']
（2）C++代码：
/**g++ -o callpy callpy.cpp -I/usr/include/python2.6 -L/usr/lib64/python2.6/config -lpython2.6**/
#include &Python.h&
int main(int argc, char** argv)
// 初始化Python
//在使用Python系统前，必须使用Py_Initialize对其
//进行初始化。它会载入Python的内建模块并添加系统路
//径到模块搜索路径中。这个函数没有返回值，检查系统
//是否初始化成功需要使用Py_IsInitialized。
Py_Initialize();
// 检查初始化是否成功
if ( !Py_IsInitialized() ) {
return -1;
// 添加当前路径
//把输入的字符串作为Python代码直接运行，返回0
//表示成功，-1表示有错。大多时候错误都是因为字符串
//中有语法错误。
PyRun_SimpleString("import sys");
PyRun_SimpleString("print '---import sys---'");
PyRun_SimpleString("sys.path.append('./')");
PyObject *pName,*pModule,*pDict,*pFunc,*pA
// 载入名为pytest的脚本
pName = PyString_FromString("pytest");
pModule = PyImport_Import(pName);
if ( !pModule ) {
printf("can't find pytest.py");
getchar();
return -1;
pDict = PyModule_GetDict(pModule);
if ( !pDict ) {
return -1;
// 找出函数名为add的函数
printf("----------------------\n");
pFunc = PyDict_GetItemString(pDict, "add");
if ( !pFunc || !PyCallable_Check(pFunc) ) {
printf("can't find function [add]");
getchar();
return -1;
// 参数进栈
pArgs = PyTuple_New(2);
PyObject* Py_BuildValue(char *format, ...)
把C++的变量转换成一个Python对象。当需要从
C++传递变量到Python时，就会使用这个函数。此函数
有点类似C的printf，但格式不同。常用的格式有
s 表示字符串，
i 表示整型变量，
f 表示浮点数，
O 表示一个Python对象。
PyTuple_SetItem(pArgs, 0, Py_BuildValue("l",3));
PyTuple_SetItem(pArgs, 1, Py_BuildValue("l",4));
// 调用Python函数
PyObject_CallObject(pFunc, pArgs);
//下面这段是查找函数foo 并执行foo
printf("----------------------\n");
pFunc = PyDict_GetItemString(pDict, "foo");
if ( !pFunc || !PyCallable_Check(pFunc) ) {
printf("can't find function [foo]");
getchar();
return -1;
pArgs = PyTuple_New(1);
PyTuple_SetItem(pArgs, 0, Py_BuildValue("l",2));
PyObject_CallObject(pFunc, pArgs);
printf("----------------------\n");
pFunc = PyDict_GetItemString(pDict, "update");
if ( !pFunc || !PyCallable_Check(pFunc) ) {
printf("can't find function [update]");
getchar();
return -1;
pArgs = PyTuple_New(0);
PyTuple_SetItem(pArgs, 0, Py_BuildValue(""));
PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pName);
Py_DECREF(pArgs);
Py_DECREF(pModule);
// 关闭Python
Py_Finalize();
（3）C++编译成二进制可执行文件：g++ -o callpy callpy.cpp -I/usr/include/python2.6 -L/usr/lib64/python2.6/config -lpython2.6，编译选项需要手动指定Python的include路径和链接接路径（Python版本号根据具体情况而定）。
（4）运行结果：
（1）Python和C/C++的相互调用仅是测试代码，具体的项目开发还得参考Python的API文档。（2）两者交互，C++可为Python编写扩展模块，Python也可为C++提供脚本接口，更加方便于实际应用。（3）若有不足，请留言，在此先感谢！
阅读(...) 评论()博主最新文章
博主热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)