基础模块-字节集示例11-20

qq1073176068 · 发表于 2025-9-28 08:30:00

本帖最后由 qq1073176068 于 2025-9-29 20:25 编辑

11.添加正整形连续

// 示例1：添加多个正整型到末尾（默认位置-1）
// 炫语言：定义字节集，用于存储ANSI文本与连续正整型的组合数据
字节集正整型连续集1
// 炫语言：添加ANSI-GBK文本“设备ID：”（“设”=0xC9E8、“备”=0xB1B8、“I”=0x49、“D”=0x44、“：”=0xA3BA，共8字节，不补终止符）
正整型连续集1.添加文本A(A"设备ID：", 假)
// 炫语言：在字节集末尾添加3个连续正整型{1000,2000,3000}（每个正整型占4字节，小端存储）
正整型连续集1.添加正整型连续({1000, 2000, 3000})
// 炫语言：调试输出字节集构成与总大小
调试输出("字节集：“设备ID：”+1000+2000+3000，总大小" + 到文本(正整型连续集1.取大小()) + "字节")
// 炫语言：调试输出字节集十六进制内容
调试输出十六进制((常量字符型A*)正整型连续集1.取地址(), 正整型连续集1.取大小())
// 输出结果：
// 字节集：“设备ID：”+1000+2000+3000，总大小20字节
// 字节集十六进制内容：C9 E8 B1 B8 49 44 A3 BA E8 03 00 00 D0 07 00 00 B8 0B 00 00
// 字节解析：C9 E8=“设”、B1 B8=“备”、49=“I”、44=“D”、A3 BA=“：”（文本8字节）；E8 03 00 00=正整型1000、D0 07 00 00=正整型2000、B8 0B 00 00=正整型3000（连续正整型12字节），总大小=8+12=20字节

复制代码

// 示例2：添加多个正整型到指定位置（位置3）
// 炫语言：定义字节集，用于存储ANSI文本与指定位置插入连续正整型的组合数据
字节集正整型连续集2
// 炫语言：添加ANSI-ASCII文本“123”（“1”=0x31、“2”=0x32、“3”=0x33，共3字节，不补终止符）
正整型连续集2.添加文本A(A"123", 假)
// 炫语言：在位置3（“123”之后）添加2个连续正整型{45678, 98765}（每个正整型占4字节，小端存储）
正整型连续集2.添加正整型连续({45678, 98765}, 3)
// 炫语言：调试输出字节集构成与总大小
调试输出("字节集：“123”后插45678+98765，总大小" + 到文本(正整型连续集2.取大小()) + "字节")
// 炫语言：调试输出字节集十六进制内容
调试输出十六进制((常量字符型A*)正整型连续集2.取地址(), 正整型连续集2.取大小())
// 输出结果：
// 字节集：“123”后插45678+98765，总大小11字节
// 字节集十六进制内容：31 32 33 6E B2 00 00 CD 81 01 00
// 字节解析：31=“1”、32=“2”、33=“3”（ANSI文本3字节）；6E B2 00 00=正整型45678、CD 81 01 00=正整型98765（连续正整型8字节，插入于“123”后），总大小=3+8=11字节

复制代码

--
12.添加长整形

// 示例1：添加长整型到末尾（默认位置-1，匹配实际输出）
// 炫语言：定义字节集，用于存储ANSI-GBK文本与64位长整型的组合数据
字节集长整型集1
// 炫语言：添加ANSI-GBK文本“序号：”（“序”=0xD0F2、“号”=0xBAC5、“：”=0xA3BA，3个字符共6字节，不补终止符）
长整型集1.添加文本A(A"序号：", 假)
// 炫语言：在字节集末尾添加64位长整型1234567890123（占8字节，小端存储：对应十六进制CB 04 FB 71 1F 01 00 00）
长整型集1.添加长整型(1234567890123)
// 炫语言：调试输出字节集构成与总大小
调试输出("字节集：“序号：”+1234567890123，总大小" + 到文本(长整型集1.取大小()) + "字节")
// 炫语言：调试输出字节集十六进制内容
调试输出十六进制((常量字符型A*)长整型集1.取地址(), 长整型集1.取大小())
// 输出结果：
// 字节集：“序号：”+1234567890123，总大小14字节
// 字节集十六进制内容：D0 F2 BA C5 A3 BA CB 04 FB 71 1F 01 00 00
// 字节解析：D0 F2=“序”、BA C5=“号”、A3 BA=“：”（ANSI-GBK文本6字节）；CB 04 FB 71 1F 01 00 00=64位长整型1234567890123（小端存储8字节），总大小=6+8=14字节

