① python中dict为什么比list浪费内存求大神，感激不尽！！
不知道你对c有没有了解，python解释器就是基于c写的，这个两个数据结构应该对应c的哈希表和数组。
因为哈希表需要额外内存记录映射关系，而数组只需要通过索引就能计算出下一个节点的位置，所以哈希表占用的内存比数组大，也就是dict比list占用的内存大些。
不过使用python说明对性能没有极端的要求，具体使用哪个主要还是要看项目的需要。
如果解决了您的问题请采纳！
如果未解决请继续追问
② python stub是什么意思
J2EE里面的stub是这样说的：为屏蔽客户调用远程主机上的对象，必须提供某种方式来模拟本地对象，这种本地对象称为存根(stub)，存根负责接收本地方法调用，并将它们委派给各自的具体实现对象。
stub替代子模块(某些特定功能模块)的模拟函数或模拟类。
在分布式对象中代表着客户端对象，承担着通信的职责。在VC++环境中做测试的模拟函数，并可以用stub指令指定DOS程序。
由于stub就是用来代替所测的子模块，故而它不能为空
####在分布式计算环境中:
存根代表参与分布式对象的通信的客户端侧对象。
存根担任分布式对象通信的角色。
存根作为一个网关，客户端对象和服务器端对象，通过它进行路由所有传出请求。存根包装客户端对象的功能，并通过添加网络逻辑保证了可靠的客户端和服务器之间的通信通道。可以写上去的存根，手动或自动生成，这取决于所选择的通信协议。
的存根是负责：
向服务器发起通信骨架
翻译从调用者调用对象
编组的参数
通知该呼叫应该被调用的骨架
在网络上传递参数的骨架
从骨架解组的响应
通知该呼叫是完整的骨架
##模拟函数的使用 (Stub Function):
通常，此种暂时用来代替某些功能的模拟函数称为 Stub，举例而言，假如我们有一个装置可以侦测温度，但是该装置的硬体尚未制作完成，此时，我们可以利用类似范例 1,9的函数，暂时先传回一个温度值，以让后续的程式可以顺利的进行测试，此种函数就称为 Stub。
范例 1.0 用来取得温度的 Stub 函数
void Thermometer() {
#ifdef _SIMULATOR _
return 28;
#else
#endif
}
利用 stub 函数，可以让未完成的系统得以进行测试，其展现的行为类似于目标系统。如此，程式开发人员可以在硬体未完成之前就进行程式撰写与测试工作，因此，能有效加快系统的开发时程，以使专案提早完成。
③ 如何从python代码中直接访问android的Service
在Kivy中，通过pyjnius扩展可以间接调用Java代码，而pyjnius利用的是Java的反射机制。但是在Python对象和Java对象中转来转去总让人感觉到十分别扭。好在Android提供了binder这个进程间通信的功能，Java中的Service也是基于Binder的C++代码封装来实现进程间通信的，这也为从Python代码中绕开pyjnius直接访问Java代码提供了可能，既然Java的Service是基于C++的封装来实现的，也同样可以在Python中封装同样的C++代码，这篇文章讲解了如何通过binder在Python代码中直接访问Java的Service，如WifiService。
binder_wrap.h
#ifndef BINDER_WRAP_H
#define BINDER_WRAP_H
#ifdef __cplusplus
extern "C" {
#endif
typedef int (*vector_visitor)(const char16_t* str16,int length,void *data);
typedef int (*fnOnTransact)(uint32_t code,const void *data,void *reply,uint32_t flags,void *userData);
int server_create(const char *name,const char *descriptor,fnOnTransact onTrans,void *data);
void* binder_getbinder(const char *name);
int binder_releasebinder(void* binder);
int binder_listServices(vector_visitor visitor,void *data);
int binder_getInterfaceDescriptor(void *binder,char16_t *descriptor,size_t size);
int binder_transact(void* binder,int code,const void *data,void* reply,int flags);
void* parcel_new();
int parcel_destroy(void* parcel);
int parcel_writeInterfaceToken(void* parcel,const char *interface);
int parcel_writeInt32(void *parcel,int val);
int parcel_writeCString(void *parcel,const char* str);
int parcel_writeString16(void *parcel,const char16_t* str, size_t len);
int parcel_readInt32(void *parcel);
long parcel_readInt64(void *parcel);
int parcel_readString16(void *parcel,char16_t* str, size_t len);
int parcel_readInplace(void *parcel,void* data, int len);
int parcel_readExceptionCode(void *parcel);
int parcel_dataAvail(void *parcel);
#ifdef __cplusplus
}
#endif
#endif
binder_wrap.cpp
#include <sys/types.h>
#include <unistd.h>
#include <grp.h>
#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <utils/Log.h>
#include <binder/Parcel.h>
#include "binder_wrap.h"
using namespace android;
void* binder_getbinder(const char *name)
{
android::sp<android::IServiceManager> sm = android::defaultServiceManager();
sp<IBinder> *binder = new sp<IBinder>();
do {
*binder = sm->getService(android::String16(name));
if (binder != 0)
{
break;
}
usleep(500000); // 0.5 s
} while(true);
return reinterpret_cast<void *>(binder);
}
int binder_releasebinder(void* binder)
{
sp<IBinder> *bp = reinterpret_cast<sp<IBinder> *>(binder);
if(bp == 0)
{
return 0;
}
delete bp;
return 1;
}
//Vector<String16> listServices() = 0;
int binder_listServices(vector_visitor visitor,void *data)
{
android::sp<android::IServiceManager> sm = android::defaultServiceManager();
Vector<String16> list = sm->listServices();
for (int i=0;i<list.size();i++)
{
visitor(list[i].string(),list[i].size(),data);
}
return list.size();
}
int binder_getInterfaceDescriptor(void *binder,char16_t *descriptor,size_t size)
{
sp<IBinder> *bp = reinterpret_cast<sp<IBinder> *>(binder);
if(bp == 0)
{
return 0;
}
if (descriptor == NULL || size <= 0)
{
return 0;
}
String16 des = (*bp)->getInterfaceDescriptor();
if (size > des.size())
{
size = des.size();
}
memcpy(descriptor,des.string(),size*2);
return size;
}
//int binder_transact(void* binder,int code,const Parcel& data,Parcel* reply,int flags = 0)
int binder_transact(void* binder,int code,const void *data,void* reply,int flags)
{
sp<IBinder> *bp = reinterpret_cast<sp<IBinder> *>(binder);
if(bp == 0 || data == 0 || reply == 0)
{
return 0;
}
return (*bp)->transact(code,*(Parcel*)data,(Parcel*)reply,flags);
}
void* parcel_new()
{
return (void*)new Parcel();
}
int parcel_destroy(void* parcel)
{
if(parcel == 0)
{
return 0;
}
delete (Parcel*)parcel;
return 1;
}
int parcel_writeInterfaceToken(void* parcel,const char *interface)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->writeInterfaceToken(String16(interface));
}
int parcel_writeInt32(void *parcel,int val)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->writeInt32(val);
}
int parcel_writeCString(void *parcel,const char* str)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->writeCString(str);
}
int parcel_writeString16(void *parcel,const char16_t* str, size_t len)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
if (str == 0 || len <= 0)
{
return 0;
}
return p->writeString16(str,len);
}
int parcel_readInt32(void *parcel)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->readInt32();
}
long parcel_readInt64(void *parcel)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->readInt64();
}
int parcel_readString16(void *parcel,char16_t* str, size_t len)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
if (str == NULL || len <= 0)
{
return 0;
}
String16 str16 = p->readString16();
if (len > str16.size())
{
len = str16.size();
}
memcpy(str,str16.string(),len*2);
return len;
}
int parcel_readExceptionCode(void *parcel)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->readExceptionCode();
}
int parcel_readInplace(void *parcel,void* data, int len)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
if (len >= 0 && len <= (int32_t)p->dataAvail())
{
const void *d = p->readInplace(len);
memcpy(data,d,len);
return len;
}
return 0;
}
int parcel_dataAvail(void *parcel)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->dataAvail();
}
④ 如何让python调用C和C++代码
要搞明白如何让python调用C/C++代码(也就是写python的extension)，你需要征服手册中的<<Extending && embedding>>厚厚的一章。在昨天花了一个小时看地头晕脑胀，仍然不知道如何写python的extension后，查阅了一些其他书籍，最终在<<Python Programming On Win32>>书中找到了教程。
1. 首先要明白的是，所谓的python扩展（也就是你提供给python的c/c++代码，不一定是c/c++代码，可以是其他语言写的代码)是一个dll,并且这个dll放在本机python安装目录下的DLLs目录下（譬如我机器上的路径是：F:/Program Files/Python25/DLLs)，假如我们接下来要写的扩展mole名为mb,python调用的代码为：import mbmb.showMsg("Python's really amazing, I kindda love it!")
2. 搭建环境，我们要使用python提供的c头文件和lib库来进行扩展的开发。
在vs 2005下点击菜单 "工具"->"选项", 打开选项对话框，选择"项目和解决方案->VC++目录", 然后在右边"显示以下内容的目录"得comboBox上选择"包含文件”，添加python的include目录(我的机器上是"F:/Program Files/Python25/include"),然后选择库文件,添加python的libs目录(我的机器上是"F:/Program Files/Python25/libs")。
既然扩展是一个dll,接下来我们要建立一个“动态链接库”工程，然后开始写代码：
#include <python.h> //python.h是包含python一些定义的头文件，在python的include目录下/*我的python版本是2.5, 因为安装python后它没提供debug下的lib库文件，因此你必须生成release版的dll，
想要生成dll版本的，你要到python官网上自己去下载python源代码,当然你可以继续生成release版本的dll,但dll中包含调试信息*/#pragma comment(lib, "python25.lib")//先不管static PyObject* mb_showMsg(PyObject* self, PyObject *args);/*如果你的扩展是mb,那么必须实现一个initmb函数，并且从dll中导出这个函数，但我们在python中调用import mb时，python会去dll里去调用
extern "C" __declspec(dllexport) void initmb(){/*当调用mb.showMsg("Python's really amazing, I kindda love it!")时， 相当于你告诉python我有一个showMsg函数，我们怎么告诉python去调用我们dll里的mb_showMsg函数呢？技巧就是下面的方式，定义一个字典数据结构，key => showMsg, value =>mb_showMsg,METH_VARARGS是函数调用方式，仔细查手册吧*/static PyMethodDef mbMethods[] = {
{"showMsg", mb_showMsg, METH_VARARGS},
{NULL, NULL, NULL} /*sentinel，哨兵，用来标识结束*/};//告诉python我们的模块名叫mb, 模块包含的函数都在mbMethods字典里
PyObject *m = Py_InitMole("mb", mbMethods);}/*接下来实现核心功能showMsg*///第一个self参数我们用不着，具体查手册，第二个参数是python传给我们的参数,它是一个python的参数tuple
static PyObject* mb_showMsg(PyObject* self, PyObject *args){//我们的showMsg函数需要的是一个字符串参数
const char* msg = NULL;/*调用特殊参数解码python传递给我们的参数,s是string,我们传递接收参数的变量地址,
如果你的功能函数需要两个参数，在PyArg_parseTuple后面继续添加接受参数的变量地址，
这个函数的原型是类似printf的不定参数的形式
PyAPI_FUNC(int) PyArg_ParseTuple(PyObject *, const char *, ...);*/if (!PyArg_ParseTuple(args, "s", &msg))
return NULL;//调用MBint r = ::MessageBox(NULL, "hello", "Caption:Form C mole", MB_ICONINFORMATION | MB_OK);//返回值return Py_BuildValue("i", r);}将上面这段混杂着大量注释的代码拷贝到你的编辑器里，然后编译生成mb.dll,修改后缀成mb.pyd,然后拷贝到python的DLLs目录下，打开idle(python的交互程序）,写入代码：import mbmb.showMsg("Python's really amazing, I kindda love it!")
⑤ 求大佬帮忙教一下进阶编程作业。Python或者C++实现都可以
首先分析题目，题目要求判定n!能否整除m，有一种很简单的解法就是用高精度数据直接求出n!并对m求余，但这种算法存在局限性，n的值越大，算法的时间复杂度就越大，给出的示例中n只有20，所以可以轻松解出来，但当n的值是10000或1000000000时，算一天都不一定能算完，而且空间上由于乘法不能直接给原值赋值，所以每次乘法时都会开辟至少相当于原值大小的空间，所以此方法不能通过
现在重新设计算法，一个数能否整除另一个数取决于这个数的质因数中是否包括另一个数的所有质因数，所以多个数的乘积能否整除另一个数取决于这些数的全部质因数中是否包括另一个数的所有质因数
那么问题迎刃而解，首先分解出m的所有质因数，然后遍历2-n（假设遍历时的数据存储到i），从m的质因数当中删去m与i的所有公共质因数，直到m的质因数为空或遍历结束，若最后m的质因数为空，则n!能整除m，否则n!不能整除m
于是得出代码：
#include <ctime>
#include <iostream>
#include <vector>
//返回a的质因数，升序排列，不包括1
template <typename _Int>
::std::vector<_Int> DecomposePrimeFactor(_Int a) {
::std::vector<_Int> res;
if (1 < a) {
for (_Int i = 2; 1 != a; ++i) {
while (0 == a % i) {
a /= i;
res.push_back(i);
}
}
}
return res;
}
//删除两个数组中相同的元素
template <typename _Elem>
void RemoveSame(::std::vector<_Elem>& v1, ::std::vector<_Elem>& v2) {
for (auto j = v1.begin(); v1.end() != j; ) {
auto f = ::std::find(v2.begin(), v2.end(), *j);
if (v2.end() != f) {
j = v1.erase(j);
v2.erase(f);
}
else {
++j;
}
}
}
//n!是否能整除m
template <typename _Int>
bool CanFactorialDivide(_Int n, _Int m) {
auto v = DecomposePrimeFactor(m);
if (!v.empty() && n < m) {
//如果a < b (a为正整数，b为质数)，那么a的质因数中一定不存在b
//由此可以对代码做一些优化
for (int i = v[0]; i <= n; ) {
auto iv = DecomposePrimeFactor(i);
RemoveSame(v, iv);
if (v.empty()) {
break;
}
i = ::std::max(v[0], i + 1);
}
}
return v.empty();
}
static constexpr bool kDebug =
#ifdef _DEBUG
true
#else
false
#endif
;
int main(int argc, char* argv[]) {
int n;
int m;
clock_t st;
clock_t et;
::std::cin >> n >> m;
if constexpr (kDebug) {
st = clock();
}
bool divide = CanFactorialDivide(n, m);
if constexpr (kDebug) {
et = clock();
}
if (divide) {
::std::cout << "YES. " << n << "! divides by " << m << "." << ::std::endl;
}
else {
::std::cout << "NO. " << n << "! does not divide by " << m << "." << ::std::endl;
}
if constexpr (kDebug) {
::std::cout << "It took " << et - st << "ms." << ::std::endl;
}
return 0;
}
⑥ 如何在linux下用c调用过python
#include <string>
#include <map>
#include <Python.h>
typedef std::map<std::string,PyObject*> pyMoleMap;
typedef pyMoleMap::iterator pyMoleMapIter;
class PyOperBase
{
public:
static int initPython() //must running at the main thread
{
if(m_isInit == true)
return true;
Py_Initialize();
if(!Py_IsInitialized())
{
return false;
}
//Need to specify the current path path only Linux
#ifdef LINUX
PyRun_SimpleString("import sys");
PyRun_SimpleString("sys.path.append('./')");
#endif
//PyEval_InitThreads();
//PyEval_ReleaseThread(PyThreadState_Get());
m_isInit = true;
return true;
}
static int releasePython()
{
if(!m_isInit) return false;
pyMoleMapIter iter;
PyObject* pMole = NULL;
for(iter = m_MoleMap.begin(); iter != m_MoleMap.end(); iter++)
{
pMole = iter->second;
Py_DECREF(pMole);
}
m_MoleMap.clear();
//PyGILState_Ensure();
Py_Finalize();
m_isInit = false;
return true;
}
static bool getInitStatus()
{
return m_isInit;
}
static int getModleDictByScriptName(std::string& script, PyObject** object)
{
if(m_isInit != true)
return false;
PyObject *pName = NULL, *pMole = NULL;
pyMoleMapIter iter = m_MoleMap.find(script);
if(iter != m_MoleMap.end())
{
pMole = iter->second;
if(!getDictByModle(pMole,object))
return false;
return true;
}
pName = PyString_FromString(script.c_str());
pMole = PyImport_Import(pName);
Py_DECREF(pName);
if(!pMole)
{
return false;
}
if(!getDictByModle(pMole,object))
{
Py_DECREF(pMole);
return false;
}
m_MoleMap.insert(std::pair<std::string,PyObject*>(script,pMole));
return true;
}
private:
static int getDictByModle(PyObject* pModle, PyObject** ppDict)
{
PyObject *pDict = NULL;
pDict = PyMole_GetDict(pModle);
if(!pDict)
{
return false;
}
*ppDict = pDict;
return true;
}
static bool m_isInit;
static pyMoleMap m_MoleMap;
};
class PyThreadLock
{
public:
PyThreadLock(void)
{
state = PyGILState_Ensure( );
}
~PyThreadLock(void)
{
PyGILState_Release( state );
}
private:
PyGILState_STATE state;
};
.cpp文件如下
#include "XPS2SVG_py.h"
bool PyOperBase::m_isInit = false;
pyMoleMap PyOperBase::m_MoleMap;
我linux下环境变量配置好了python路径，所以直接#include <Python.h>了
以上代码在windows下跑没问题。
但到linux下,pMole = PyImport_Import(pName);会返回空
应该是没找到pName标识的模块，但是pName标识标识的模块文件就在可执行文件的当前目录下
⑦ 运行python水仙花数代码在win7错误，而linux 正确
python是跨平台的语言，可以同时在win7和linux上运行。
你的程序判断水仙花数的逻辑没有错误，打印i,j,k三次方的次序有问题。
我在win7上修改了一下，可以正常输出
for n in range(152,156):
i = n / 100
j = (n / 10) % 10
k = n % 10
print('n=%-3d i=%d j=%d k=%d'%(n,i,j,k))
# print('n=%-3d i^3=%d j^3=%d k^3=%d'%(n,k*k*k , j*j*j , i*i*i))
print('n=%-3d i^3=%d j^3=%d k^3=%d'%(n, i*i*i, j*j*j , k*k*k))
if n == k**3 + j**3 + i**3:
print ("n=%-3d" % n)
print("\n")
运行结果:
n=152 i=1 j=5 k=2
n=152 i^3=1 j^3=125 k^3=8
n=153 i=1 j=5 k=3
n=153 i^3=1 j^3=125 k^3=27
n=153
n=154 i=1 j=5 k=4
n=154 i^3=1 j^3=125 k^3=64
n=155 i=1 j=5 k=5
n=155 i^3=1 j^3=125 k^3=125
⑧ 如何从python代码中直接访问Android的Service
在Ubuntu下用Python搭建桌面算法交易研究环境
binder_wrap.h
#ifndef BINDER_WRAP_H
#define BINDER_WRAP_H
#ifdef __cplusplus
extern "C" {
#endif
typedef int (*vector_visitor)(const char16_t* str16,int length,void *data);
typedef int (*fnOnTransact)(uint32_t code,const void *data,void *reply,uint32_t flags,void *userData);
int server_create(const char *name,const char *descriptor,fnOnTransact onTrans,void *data);
void* binder_getbinder(const char *name);
int binder_releasebinder(void* binder);
int binder_listServices(vector_visitor visitor,void *data);
int binder_getInterfaceDescriptor(void *binder,char16_t *descriptor,size_t size);
int binder_transact(void* binder,int code,const void *data,void* reply,int flags);
void* parcel_new();
int parcel_destroy(void* parcel);
int parcel_writeInterfaceToken(void* parcel,const char *interface);
int parcel_writeInt32(void *parcel,int val);
int parcel_writeCString(void *parcel,const char* str);
int parcel_writeString16(void *parcel,const char16_t* str, size_t len);
int parcel_readInt32(void *parcel);
long parcel_readInt64(void *parcel);
int parcel_readString16(void *parcel,char16_t* str, size_t len);
int parcel_readInplace(void *parcel,void* data, int len);
int parcel_readExceptionCode(void *parcel);
int parcel_dataAvail(void *parcel);
#ifdef __cplusplus
}
#endif
#endif
binder_wrap.cpp
#include <sys/types.h>
#include <unistd.h>
#include <grp.h>
#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <utils/Log.h>
#include <binder/Parcel.h>
#include "binder_wrap.h"
using namespace android;
void* binder_getbinder(const char *name)
{
android::sp<android::IServiceManager> sm = android::defaultServiceManager();
sp<IBinder> *binder = new sp<IBinder>();
do {
*binder = sm->getService(android::String16(name));
if (binder != 0)
{
break;
}
usleep(500000); // 0.5 s
} while(true);
return reinterpret_cast<void *>(binder);
}
int binder_releasebinder(void* binder)
{
sp<IBinder> *bp = reinterpret_cast<sp<IBinder> *>(binder);
if(bp == 0)
{
return 0;
}
delete bp;
return 1;
}
//Vector<String16> listServices() = 0;
int binder_listServices(vector_visitor visitor,void *data)
{
android::sp<android::IServiceManager> sm = android::defaultServiceManager();
Vector<String16> list = sm->listServices();
for (int i=0;i<list.size();i++)
{
visitor(list[i].string(),list[i].size(),data);
}
return list.size();
}
int binder_getInterfaceDescriptor(void *binder,char16_t *descriptor,size_t size)
{
sp<IBinder> *bp = reinterpret_cast<sp<IBinder> *>(binder);
if(bp == 0)
{
return 0;
}
if (descriptor == NULL || size <= 0)
{
return 0;
}
String16 des = (*bp)->getInterfaceDescriptor();
if (size > des.size())
{
size = des.size();
}
memcpy(descriptor,des.string(),size*2);
return size;
}
//int binder_transact(void* binder,int code,const Parcel& data,Parcel* reply,int flags = 0)
int binder_transact(void* binder,int code,const void *data,void* reply,int flags)
{
sp<IBinder> *bp = reinterpret_cast<sp<IBinder> *>(binder);
if(bp == 0 || data == 0 || reply == 0)
{
return 0;
}
return (*bp)->transact(code,*(Parcel*)data,(Parcel*)reply,flags);
}
void* parcel_new()
{
return (void*)new Parcel();
}
int parcel_destroy(void* parcel)
{
if(parcel == 0)
{
return 0;
}
delete (Parcel*)parcel;
return 1;
}
int parcel_writeInterfaceToken(void* parcel,const char *interface)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->writeInterfaceToken(String16(interface));
}
int parcel_writeInt32(void *parcel,int val)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->writeInt32(val);
}
int parcel_writeCString(void *parcel,const char* str)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->writeCString(str);
}
int parcel_writeString16(void *parcel,const char16_t* str, size_t len)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
if (str == 0 || len <= 0)
{
return 0;
}
return p->writeString16(str,len);
}
int parcel_readInt32(void *parcel)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->readInt32();
}
long parcel_readInt64(void *parcel)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->readInt64();
}
int parcel_readString16(void *parcel,char16_t* str, size_t len)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
if (str == NULL || len <= 0)
{
return 0;
}
String16 str16 = p->readString16();
if (len > str16.size())
{
len = str16.size();
}
memcpy(str,str16.string(),len*2);
return len;
}
int parcel_readExceptionCode(void *parcel)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->readExceptionCode();
}
int parcel_readInplace(void *parcel,void* data, int len)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
if (len >= 0 && len <= (int32_t)p->dataAvail())
{
const void *d = p->readInplace(len);
memcpy(data,d,len);
return len;
}
return 0;
}
int parcel_dataAvail(void *parcel)
{
Parcel *p = reinterpret_cast<Parcel *>(parcel);
if(p == 0)
{
return 0;
}
return p->dataAvail();
}
本篇文章来源于 Linux公社网站(www.linuxidc.com) 原文链接：http://www.linuxidc.com/Linux/2014-08/105192.htm
⑨ 如何从Python代码中直接访问Android的Service
您好，希望以下回答能帮助您
在Ubuntu下用Python搭建桌面算法交易研究环境
binder_wrap.h
#ifndef BINDER_WRAP_H
#define BINDER_WRAP_H
#ifdef __cplusplus
extern "C" {
#endif
typedef int (*vector_visitor)(const char16_t* str16,int length,void *data);
typedef int (*fnOnTransact)(uint32_t code,const void *data,void *reply,uint32_t flags,void *userData);
int server_create(const char *name,const char *descriptor,fnOnTransact onTrans,void *data);
void* binder_getbinder(const char *name);
int binder_releasebinder(void* binder);
int binder_listServices(vector_visitor visitor,void *data);
int binder_getInterfaceDescriptor(void *binder,char16_t *descriptor,size_t size);
int binder_transact(void* binder,int code,const void *data,void* reply,int flags);
void* parcel_new();
int parcel_destroy(void* parcel);
int parcel_writeInterfaceToken(void* parcel,const char *interface);
int parcel_writeInt32(void *parcel,int val);
int parcel_writeCString(void *parcel,const char* str);
int parcel_writeString16(void *parcel,const char16_t* str, size_t len);
int parcel_readInt32(void *parcel);
long parcel_readInt64(void *parcel);
int parcel_readString16(void *parcel,char16_t* str, size_t len);
int parcel_readInplace(void *parcel,void* data, int len);
int parcel_readExceptionCode(void *parcel);
int parcel_dataAvail(void *parcel);
#ifdef __cplusplus
}
如您还有疑问可继续追问。