✅指针_互转【更新】

莫小乐

  

DLL命令名	返回值类型	公开	备 注
lstrcpyn_指针_长整数型	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
lstrcpyn
参数名	类 型	传址	数组	备 注
目标	长整数型
源	长整数型
长度	整数型

DLL命令名	返回值类型	公开	备 注
lstrcpyn_指针_短整数型	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
lstrcpyn
参数名	类 型	传址	数组	备 注
目标	短整数型
源	短整数型
长度	整数型

DLL命令名	返回值类型	公开	备 注
lstrcpyn_指针_整数型	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
lstrcpyn
参数名	类 型	传址	数组	备 注
目标	整数型
源	整数型
长度	整数型

DLL命令名	返回值类型	公开	备 注
lstrcpyn_指针_小数型	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
lstrcpyn
参数名	类 型	传址	数组	备 注
目标	小数型
源	小数型
长度	整数型

DLL命令名	返回值类型	公开	备 注
HeapAlloc_空白字节集	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
HeapAlloc
参数名	类 型	传址	数组	备 注
堆栈句柄	整数型
标志	整数型
分配大小	整数型

DLL命令名	返回值类型	公开	备 注
GetProcessHeap_空白字节集	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
GetProcessHeap
参数名	类 型	传址	数组	备 注

DLL命令名	返回值类型	公开	备 注
lstrcpyn_指针_字节集	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
lstrcpyn
参数名	类 型	传址	数组	备 注
欲取其指针	字节集
欲取其指针	字节集
保留	整数型			0

DLL命令名	返回值类型	公开	备 注
RtlMoveMemory_int2Bytes_指针_字节集	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
RtlMoveMemory
参数名	类 型	传址	数组	备 注
Destination	字节集
字节集指针	整数型
数据长度	整数型

DLL命令名	返回值类型	公开	备 注
RtlMoveMemory_指针_文本型
DLL库文件名:
在DLL库中对应命令名:
RtlMoveMemory
参数名	类 型	传址	数组	备 注
Destination	整数型
Source	整数型
Length	整数型

DLL命令名	返回值类型	公开	备 注
lstrlenA_指针_文本型	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
lstrlenA
参数名	类 型	传址	数组	备 注
lpString	整数型

DLL命令名	返回值类型	公开	备 注
lstrcpyn_指针_文本型	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
lstrcpyn
参数名	类 型	传址	数组	备 注
目标	文本型
源	文本型
长度	整数型

DLL命令名	返回值类型	公开	备 注
IsBadStringPtrA_指针_是否有效	整数型
DLL库文件名:
kernel32.dll
在DLL库中对应命令名:
IsBadStringPtrA
参数名	类 型	传址	数组	备 注
指针	整数型
ucchMax	整数型

子程序名	返回值类型	公开	备 注
指针_递增			博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
被加数指针	整数型
偏移	整数型

置入代码 ({ 139, 69, 8, 3, 69, 12, 255, 0 })

子程序名	返回值类型	公开	备 注
指针_递减			博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
被减数指针	整数型
偏移	整数型

置入代码 ({ 139, 69, 8, 43, 69, 12, 255, 8 })

子程序名	返回值类型	公开	备 注
指针_是否有效	逻辑型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
要判断的指针地址	整数型

返回 (IsBadStringPtrA_指针_是否有效 (要判断的指针地址, 4) ＝ 0)

子程序名	返回值类型	公开	备 注
取指针_子程序	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
proc	子程序指针

变量名	类 型	静态	数组	备 注
ret	整数型

置入代码 ({ 139, 69, 8, 137, 69, 252 })
返回 (ret)

子程序名	返回值类型	公开	备 注
到指针_子程序	子程序指针		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
val	整数型

变量名	类 型	静态	数组	备 注
ret	子程序指针

置入代码 ({ 139, 69, 8, 137, 69, 252 })
返回 (ret)

子程序名	返回值类型	公开	备 注
取指针_文本型	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
欲取地址的数据	文本型