复制代码

// 示例2：添加长整型到指定位置（位置4，匹配实际输出）
// 炫语言：定义字节集，用于存储ANSI文本与指定位置插入64位长整型的组合数据
字节集长整型集2
// 炫语言：添加ANSI-ASCII文本“Code”（“C”=0x43、“o”=0x6F、“d”=0x64、“e”=0x65，4个字符共4字节，不补终止符）
长整型集2.添加文本A(A"Code", 假)
// 炫语言：在位置4（“Code”之后）添加64位长整型98765432109876（占8字节，小端存储：对应十六进制34 3B 7F 9E D3 59 00 00）
长整型集2.添加长整型(98765432109876, 4)
// 炫语言：调试输出字节集构成与总大小
调试输出("字节集：“Code”后插98765432109876，总大小" + 到文本(长整型集2.取大小()) + "字节")
// 炫语言：调试输出字节集十六进制内容
调试输出十六进制((常量字符型A*)长整型集2.取地址(), 长整型集2.取大小())
// 输出结果：
// 字节集：“Code”后插98765432109876，总大小12字节
// 字节集十六进制内容：43 6F 64 65 34 3B 7F 9E D3 59 00 00
// 字节解析：43=“C”、6F=“o”、64=“d”、65=“e”（ANSI文本4字节）；34 3B 7F 9E D3 59 00 00=64位长整型98765432109876（小端存储8字节，插入于“Code”后），总大小=4+8=12字节

复制代码

--
13.添加长整形连续

// 示例1：添加多个长整型到末尾（默认位置-1，匹配实际输出）
// 炫语言：定义字节集，用于存储ANSI-GBK文本与连续64位长整型的组合数据
字节集长整型连续集1
// 炫语言：添加ANSI-GBK文本“日志ID：”（“日”=0xC8D5、“志”=0xD6BE、“I”=0x49、“D”=0x44、“：”=0xA3BA，共8字节，不补终止符）
长整型连续集1.添加文本A(A"日志ID：", 假)
// 炫语言：在字节集末尾添加2个连续64位长整型{1234567890123, 4567890123456}（每个长整型占8字节，均为小端存储）
长整型连续集1.添加长整型连续({1234567890123, 4567890123456})
// 炫语言：调试输出字节集构成与总大小
调试输出("字节集：“日志ID：”+1234567890123+4567890123456，总大小" + 到文本(长整型连续集1.取大小()) + "字节")
// 炫语言：调试输出字节集十六进制内容
调试输出十六进制((常量字符型A*)长整型连续集1.取地址(), 长整型连续集1.取大小())
// 输出结果：
// 字节集：“日志ID：”+1234567890123+4567890123456，总大小24字节
// 字节集十六进制内容：C8 D5 D6 BE 49 44 A3 BA CB 04 FB 71 1F 01 00 00 C0 DA 77 8B 27 04 00 00
// 字节解析：C8 D5=“日”、D6 BE=“志”、49=“I”、44=“D”、A3 BA=“：”（ANSI-GBK文本8字节）；CB 04 FB 71 1F 01 00 00=长整型1234567890123、C0 DA 77 8B 27 04 00 00=长整型4567890123456（连续长整型16字节），总大小=8+16=24字节

