如果要优化性能，还是直接传引用然后改比较好，可以纯汇编实现：
.版本 2
.子程序 汇编__字节集_XOR, , , [爱飞的猫 @ 52pojie] 使用汇编对两个字节集进行 XOR 处理
.参数 内容, 字节集, 参考, [ebp + 0x08] 直接更改该参数传参值
.参数 密钥, 字节集, , [ebp + 0x0C] 若短于内容，则重复处理密钥
置入代码 ({ 86, 87, 83, 139, 117, 8, 139, 54, 131, 198, 8, 139, 126, 252, 1, 247, 57, 254, 116, 35, 139, 77, 12, 139, 9, 131, 193, 8, 139, 81, 252, 1, 202, 137, 203, 57, 209, 116, 16, 138, 1, 65, 48, 6, 70, 57, 209, 117, 2, 137, 217, 57, 254, 117, 240, 91, 95, 94 })
汇编代码如下，使用 FASM 编译即可。
use32 ; 爱飞的猫制作
; [易语言] 置入代码 - 汇编__字节集_XOR
push esi
push edi
push ebx
p_input equ esi
p_input_end equ edi
p_key equ ecx
p_key_end equ edx
p_key_start equ ebx
temp equ al
mov p_input, dword[ebp + 0x08]
mov p_input, dword[p_input]
add p_input, 0x08
mov p_input_end, [p_input - 0x04]
add p_input_end, p_input
cmp p_input, p_input_end
je __end
mov p_key, dword[ebp + 0x0C]
mov p_key, dword[p_key]
add p_key, 0x08
mov p_key_end, [p_key - 0x04]
add p_key_end, p_key
mov p_key_start, p_key
cmp p_key, p_key_end
je __end
__loop:
mov temp, byte[p_key]
inc p_key
xor byte[p_input], temp
inc p_input
cmp p_key, p_key_end
jne @f
mov p_key, p_key_start
@@:
cmp p_input, p_input_end
jne __loop
__end:
pop ebx
pop edi
pop esi
测试代码：
.版本 2
.子程序 _启动子程序, 整数型, , [爱飞的猫] 制作
.局部变量 数据, 字节集
.局部变量 密钥, 字节集
数据 ＝ 到字节集 (“A0 测试内容”)
密钥 ＝ { 255, 0, 0 }
密钥 [2] ＝ 二进制 (“01010101”)
密钥 [3] ＝ 二进制 (“10101010”)
标准输出 (#标准输出设备, “ 原始数据 (十六进制): ”)
标准输出 (#标准输出设备, 汇编_字节集到十六进制 (数据, 真))
标准输出 (#标准输出设备, #换行符)
标准输出 (#标准输出设备, “ 密钥 (十六进制): ”)
标准输出 (#标准输出设备, 汇编_字节集到十六进制 (密钥, 真))
标准输出 (#标准输出设备, #换行符)
汇编__字节集_XOR (数据, 密钥) ' 第一次处理
标准输出 (#标准输出设备, “第一次处理 (十六进制): ”)
标准输出 (#标准输出设备, 汇编_字节集到十六进制 (数据, 真))
标准输出 (#标准输出设备, #换行符)
汇编__字节集_XOR (数据, 密钥) ' 第二次处理
标准输出 (#标准输出设备, “第二次处理 (十六进制): ”)
标准输出 (#标准输出设备, 汇编_字节集到十六进制 (数据, 真))
标准输出 (#标准输出设备, #换行符)
标准输出 (#标准输出设备, “第二次处理 (字 符 串): ”)
标准输出 (#标准输出设备, 到文本 (数据))
标准输出 (#标准输出设备, #换行符)
标准输入 (假)
返回 (0) ' 可以根据您的需要返回任意数值
输出：
原始数据 (十六进制): 41 30 20 B2 E2 CA D4 C4 DA C8 DD
密钥 (十六进制): FF 55 AA
第一次处理 (十六进制): BE 65 8A 4D B7 60 2B 91 70 37 88
第二次处理 (十六进制): 41 30 20 B2 E2 CA D4 C4 DA C8 DD
第二次处理 (字 符 串): A0 测试内容
来跑个测速，测速代码：
.版本 2
.子程序 测速
.局部变量 数据, 字节集
.局部变量 数据副本, 字节集
.局部变量 密钥, 字节集
.局部变量 开始时间, 整数型
.局部变量 耗时毫秒, 整数型
.局部变量 耗时记录, 双精度小数型, , "1"
.局部变量 次数, 整数型
.局部变量 耗时最高, 整数型
.局部变量 耗时最低, 整数型
.局部变量 累计耗时, 整数型
.局部变量 平均耗时, 整数型
.局部变量 切尾均值, 双精度小数型
数据副本 ＝ 到字节集 (“A1 测试内容”)
密钥 ＝ { 255, 0, 0, 0 }
密钥 [2] ＝ 二进制 (“01010101”)
密钥 [3] ＝ 二进制 (“10101010”)
' #采样次数 ＝ 10
重定义数组 (耗时记录, 假, #采样次数)
.计次循环首 (#采样次数, 次数) ' 取样 10 次
开始时间 ＝ 取启动时间 ()
.计次循环首 (100 × 10000, )
数据 ＝ 数据副本
汇编__字节集_XOR (数据, 密钥)
.计次循环尾 ()
耗时毫秒 ＝ 取启动时间 () － 开始时间
累计耗时 ＝ 累计耗时 ＋ 耗时毫秒
耗时记录 [次数] ＝ 耗时毫秒
printf__siis_v (“百万次执行耗时 [%02d] -- %dms%s”, 次数, 耗时毫秒, #换行符)
.计次循环尾 ()
数组排序 (耗时记录, 真)
' 切尾均值: 去掉两个最低和最高的成绩，再次计算
平均耗时 ＝ 累计耗时 ÷ #采样次数
切尾均值 ＝ (累计耗时 － 耗时记录 [1] － 耗时记录 [2] － 耗时记录 [#采样次数 － 0] － 耗时记录 [#采样次数 － 1]) ÷ (#采样次数 － 4)
printf__dds_v (“ 平均耗时: %.2fms (切尾均值=%.2fms)%s”, 平均耗时, 切尾均值, #换行符)
printf__is_v (“ 最佳成绩: %dms%s”, 耗时记录 [1], #换行符)
printf__is_v (“ 最差成绩: %dms%s”, 耗时记录 [#采样次数 ＋ 0], #换行符)
.DLL命令 printf__siis_v, , "msvcrt.dll", "@printf"
.参数 fmt, 文本型
.参数 i1, 整数型
.参数 i2, 整数型
.参数 s1, 文本型
.DLL命令 printf__dds_v, , "msvcrt.dll", "@printf"
.参数 fmt, 文本型
.参数 d1, 双精度小数型
.参数 d2, 双精度小数型
.参数 s1, 文本型
.DLL命令 printf__is_v, , "msvcrt.dll", "@printf"
.参数 fmt, 文本型
.参数 i1, 整数型
.参数 s1, 文本型
.常量 采样次数, "10"
测速结果（静态编译）：
百万次执行耗时 [01] -- 62ms
百万次执行耗时 [02] -- 78ms
百万次执行耗时 [03] -- 63ms
百万次执行耗时 [04] -- 63ms
百万次执行耗时 [05] -- 62ms
百万次执行耗时 [06] -- 63ms
百万次执行耗时 [07] -- 78ms
百万次执行耗时 [08] -- 63ms
百万次执行耗时 [09] -- 62ms
百万次执行耗时 [10] -- 63ms
平均耗时: 65.00ms (切尾均值=62.83ms)
最佳成绩: 62ms
最差成绩: 78ms
然后测测你的（静态编译）：
百万次执行耗时 [01] -- 156ms
百万次执行耗时 [02] -- 141ms
百万次执行耗时 [03] -- 141ms
百万次执行耗时 [04] -- 156ms
百万次执行耗时 [05] -- 140ms
百万次执行耗时 [06] -- 141ms
百万次执行耗时 [07] -- 141ms
百万次执行耗时 [08] -- 156ms
百万次执行耗时 [09] -- 141ms
百万次执行耗时 [10] -- 140ms
平均耗时: 145.00ms (切尾均值=143.50ms)
最佳成绩: 140ms
最差成绩: 156ms
感觉应该是 参与异或的字节集 ＝ 取重复字节集 (参与异或的字节集长度, 参与异或的字节集) 这一行对性能的影响最大。
易语言代码（附赠一个 汇编_字节集到十六进制 的实现）：
汇编_字节集处理.7z
(2.7 KB, 下载次数: 3)
发表于 2023-8-16 17:53
发表于 2023-8-17 07:15
|
发表于 2023-8-17 08:49