返回 (lstrcpyn_指针_文本型 (欲取地址的数据, 欲取地址的数据, 0))

子程序名	返回值类型	公开	备 注
到指针_文本型	文本型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
文本指针	整数型

变量名	类 型	静态	数组	备 注
长度	整数型
文本	文本型

长度 ＝ lstrlenA_指针_文本型 (文本指针) ＋ 1
文本 ＝ 取空白文本 (长度)
RtlMoveMemory_指针_文本型 (取指针_文本型 (文本), 文本指针, 长度)
返回 (文本)

子程序名	返回值类型	公开	备 注
取指针_文本型1	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
文本	文本型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
到指针_文本型1	文本型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
指针	整数型

置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })
返回 (“”)

子程序名	返回值类型	公开	备 注
取指针_字节集	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
欲取地址的数据	字节集

返回 (lstrcpyn_指针_字节集 (欲取地址的数据, 欲取地址的数据, 0))

子程序名	返回值类型	公开	备 注
到指针_字节集	字节集		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
字节集指针	整数型
数据长度	整数型

变量名	类 型	静态	数组	备 注
字节集	字节集

字节集 ＝ API_取空白字节集 (数据长度)
RtlMoveMemory_int2Bytes_指针_字节集 (字节集, 字节集指针, 数据长度)
返回 (字节集)

子程序名	返回值类型	公开	备 注
API_取空白字节集	字节集		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
零字节数目	整数型

变量名	类 型	静态	数组	备 注
字节集指针	整数型

如果真 (零字节数目 ≤ 0)
置入代码 ({ 51, 192, 139, 229, 93, 194, 4, 0 })
字节集指针 ＝ HeapAlloc_空白字节集 (GetProcessHeap_空白字节集 (), 8, 零字节数目 ＋ 8)
如果真 (字节集指针 ＝ 0)
置入代码 ({ 139, 229, 93, 194, 4, 0 })
置入代码 ({ 254, 0, 255, 117, 8, 143, 64, 4, 139, 229, 93, 194, 4, 0 })
返回 ({  })

子程序名	返回值类型	公开	备 注
取指针_字节型	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
数据	字节型

置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
到指针_字节型	字节型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
指针	整数型