复制代码

// 示例2：添加多个长整型到指定位置（位置4，匹配实际输出）
// 炫语言：定义字节集，用于存储ANSI文本与指定位置插入连续64位长整型的组合数据
字节集长整型连续集2
// 炫语言：添加ANSI-ASCII文本“Data”（“D”=0x44、“a”=0x61、“t”=0x74、“a”=0x61，4个字符共4字节，不补终止符）
长整型连续集2.添加文本A(A"Data", 假)
// 炫语言：在位置4（“Data”之后）添加2个连续64位长整型{98765432109876, 76543210987654}（每个长整型占8字节，按指定小端存储）
长整型连续集2.添加长整型连续({98765432109876, 76543210987654}, 4)
// 炫语言：调试输出字节集构成与总大小
调试输出("字节集：“Data”后插98765432109876+76543210987654，总大小" + 到文本(长整型连续集2.取大小()) + "字节")
// 炫语言：调试输出字节集十六进制内容
调试输出十六进制((常量字符型A*)长整型连续集2.取地址(), 长整型连续集2.取大小())
// 输出结果：
// 字节集：“Data”后插98765432109876+76543210987654，总大小20字节
// 字节集十六进制内容：44 61 74 61 34 3B 7F 9E D3 59 00 00 86 A0 E6 9A 9D 45 00 00
// 字节解析：44=“D”、61=“a”、74=“t”、61=“a”（ANSI文本4字节）；34 3B 7F 9E D3 59 00 00=长整型98765432109876、86 A0 E6 9A 9D 45 00 00=长整型76543210987654（连续长整型16字节，插入于“Data”后），总大小=4+16=20字节

复制代码

--
14.添加正长整形

// 示例1：添加正长整型到末尾（默认位置-1，匹配指定输出）
// 炫语言：定义字节集，用于存储ANSI-GBK文本与无符号64位正长整型的组合数据
字节集正长整型集1
// 炫语言：添加ANSI-GBK文本“设备码：”（“设”=0xC9E8、“备”=0xB1B8、“码”=0xC2EB、“：”=0xA3BA，共8字节，不补终止符）
正长整型集1.添加文本A(A"设备码：", 假)
// 炫语言：在字节集末尾添加无符号64位正长整型1234567890123456（占8字节，匹配指定小端存储格式）
正长整型集1.添加正长整型(1234567890123456)
// 炫语言：调试输出字节集构成与总大小
调试输出("字节集：“设备码：”+1234567890123456，总大小" + 到文本(正长整型集1.取大小()) + "字节")
// 炫语言：调试输出字节集十六进制内容
调试输出十六进制((常量字符型A*)正长整型集1.取地址(), 正长整型集1.取大小())
// 输出结果：
// 字节集：“设备码：”+1234567890123456，总大小16字节
// 字节集十六进制内容：C9 E8 B1 B8 C2 EB A3 BA C0 BA 8A 3C D5 62 04 00
// 字节解析：C9 E8=“设”、B1 B8=“备”、C2 EB=“码”、A3 BA=“：”（ANSI-GBK文本8字节）；C0 BA 8A 3C D5 62 04 00=无符号64位正长整型1234567890123456（小端存储8字节），总大小=8+8=16字节

复制代码

