① 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
}
如您還有疑問可繼續追問。