置入代码 ({ 139, 69, 8, 138, 0, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
取指针_逻辑型	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
数据	逻辑型

置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
到指针_逻辑型	逻辑型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
指针	整数型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (假)

子程序名	返回值类型	公开	备 注
取指针_小数型	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
欲取地址的数据	小数型

返回 (lstrcpyn_指针_小数型 (欲取地址的数据, 欲取地址的数据, 0))

子程序名	返回值类型	公开	备 注
到指针_小数型	小数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
指针	整数型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
取指针_整数型	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
欲取地址的数据	整数型

返回 (lstrcpyn_指针_整数型 (欲取地址的数据, 欲取地址的数据, 0))

子程序名	返回值类型	公开	备 注
到指针_整数型	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
整数指针	整数型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
取指针_短整数型	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
欲取地址的数据	短整数型

返回 (lstrcpyn_指针_短整数型 (欲取地址的数据, 欲取地址的数据, 0))

子程序名	返回值类型	公开	备 注
到指针_短整数型	短整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
指针	整数型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
取指针_长整数型	长整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
欲取地址的数据	长整数型

返回 (lstrcpyn_指针_长整数型 (欲取地址的数据, 欲取地址的数据, 0))

子程序名	返回值类型	公开	备 注
到指针_长整数型	长整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
指针	整数型

变量名	类 型	静态	数组	备 注
Ret	长整数型

置入代码 ({ 139, 69, 8, 255, 48, 143, 69, 248, 255, 112, 4, 143, 69, 252 })
返回 (Ret)

子程序名	返回值类型	公开	备 注
取指针_日期时间型	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
数据	日期时间型

置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
到指针_日期时间型	日期时间型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
指针	整数型

变量名	类 型	静态	数组	备 注
结果	日期时间型

置入代码 ({ 139, 69, 8, 139, 16, 137, 85, 248, 139, 64, 4, 137, 69, 252 })
返回 (结果)

子程序名	返回值类型	公开	备 注
取指针_双精度小数型	整数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
数据	双精度小数型

置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
到指针_双精度小数型	双精度小数型		博乐助手整理   浪子优化
参数名	类 型	参考	可空	数组	备 注
指针	整数型

变量名	类 型	静态	数组	备 注
结果	双精度小数型

置入代码 ({ 139, 69, 8, 139, 16, 137, 85, 248, 139, 64, 4, 137, 69, 252 })
返回 (结果)

.版本 2<br /> <br /> .DLL命令 lstrcpyn_指针_长整数型, 整数型, "kernel32.dll", "lstrcpyn"<br />     .参数 目标, 长整数型, 传址<br />     .参数 源, 长整数型, 传址<br />     .参数 长度, 整数型<br /> <br /> .DLL命令 lstrcpyn_指针_短整数型, 整数型, "kernel32.dll", "lstrcpyn"<br />     .参数 目标, 短整数型, 传址<br />     .参数 源, 短整数型, 传址<br />     .参数 长度, 整数型<br /> <br /> .DLL命令 lstrcpyn_指针_整数型, 整数型, "kernel32.dll", "lstrcpyn"<br />     .参数 目标, 整数型, 传址<br />     .参数 源, 整数型, 传址<br />     .参数 长度, 整数型<br /> <br /> .DLL命令 lstrcpyn_指针_小数型, 整数型, "kernel32.dll", "lstrcpyn"<br />     .参数 目标, 小数型, 传址<br />     .参数 源, 小数型, 传址<br />     .参数 长度, 整数型<br /> <br /> .DLL命令 HeapAlloc_空白字节集, 整数型, "kernel32.dll", "HeapAlloc"<br />     .参数 堆栈句柄, 整数型<br />     .参数 标志, 整数型<br />     .参数 分配大小, 整数型<br /> <br /> .DLL命令 GetProcessHeap_空白字节集, 整数型, "kernel32.dll", "GetProcessHeap"<br /> <br /> .DLL命令 lstrcpyn_指针_字节集, 整数型, "kernel32.dll", "lstrcpyn"<br />     .参数 欲取其指针, 字节集, 传址<br />     .参数 欲取其指针, 字节集, 传址<br />     .参数 保留, 整数型, , 0<br /> <br /> .DLL命令 RtlMoveMemory_int2Bytes_指针_字节集, 整数型, "kernel32.dll", "RtlMoveMemory"<br />     .参数 Destination, 字节集<br />     .参数 字节集指针, 整数型<br />     .参数 数据长度, 整数型<br /> <br /> .DLL命令 RtlMoveMemory_指针_文本型, , , "RtlMoveMemory"<br />     .参数 Destination, 整数型<br />     .参数 Source, 整数型<br />     .参数 Length, 整数型<br /> <br /> .DLL命令 lstrlenA_指针_文本型, 整数型, "kernel32.dll", "lstrlenA"<br />     .参数 lpString, 整数型<br /> <br /> .DLL命令 lstrcpyn_指针_文本型, 整数型, "kernel32.dll", "lstrcpyn"<br />     .参数 目标, 文本型, 传址<br />     .参数 源, 文本型, 传址<br />     .参数 长度, 整数型<br /> <br /> .DLL命令 IsBadStringPtrA_指针_是否有效, 整数型, "kernel32.dll", "IsBadStringPtrA"<br />     .参数 指针, 整数型<br />     .参数 ucchMax, 整数型<br /> .版本 2<br /> <br /> .子程序 指针_递增, , , 博乐助手整理   浪子优化<br /> .参数 被加数指针, 整数型<br /> .参数 偏移, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 3, 69, 12, 255, 0 })<br /> <br /> .子程序 指针_递减, , , 博乐助手整理   浪子优化<br /> .参数 被减数指针, 整数型<br /> .参数 偏移, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 43, 69, 12, 255, 8 })<br /> <br /> .子程序 指针_是否有效, 逻辑型, , 博乐助手整理   浪子优化<br /> .参数 要判断的指针地址, 整数型<br /> <br /> 返回 (IsBadStringPtrA_指针_是否有效 (要判断的指针地址, 4) ＝ 0)<br /> <br /> .子程序 取指针_子程序, 整数型, , 博乐助手整理   浪子优化<br /> .参数 proc, 子程序指针<br /> .局部变量 ret, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 137, 69, 252 })<br /> 返回 (ret)<br /> <br /> .子程序 到指针_子程序, 子程序指针, , 博乐助手整理   浪子优化<br /> .参数 val, 整数型<br /> .局部变量 ret, 子程序指针<br /> <br /> 置入代码 ({ 139, 69, 8, 137, 69, 252 })<br /> 返回 (ret)<br /> <br /> .子程序 取指针_文本型, 整数型, , 博乐助手整理   浪子优化<br /> .参数 欲取地址的数据, 文本型, 参考<br /> <br /> 返回 (lstrcpyn_指针_文本型 (欲取地址的数据, 欲取地址的数据, 0))<br /> <br /> .子程序 到指针_文本型, 文本型, , 博乐助手整理   浪子优化<br /> .参数 文本指针, 整数型<br /> .局部变量 长度, 整数型<br /> .局部变量 文本, 文本型<br /> <br /> 长度 ＝ lstrlenA_指针_文本型 (文本指针) ＋ 1<br /> 文本 ＝ 取空白文本 (长度)<br /> RtlMoveMemory_指针_文本型 (取指针_文本型 (文本), 文本指针, 长度)<br /> 返回 (文本)<br /> <br /> .子程序 取指针_文本型1, 整数型, , 博乐助手整理   浪子优化<br /> .参数 文本, 文本型, 参考<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 到指针_文本型1, 文本型, , 博乐助手整理   浪子优化<br /> .参数 指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })<br /> 返回 (“”)<br /> <br /> .子程序 取指针_字节集, 整数型, , 博乐助手整理   浪子优化<br /> .参数 欲取地址的数据, 字节集, 参考<br /> <br /> 返回 (lstrcpyn_指针_字节集 (欲取地址的数据, 欲取地址的数据, 0))<br /> <br /> .子程序 到指针_字节集, 字节集, , 博乐助手整理   浪子优化<br /> .参数 字节集指针, 整数型<br /> .参数 数据长度, 整数型<br /> .局部变量 字节集, 字节集<br /> <br /> 字节集 ＝ API_取空白字节集 (数据长度)<br /> RtlMoveMemory_int2Bytes_指针_字节集 (字节集, 字节集指针, 数据长度)<br /> 返回 (字节集)<br /> <br /> .子程序 API_取空白字节集, 字节集, , 博乐助手整理   浪子优化<br /> .参数 零字节数目, 整数型<br /> .局部变量 字节集指针, 整数型<br /> <br /> .如果真 (零字节数目 ≤ 0)<br />     置入代码 ({ 51, 192, 139, 229, 93, 194, 4, 0 })<br /> .如果真结束<br /> 字节集指针 ＝ HeapAlloc_空白字节集 (GetProcessHeap_空白字节集 (), 8, 零字节数目 ＋ 8)<br /> .如果真 (字节集指针 ＝ 0)<br />     置入代码 ({ 139, 229, 93, 194, 4, 0 })<br /> .如果真结束<br /> 置入代码 ({ 254, 0, 255, 117, 8, 143, 64, 4, 139, 229, 93, 194, 4, 0 })<br /> 返回 ({  })<br /> <br /> .子程序 取指针_字节型, 整数型, , 博乐助手整理   浪子优化<br /> .参数 数据, 字节型, 参考<br /> <br /> 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 到指针_字节型, 字节型, , 博乐助手整理   浪子优化<br /> .参数 指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 138, 0, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 取指针_逻辑型, 整数型, , 博乐助手整理   浪子优化<br /> .参数 数据, 逻辑型, 参考<br /> <br /> 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 到指针_逻辑型, 逻辑型, , 博乐助手整理   浪子优化<br /> .参数 指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (假)<br /> <br /> .子程序 取指针_小数型, 整数型, , 博乐助手整理   浪子优化<br /> .参数 欲取地址的数据, 小数型, 参考<br /> <br /> 返回 (lstrcpyn_指针_小数型 (欲取地址的数据, 欲取地址的数据, 0))<br /> <br /> .子程序 到指针_小数型, 小数型, , 博乐助手整理   浪子优化<br /> .参数 指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 取指针_整数型, 整数型, , 博乐助手整理   浪子优化<br /> .参数 欲取地址的数据, 整数型, 参考<br /> <br /> 返回 (lstrcpyn_指针_整数型 (欲取地址的数据, 欲取地址的数据, 0))<br /> <br /> .子程序 到指针_整数型, 整数型, , 博乐助手整理   浪子优化<br /> .参数 整数指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 取指针_短整数型, 整数型, , 博乐助手整理   浪子优化<br /> .参数 欲取地址的数据, 短整数型, 参考<br /> <br /> 返回 (lstrcpyn_指针_短整数型 (欲取地址的数据, 欲取地址的数据, 0))<br /> <br /> .子程序 到指针_短整数型, 短整数型, , 博乐助手整理   浪子优化<br /> .参数 指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 取指针_长整数型, 长整数型, , 博乐助手整理   浪子优化<br /> .参数 欲取地址的数据, 长整数型, 参考<br /> <br /> 返回 (lstrcpyn_指针_长整数型 (欲取地址的数据, 欲取地址的数据, 0))<br /> <br /> .子程序 到指针_长整数型, 长整数型, , 博乐助手整理   浪子优化<br /> .参数 指针, 整数型<br /> .局部变量 Ret, 长整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 255, 48, 143, 69, 248, 255, 112, 4, 143, 69, 252 })<br /> 返回 (Ret)<br /> <br /> .子程序 取指针_日期时间型, 整数型, , 博乐助手整理   浪子优化<br /> .参数 数据, 日期时间型, 参考<br /> <br /> 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 到指针_日期时间型, 日期时间型, , 博乐助手整理   浪子优化<br /> .参数 指针, 整数型<br /> .局部变量 结果, 日期时间型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 16, 137, 85, 248, 139, 64, 4, 137, 69, 252 })<br /> 返回 (结果)<br /> <br /> .子程序 取指针_双精度小数型, 整数型, , 博乐助手整理   浪子优化<br /> .参数 数据, 双精度小数型, 参考<br /> <br /> 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 到指针_双精度小数型, 双精度小数型, , 博乐助手整理   浪子优化<br /> .参数 指针, 整数型<br /> .局部变量 结果, 双精度小数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 16, 137, 85, 248, 139, 64, 4, 137, 69, 252 })<br /> 返回 (结果)