// 示例2：添加正长整型到指定位置（位置3，匹配指定输出）
// 炫语言：定义字节集，用于存储ANSI文本与指定位置插入无符号64位正长整型的组合数据
字节集正长整型集2
// 炫语言：添加ANSI-ASCII文本“Key”（“K”=0x4B、“e”=0x65、“y”=0x79，3个字符共3字节，不补终止符）
正长整型集2.添加文本A(A"Key", 假)
// 炫语言：在位置3（“Key”之后）添加无符号64位正长整型9876543210987654（占8字节，匹配指定存储格式）
正长整型集2.添加正长整型(9876543210987654, 3)
// 炫语言：调试输出字节集构成与总大小
调试输出("字节集：“Key”后插9876543210987654，总大小" + 到文本(正长整型集2.取大小()) + "字节")
// 炫语言：调试输出字节集十六进制内容
调试输出十六进制((常量字符型A*)正长整型集2.取地址(), 正长整型集2.取大小())
// 输出结果：
// 字节集：“Key”后插9876543210987654，总大小11字节
// 字节集十六进制内容：4B 65 79 86 20 B3 E9 A9 16 23 00
// 字节解析：4B=“K”、65=“e”、79=“y”（ANSI文本3字节）；86 20 B3 E9 A9 16 23 00=无符号64位正长整型9876543210987654（指定存储8字节，插入于“Key”后），总大小=3+8=11字节

复制代码

--
15.添加正长整形连续

// 炫语言：定义字节集，用于存储带ANSI前缀的多设备正长整型ID数据
字节集设备ID集
// 炫语言：添加ANSI-GBK编码的文本前缀“设备ID：”（“设”=0xC9E8、“备”=0xB1B8、“I”=0x49、“D”=0x44、“：”=0xA3BA，共8字节，不补终止符）
设备ID集.添加文本A(A"设备ID：", 假)
// 炫语言：在字节集末尾添加3个连续无符号64位正长整型ID（每个占8字节，按小端存储规则，匹配指定十六进制输出）
设备ID集.添加正长整型连续({18446744073709551355, 393216, 150323850560004})
// 炫语言：调试输出字节集总大小（文本8字节 + 3个正长整型24字节 = 32字节）
调试输出("设备ID集总大小：" + 到文本(设备ID集.取大小()) + "字节")
// 炫语言：调试输出字节集完整十六进制内容
调试输出("设备ID集十六进制内容：")
调试输出十六进制((常量字符型A*)设备ID集.取地址(), 设备ID集.取大小())
// 输出结果：
// 设备ID集总大小：32字节
// 设备ID集十六进制内容：C9 E8 B1 B8 49 44 A3 BA FB FE FF FF FF FF FF FF 00 00 06 00 00 00 00 00 04 C2 B6 FF B7 88 00 00
// 字节解析：C9 E8=“设”、B1 B8=“备”、49=“I”、44=“D”、A3 BA=“：”（文本8字节）；FB FE FF FF FF FF FF FF=正长整型18446744073709551355、00 00 06 00 00 00 00 00=正长整型393216、04 C2 B6 FF B7 88 00 00=正长整型150323850560004（3个正长整型共24字节），总大小=8+24=32字节

复制代码

// 炫语言：定义字节集，用于存储带ANSI前缀且指定位置插入正长整型订单号的数据
字节集订单号集
// 炫语言：添加ANSI-GBK编码的文本前缀“订单号：”（“订”=0xB6A9、“单”=0xB5A5、“号”=0xBAC5、“：”=0xA3BA，共8字节，不补终止符）
订单号集.添加文本A(A"订单号：", 假)
// 炫语言：在位置8（文本“订单号：”之后）插入2个连续无符号64位正长整型订单号（每个占8字节，按小端存储，匹配指定输出）
订单号集.添加正长整型连续({9876543210987654, 12345678901234}, 8)
// 炫语言：调试输出字节集总大小（文本8字节 + 2个正长整型16字节 = 24字节）
调试输出("订单号集总大小：" + 到文本(订单号集.取大小()) + "字节")
// 炫语言：调试输出字节集完整十六进制内容
调试输出("订单号集十六进制内容：")
调试输出十六进制((常量字符型A*)订单号集.取地址(), 订单号集.取大小())
// 输出结果：
// 订单号集总大小：24字节
// 订单号集十六进制内容：B6 A9 B5 A5 BA C5 A3 BA 86 20 B3 E9 A9 16 23 00 F2 2F CE 73 3A 0B 00 00
// 字节解析：B6 A9=“订”、B5 A5=“单”、BA C5=“号”、A3 BA=“：”（文本8字节）；86 20 B3 E9 A9 16 23 00=正长整型9876543210987654、F2 2F CE 73 3A 0B 00 00=正长整型12345678901234（2个正长整型共16字节），总大小=8+16=24字节

复制代码

--
16.添加短整形

// 示例1：添加短整型到末尾（默认位置-1，匹配实际输出）
// 炫语言：定义字节集，存储ANSI-GBK文本与末尾追加的短整型数据
字节集短整型集1
// 炫语言：添加ANSI-GBK文本“数值：”（“数”=0xCAFD、“值”=0xD6B5、“：”=0xA3BA，每个字符2字节，共6字节，不补终止符）
短整型集1.添加文本A(A"数值：", 假)
// 炫语言：调用addShort()，默认插入末尾，添加短整型数据32767（2字节，小端存储：FF 7F）
短整型集1.添加短整型(32767)
// 炫语言：输出字节集总大小（文本6字节+短整型2字节=8字节）
调试输出("短整型集1总大小：" + 到文本(短整型集1.取大小()) + "字节")
// 炫语言：输出十六进制内容，验证存储结果
调试输出十六进制((常量字符型A*)短整型集1.取地址(), 短整型集1.取大小())
// 输出结果：
// 短整型集1总大小：8字节
// 短整型集1十六进制内容：CA FD D6 B5 A3 BA FF 7F
// 字节解析：CA FD=“数”、D6 B5=“值”、A3 BA=“：”（文本6字节）；FF 7F=短整型32767（小端存储2字节），总大小=6+2=8字节

复制代码

// 示例2：添加短整型到指定位置（位置3，匹配实际输出）
// 炫语言：定义字节集，存储ANSI-ASCII文本与指定位置插入的短整型数据
字节集短整型集2
// 炫语言：添加ANSI-ASCII文本“123”（“1”=0x31、“2”=0x32、“3”=0x33，每个字符1字节，共3字节，不补终止符）
短整型集2.添加文本A(A"123", 假)
// 炫语言：调用addShort()，指定插入位置3（“123”之后），添加短整型数据1234（2字节，小端存储：D2 04）
短整型集2.添加短整型(1234, 3)
// 炫语言：输出字节集总大小（文本3字节+短整型2字节=5字节）
调试输出("短整型集2总大小：" + 到文本(短整型集2.取大小()) + "字节")
// 炫语言：输出十六进制内容，验证存储结果
调试输出十六进制((常量字符型A*)短整型集2.取地址(), 短整型集2.取大小())
// 输出结果：
// 短整型集2总大小：5字节
// 短整型集2十六进制内容：31 32 33 D2 04
// 字节解析：31=“1”、32=“2”、33=“3”（文本3字节）；D2 04=短整型1234（小端存储2字节，插入于“123”后），总大小=3+2=5字节

复制代码

--
17.添加短整形连续

// 示例1：添加多个短整型到末尾（默认位置-1，匹配实际输出）
// 炫语言：定义字节集，存储ANSI-GBK文本与末尾追加的连续短整型数据
字节集短整型连续集1
// 炫语言：添加ANSI-GBK文本“批量值：”（“批”=0xC5FA、“量”=0xC1BF、“值”=0xD6B5、“：”=0xA3BA，每个字符2字节，共8字节，不补终止符）
短整型连续集1.添加文本A(A"批量值：", 假)
// 炫语言：调用addShorts()，默认插入末尾，添加3个连续短整型{123, 456, 789}（每个2字节，小端存储：7B 00、C8 01、15 03）
短整型连续集1.添加短整型连续({123, 456, 789})
// 炫语言：输出字节集总大小（文本8字节+3个短整型6字节=14字节）
调试输出("短整型连续集1总大小：" + 到文本(短整型连续集1.取大小()) + "字节")
// 炫语言：输出十六进制内容，验证存储结果
调试输出十六进制((常量字符型A*)短整型连续集1.取地址(), 短整型连续集1.取大小())
// 输出结果：
// 短整型连续集1总大小：14字节
// 短整型连续集1十六进制内容：C5 FA C1 BF D6 B5 A3 BA 7B 00 C8 01 15 03
// 字节解析：C5 FA=“批”、C1 BF=“量”、D6 B5=“值”、A3 BA=“：”（文本8字节）；7B 00=短整型123、C8 01=短整型456、15 03=短整型789（连续短整型6字节），总大小=8+6=14字节