下面是调用测试

  

子程序名	返回值类型	公开	备 注
测试_指针			博乐助手整理   浪子优化

变量名	类 型	静态	数组	备 注
文本变量	文本型
文本指针	整数型
字节集变量	字节集
字节集指针	整数型
字节变量	字节型
字节指针	整数型
逻辑变量	逻辑型
逻辑指针	整数型
小数变量	小数型
小数指针	整数型
整数变量	整数型
整数指针	整数型
短整数变量	短整数型
短整数指针	整数型
长整数变量	长整数型
长整数指针	整数型
日期变量	日期时间型
日期指针	整数型
双精度变量	双精度小数型
双精度指针	整数型
还原文本	文本型
还原字节集	字节集

调试输出 (“========== 指针_递增 ==========”)
整数变量 ＝ 100
整数指针 ＝ 取指针_整数型 (整数变量)
调试输出 (“原值:”, 到指针_整数型 (整数指针))
指针_递增 (整数指针, 50)
调试输出 (“+50:”, 到指针_整数型 (整数指针))
调试输出 (“========== 指针_递减 ==========”)
指针_递减 (整数指针, 30)
调试输出 (“-30:”, 到指针_整数型 (整数指针))
调试输出 (“========== 指针_是否有效 ==========”)
调试输出 (“有效:”, 指针_是否有效 (整数指针))
调试输出 (“空:”, 指针_是否有效 (0))
调试输出 (“========== API_取空白字节集 ==========”)
还原字节集 ＝ API_取空白字节集 (8)
调试输出 (“长度:”, 取字节集长度 (还原字节集))
调试输出 (“========== 取指针_子程序 ==========”)
调试输出 (“取:”, 取指针_子程序 (&测试_指针))
调试输出 (“到:”, 到指针_子程序 (取指针_子程序 (&测试_指针)) ＝ &测试_指针)
调试输出 (“========== 文本型(汇编) ==========”)
文本变量 ＝ “Hello”
文本指针 ＝ 取指针_文本型 (文本变量)
调试输出 (“取:”, 文本指针)
还原文本 ＝ 到指针_文本型 (文本指针)
调试输出 (“到:”, 还原文本)
调试输出 (“========== 文本型(API) ==========”)
文本指针 ＝ 取指针_文本型1 (文本变量)
调试输出 (“取:”, 文本指针)
还原文本 ＝ 到指针_文本型1 (文本指针)
调试输出 (“到:”, 还原文本)
调试输出 (“========== 字节集 ==========”)
字节集变量 ＝ { 1, 2, 3, 255 }
字节集指针 ＝ 取指针_字节集 (字节集变量)
调试输出 (“取:”, 字节集指针)
还原字节集 ＝ 到指针_字节集 (字节集指针, 4)
调试输出 (“到:”, 还原字节集)
调试输出 (“========== 字节型 ==========”)
字节变量 ＝ 255
字节指针 ＝ 取指针_字节型 (字节变量)
调试输出 (“取:”, 字节指针)
调试输出 (“到:”, 到指针_字节型 (字节指针))
调试输出 (“========== 逻辑型 ==========”)
逻辑变量 ＝ 真
逻辑指针 ＝ 取指针_逻辑型 (逻辑变量)
调试输出 (“取:”, 逻辑指针)
调试输出 (“到:”, 到指针_逻辑型 (逻辑指针))
调试输出 (“========== 小数型 ==========”)
小数变量 ＝ 3.14
小数指针 ＝ 取指针_小数型 (小数变量)
调试输出 (“取:”, 小数指针)
调试输出 (“到:”, 到指针_小数型 (小数指针))
调试输出 (“========== 整数型 ==========”)
整数变量 ＝ 123456
整数指针 ＝ 取指针_整数型 (整数变量)
调试输出 (“取:”, 整数指针)
调试输出 (“到:”, 到指针_整数型 (整数指针))
调试输出 (“========== 短整数型 ==========”)
短整数变量 ＝ 32767
短整数指针 ＝ 取指针_短整数型 (短整数变量)
调试输出 (“取:”, 短整数指针)
调试输出 (“到:”, 到指针_短整数型 (短整数指针))
调试输出 (“========== 长整数型 ==========”)
长整数变量 ＝ 1234567890123
长整数指针 ＝ 取指针_长整数型 (长整数变量)
调试输出 (“取:”, 长整数指针)
调试输出 (“到:”, 到指针_长整数型 (长整数指针))
调试输出 (“========== 日期时间型 ==========”)
日期变量 ＝ [2026年7月16日15时30分]
日期指针 ＝ 取指针_日期时间型 (日期变量)
调试输出 (“取:”, 日期指针)
调试输出 (“到:”, 到指针_日期时间型 (日期指针))
调试输出 (“========== 双精度小数型 ==========”)
双精度变量 ＝ 3.14159265359
双精度指针 ＝ 取指针_双精度小数型 (双精度变量)
调试输出 (“取:”, 双精度指针)
调试输出 (“到:”, 到指针_双精度小数型 (双精度指针))
调试输出 (“========== 全部测试完成 ==========”)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试_指针, , , 博乐助手整理   浪子优化<br /> .局部变量 文本变量, 文本型<br /> .局部变量 文本指针, 整数型<br /> .局部变量 字节集变量, 字节集<br /> .局部变量 字节集指针, 整数型<br /> .局部变量 字节变量, 字节型<br /> .局部变量 字节指针, 整数型<br /> .局部变量 逻辑变量, 逻辑型<br /> .局部变量 逻辑指针, 整数型<br /> .局部变量 小数变量, 小数型<br /> .局部变量 小数指针, 整数型<br /> .局部变量 整数变量, 整数型<br /> .局部变量 整数指针, 整数型<br /> .局部变量 短整数变量, 短整数型<br /> .局部变量 短整数指针, 整数型<br /> .局部变量 长整数变量, 长整数型<br /> .局部变量 长整数指针, 整数型<br /> .局部变量 日期变量, 日期时间型<br /> .局部变量 日期指针, 整数型<br /> .局部变量 双精度变量, 双精度小数型<br /> .局部变量 双精度指针, 整数型<br /> .局部变量 还原文本, 文本型<br /> .局部变量 还原字节集, 字节集<br /> <br /> 调试输出 (“========== 指针_递增 ==========”)<br /> 整数变量 ＝ 100<br /> 整数指针 ＝ 取指针_整数型 (整数变量)<br /> 调试输出 (“原值:”, 到指针_整数型 (整数指针))<br /> 指针_递增 (整数指针, 50)<br /> 调试输出 (“+50:”, 到指针_整数型 (整数指针))<br /> <br /> 调试输出 (“========== 指针_递减 ==========”)<br /> 指针_递减 (整数指针, 30)<br /> 调试输出 (“-30:”, 到指针_整数型 (整数指针))<br /> <br /> 调试输出 (“========== 指针_是否有效 ==========”)<br /> 调试输出 (“有效:”, 指针_是否有效 (整数指针))<br /> 调试输出 (“空:”, 指针_是否有效 (0))<br /> <br /> 调试输出 (“========== API_取空白字节集 ==========”)<br /> 还原字节集 ＝ API_取空白字节集 (8)<br /> 调试输出 (“长度:”, 取字节集长度 (还原字节集))<br /> <br /> 调试输出 (“========== 取指针_子程序 ==========”)<br /> 调试输出 (“取:”, 取指针_子程序 (&测试_指针))<br /> 调试输出 (“到:”, 到指针_子程序 (取指针_子程序 (&测试_指针)) ＝ &测试_指针)<br /> <br /> 调试输出 (“========== 文本型(汇编) ==========”)<br /> 文本变量 ＝ “Hello”<br /> 文本指针 ＝ 取指针_文本型 (文本变量)<br /> 调试输出 (“取:”, 文本指针)<br /> 还原文本 ＝ 到指针_文本型 (文本指针)<br /> 调试输出 (“到:”, 还原文本)<br /> <br /> 调试输出 (“========== 文本型(API) ==========”)<br /> 文本指针 ＝ 取指针_文本型1 (文本变量)<br /> 调试输出 (“取:”, 文本指针)<br /> 还原文本 ＝ 到指针_文本型1 (文本指针)<br /> 调试输出 (“到:”, 还原文本)<br /> <br /> 调试输出 (“========== 字节集 ==========”)<br /> 字节集变量 ＝ { 1, 2, 3, 255 }<br /> 字节集指针 ＝ 取指针_字节集 (字节集变量)<br /> 调试输出 (“取:”, 字节集指针)<br /> 还原字节集 ＝ 到指针_字节集 (字节集指针, 4)<br /> 调试输出 (“到:”, 还原字节集)<br /> <br /> 调试输出 (“========== 字节型 ==========”)<br /> 字节变量 ＝ 255<br /> 字节指针 ＝ 取指针_字节型 (字节变量)<br /> 调试输出 (“取:”, 字节指针)<br /> 调试输出 (“到:”, 到指针_字节型 (字节指针))<br /> <br /> 调试输出 (“========== 逻辑型 ==========”)<br /> 逻辑变量 ＝ 真<br /> 逻辑指针 ＝ 取指针_逻辑型 (逻辑变量)<br /> 调试输出 (“取:”, 逻辑指针)<br /> 调试输出 (“到:”, 到指针_逻辑型 (逻辑指针))<br /> <br /> 调试输出 (“========== 小数型 ==========”)<br /> 小数变量 ＝ 3.14<br /> 小数指针 ＝ 取指针_小数型 (小数变量)<br /> 调试输出 (“取:”, 小数指针)<br /> 调试输出 (“到:”, 到指针_小数型 (小数指针))<br /> <br /> 调试输出 (“========== 整数型 ==========”)<br /> 整数变量 ＝ 123456<br /> 整数指针 ＝ 取指针_整数型 (整数变量)<br /> 调试输出 (“取:”, 整数指针)<br /> 调试输出 (“到:”, 到指针_整数型 (整数指针))<br /> <br /> 调试输出 (“========== 短整数型 ==========”)<br /> 短整数变量 ＝ 32767<br /> 短整数指针 ＝ 取指针_短整数型 (短整数变量)<br /> 调试输出 (“取:”, 短整数指针)<br /> 调试输出 (“到:”, 到指针_短整数型 (短整数指针))<br /> <br /> 调试输出 (“========== 长整数型 ==========”)<br /> 长整数变量 ＝ 1234567890123<br /> 长整数指针 ＝ 取指针_长整数型 (长整数变量)<br /> 调试输出 (“取:”, 长整数指针)<br /> 调试输出 (“到:”, 到指针_长整数型 (长整数指针))<br /> <br /> 调试输出 (“========== 日期时间型 ==========”)<br /> 日期变量 ＝ [2026年7月16日15时30分]<br /> 日期指针 ＝ 取指针_日期时间型 (日期变量)<br /> 调试输出 (“取:”, 日期指针)<br /> 调试输出 (“到:”, 到指针_日期时间型 (日期指针))<br /> <br /> 调试输出 (“========== 双精度小数型 ==========”)<br /> 双精度变量 ＝ 3.14159265359<br /> 双精度指针 ＝ 取指针_双精度小数型 (双精度变量)<br /> 调试输出 (“取:”, 双精度指针)<br /> 调试输出 (“到:”, 到指针_双精度小数型 (双精度指针))<br /> <br /> 调试输出 (“========== 全部测试完成 ==========”)