复制代码

// 示例2：添加多个短整型到指定位置（位置4，匹配实际输出）
// 炫语言：定义字节集，存储ANSI-ASCII文本与指定位置插入的连续短整型数据
字节集短整型连续集2
// 炫语言：添加ANSI-ASCII文本“Code”（“C”=0x43、“o”=0x6F、“d”=0x64、“e”=0x65，每个字符1字节，共4字节，不补终止符）
短整型连续集2.添加文本A(A"Code", 假)
// 炫语言：调用addShorts()，指定插入位置4（“Code”之后），添加2个连续短整型{999, 1000}（每个2字节，小端存储：E7 03、E8 03）
短整型连续集2.添加短整型连续({999, 1000}, 4)
// 炫语言：输出字节集总大小（文本4字节+2个短整型4字节=8字节）
调试输出("短整型连续集2总大小：" + 到文本(短整型连续集2.取大小()) + "字节")
// 炫语言：输出十六进制内容，验证存储结果
调试输出十六进制((常量字符型A*)短整型连续集2.取地址(), 短整型连续集2.取大小())
// 输出结果：
// 短整型连续集2总大小：8字节
// 短整型连续集2十六进制内容：43 6F 64 65 E7 03 E8 03
// 字节解析：43=“C”、6F=“o”、64=“d”、65=“e”（文本4字节）；E7 03=短整型999、E8 03=短整型1000（连续短整型4字节，插入于“Code”后），总大小=4+4=8字节

复制代码

--
18.添加正短整形

// 示例1：添加正短整型到末尾（默认位置-1，匹配实际输出）
// 炫语言：定义字节集，存储ANSI-GBK文本与末尾追加的无符号短整型数据
字节集正短整型集1
// 炫语言：添加ANSI-GBK文本“正短值：”（“正”=0xD5FD、“短”=0xB6CC、“值”=0xD6B5、“：”=0xA3BA，每个字符2字节，共8字节，不补终止符）
正短整型集1.添加文本A(A"正短值：", 假)
// 炫语言：调用addUShort()，默认插入末尾，添加正短整型（无符号短整型）65535（2字节，小端存储：FF FF）
正短整型集1.添加正短整型(65535)
// 炫语言：输出字节集总大小（文本8字节+正短整型2字节=10字节）
调试输出("正短整型集1总大小：" + 到文本(正短整型集1.取大小()) + "字节")
// 炫语言：输出十六进制内容，验证存储结果
调试输出十六进制((常量字符型A*)正短整型集1.取地址(), 正短整型集1.取大小())
// 输出结果：
// 正短整型集1总大小：10字节
// 正短整型集1十六进制内容：D5 FD B6 CC D6 B5 A3 BA FF FF
// 字节解析：D5 FD=“正”、B6 CC=“短”、D6 B5=“值”、A3 BA=“：”（文本8字节）；FF FF=正短整型65535（无符号短整型，小端存储2字节），总大小=8+2=10字节

复制代码

// 示例2：添加正短整型到指定位置（位置3，匹配实际输出）
// 炫语言：定义字节集，存储ANSI-ASCII文本与指定位置插入的无符号短整型数据
字节集正短整型集2
// 炫语言：添加ANSI-ASCII文本“Num”（“N”=0x4E、“u”=0x75、“m”=0x6D，每个字符1字节，共3字节，不补终止符）
正短整型集2.添加文本A(A"Num", 假)
// 炫语言：调用addUShort()，指定插入位置3（“Num”之后），添加正短整型（无符号短整型）5678（2字节，小端存储：AE 16）
正短整型集2.添加正短整型(5678, 3)
// 炫语言：输出字节集总大小（文本3字节+正短整型2字节=5字节）
调试输出("正短整型集2总大小：" + 到文本(正短整型集2.取大小()) + "字节")
// 炫语言：输出十六进制内容，验证存储结果
调试输出十六进制((常量字符型A*)正短整型集2.取地址(), 正短整型集2.取大小())
// 输出结果：
// 正短整型集2总大小：5字节
// 正短整型集2十六进制内容：4E 75 6D AE 16
// 字节解析：4E=“N”、75=“u”、6D=“m”（文本3字节）；AE 16=正短整型5678（无符号短整型，小端存储2字节，插入于“Num”后），总大小=3+2=5字节

复制代码

--
19.添加正短整形连续

// 示例1：添加多个正短整型到末尾（默认位置-1，匹配实际输出）
// 炫语言：定义字节集，存储ANSI-GBK文本与末尾追加的连续无符号短整型数据
字节集正短整型连续集1
// 炫语言：添加ANSI-GBK文本“批量正短值：”（“批”=0xC5FA、“量”=0xC1BF、“正”=0xD5FD、“短”=0xB6CC、“值”=0xD6B5、“：”=0xA3BA，每个字符2字节，共12字节，不补终止符）
正短整型连续集1.添加文本A(A"批量正短值：", 假)
// 炫语言：调用addUShorts()，默认插入末尾，添加3个连续正短整型（无符号短整型），匹配最终输出的十六进制存储格式
正短整型连续集1.添加正短整型连续({1234, 5678, 8754})
// 炫语言：输出字节集总大小（文本12字节 + 3个正短整型6字节 = 18字节）
调试输出("正短整型连续集1总大小：" + 到文本(正短整型连续集1.取大小()) + "字节")
// 炫语言：输出十六进制内容，验证存储结果
调试输出十六进制((常量字符型A*)正短整型连续集1.取地址(), 正短整型连续集1.取大小())
// 输出结果：
// 正短整型连续集1总大小：18字节
// 正短整型连续集1十六进制内容：C5 FA C1 BF D5 FD B6 CC D6 B5 A3 BA D2 04 2E 16 32 22
// 字节解析：C5 FA=“批”、C1 BF=“量”、D5 FD=“正”、B6 CC=“短”、D6 B5=“值”、A3 BA=“：”（ANSI-GBK文本共12字节）；D2 04=第1个正短整型（1234）、2E 16=第2个正短整型（5678）、32 22=第3个正短整型（匹配最终十六进制存储的对应值）（每个正短整型2字节，共6字节），总大小=12+6=18字节

复制代码

// 示例2：添加多个正短整型到指定位置（位置4，匹配实际输出）
// 炫语言：定义字节集，存储ANSI-ASCII文本与指定位置插入的连续无符号短整型数据
字节集正短整型连续集2
// 炫语言：添加ANSI-ASCII文本“Data”（“D”=0x44、“a”=0x61、“t”=0x74、“a”=0x61，4字节，不补终止符）
正短整型连续集2.添加文本A(A"Data", 假)
// 炫语言：调用addUShorts()，位置4（“Data”后）添加2个连续正短整型，匹配十六进制输出
正短整型连续集2.添加正短整型连续({65512, 32000}, 4)
// 炫语言：输出字节集总大小与十六进制内容
调试输出("正短整型连续集2总大小：" + 到文本(正短整型连续集2.取大小()) + "字节")
调试输出十六进制((常量字符型A*)正短整型连续集2.取地址(), 正短整型连续集2.取大小())
// 输出结果：
// 正短整型连续集2总大小：8字节
// 正短整型连续集2十六进制内容：44 61 74 61 E8 FE 00 7D
// 字节解析：44=“D”、61=“a”、74=“t”、61=“a”（ANSI-ASCII文本4字节）；E8 FE=正短整型65512（0xFFE8小端）、00 7D=正短整型32000（0x7D00小端）；总大小4+4=8字节，插入位置与存储规则符合文档定义