游客，如果您要查看本帖隐藏内容请回复

莫小乐

代码都是我项目里的边角料！

---

1. 这是教程，不是产品发布
发源码是为了让人看懂原理，不是喂饭。模块一行调用，学不到东西。

2. 源码更透明
源码白纸黑字，有没有后门、会不会崩，一眼看清，心里有底。

3. 多一种选择
模块有模块的用途，这只是多给一个选择。有人喜欢用模块，有人喜欢翻源码，各取所需。

4. 依赖越少，项目越稳
引一个模块，它又拖一堆依赖，最后挂十几个，崩了都不知道谁的锅。源码直接嵌入，零依赖。

5. 你觉得没用，不代表别人没用
写给愿意学的人看。只想要成品的，跳过就完了。

---

代码是否与其他模块相同？
有可能，声明的dll、用的如果真、如果，确实一样。等我有空给你写一个：@#￥%……&*（）

为什么单帖？
我自己整合记录，顺便发布。

awuming

助手 助手 助手

夏亿

感谢分享

飞鱼软件

感谢分享 赞一个 ！

小窗润轻风

超好，辛苦了辛苦了

caoljie

什么情况。我看看

ljx111

感谢分享

ker519

感谢分享

mood100

感谢分享嗯

wh1234567

感谢分享