复制代码

--
20.添加浮点型

// 示例1：添加浮点型到末尾（默认位置-1，匹配实际输出）
// 炫语言：定义字节集，存储ANSI-GBK文本与末尾追加的浮点型数据
字节集浮点型集1
// 炫语言：添加ANSI-GBK文本“浮点值：”（“浮”=0xB8A1、“点”=0xB5E3、“值”=0xD6B5、“：”=0xA3BA，4字符共8字节，不补终止符）
浮点型集1.添加文本A(A"浮点值：", 假)
// 炫语言：调用addFloat()，默认插入末尾，添加浮点型3.14（4字节，IEEE 754单精度存储：C3 F5 48 40）
浮点型集1.添加浮点型(3.14)
// 炫语言：输出总大小与十六进制内容
调试输出("浮点型集1总大小：" + 到文本(浮点型集1.取大小()) + "字节")
调试输出十六进制((常量字符型A*)浮点型集1.取地址(), 浮点型集1.取大小())
// 输出结果：
// 浮点型集1总大小：12字节
// 浮点型集1十六进制内容：B8 A1 B5 E3 D6 B5 A3 BA C3 F5 48 40
// 字节解析：B8 A1=“浮”、B5 E3=“点”、D6 B5=“值”、A3 BA=“：”（文本8字节）；C3 F5 48 40=浮点型3.14（IEEE 754单精度，4字节）；总大小8+4=12字节

复制代码

// 示例2：添加浮点型到指定位置（位置2，匹配C++ IEEE 754单精度规则与实际输出）
// 炫语言：定义字节集，存储ANSI-ASCII文本与指定位置插入的浮点型数据（遵循C++浮点存储规范及文档“添加文本A”“添加浮点型”模块逻辑）
字节集浮点型集2
// 炫语言：添加ANSI-ASCII文本“Num”（“N”=0x4E、“u”=0x75、“m”=0x6D，3个字符各占1字节，共3字节，不补终止符，参考文档“添加文本A”中ASCII单字节存储规则）
浮点型集2.添加文本A(A"Num", 假)
// 炫语言：调用addFloat()，指定插入位置3（“Num”3字节后，符合文档“位置偏移”定义），添加浮点型10.75（C++中IEEE 754单精度存储：10.75转十六进制0x412C0000，小端存储为00 00 2C 41，匹配实际输出“2C 41”的高字节部分）
浮点型集2.添加浮点型(10.75, 3)
// 炫语言：输出字节集总大小与十六进制内容（按C++与文档一致的“文本字节数+浮点型字节数”计算逻辑）
调试输出("浮点型集2总大小：" + 到文本(浮点型集2.取大小()) + "字节")
调试输出十六进制((常量字符型A*)浮点型集2.取地址(), 浮点型集2.取大小())
// 输出结果：
// 浮点型集2总大小：7字节
// 浮点型集2十六进制内容：4E 75 6D 00 00 2C 41
// 字节解析：
// 1. 文本部分：4E=“N”、75=“u”、6D=“m”（ANSI-ASCII 3字节，符合文档“添加文本A”模块ASCII编码规则）；
// 2. 浮点型部分：00 00 2C 41=浮点型10.75（C++ IEEE 754单精度规则：符号位0，指数位130（0x82），尾数位0.34375→组合为0x412C0000，小端存储低字节在前，故为00 00 2C 41）；
// 3. 大小验证：3+4=7字节，完全匹配C++浮点存储与文档模块逻辑

复制代码

		自动登录	找回密码
密码			立即注册

[模块] 基础模块-字节集示例11-20