基础模块-字节集示例21-30

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

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

21.添加浮点型连续

// 炫语言：定义字节集，存储简单文本与末尾追加的连续浮点型
字节集浮点连续集1
// 炫语言：添加ANSI-ASCII文本“Floats:”（6个字符，每个1字节，共6字节，不补终止符）
浮点连续集1.添加文本A(A"Floats:", 假)
// 炫语言：调用addFloats()，默认插入末尾，添加2个简单浮点型{1.5, 2.5}（符合C++ IEEE 754单精度，每个占4字节）
浮点连续集1.添加浮点型连续({1.5, 2.5})
// 炫语言：输出字节集总大小与十六进制内容
调试输出("浮点连续集1总大小：" + 到文本(浮点连续集1.取大小()) + "字节")
调试输出十六进制((常量字符型A*)浮点连续集1.取地址(), 浮点连续集1.取大小())
// 输出结果：
// 浮点连续集1总大小：15字节（文本7字节 + 2个浮点型8字节，文本含末尾隐含空字节）
// 浮点连续集1十六进制内容：46 6C 6F 61 74 73 3A 00 00 C0 3F 00 00 20 40
// 字节解析：46（“F”）、6C（“l”）、6F（“o”）、61（“a”）、74（“t”）、73（“s”）、3A（“：”）、00（文本隐含空字节）（共7字节）；00 00 C0 3F=浮点型1.5（C++ IEEE 754单精度，小端存储）、00 00 20 40=浮点型2.5（C++ IEEE 754单精度，小端存储）（各4字节，共8字节），总大小7+8=15字节

复制代码

// 炫语言：定义字节集，存储基础文本与指定位置插入的连续浮点型
字节集浮点连续集2
// 炫语言：添加ANSI-ASCII文本“Vals:”（5个字符，每个1字节，共5字节，不补终止符）
浮点连续集2.添加文本A(A"Vals:", 假)
// 炫语言：调用addFloats()，指定插入位置5（“Vals:”后），添加2个简单浮点型{3.0, 4.5}（符合C++ IEEE 754单精度，每个占4字节）
浮点连续集2.添加浮点型连续({3.0, 4.5}, 5)
// 炫语言：输出字节集总大小与十六进制内容
调试输出("浮点连续集2总大小：" + 到文本(浮点连续集2.取大小()) + "字节")
调试输出十六进制((常量字符型A*)浮点连续集2.取地址(), 浮点连续集2.取大小())
// 输出结果：
// 浮点连续集2总大小：13字节（文本5字节 + 2个浮点型8字节）
// 浮点连续集2十六进制内容：56 61 6C 73 3A 00 00 40 40 00 00 90 40
// 字节解析：56（“V”）、61（“a”）、6C（“l”）、73（“s”）、3A（“：”）（共5字节，ANSI-ASCII编码）；00 00 40 40=浮点型3.0（C++ IEEE 754单精度，小端存储）、00 00 90 40=浮点型4.5（C++ IEEE 754单精度，小端存储）（各4字节，共8字节），总大小5+8=13字节

复制代码

--
22.添加双浮点型

// 炫语言：定义字节集，存储ANSI-ASCII文本与双浮点型数据（遵循文档模块规范）
字节集双浮点型集
// 炫语言：添加ANSI-ASCII文本“Temp”（4字符，每字符1字节，共4字节，不补终止符）
双浮点型集.添加文本A(A"Temp", 假)
// 炫语言：调用addDouble()，位置4（“Temp”后）插入双浮点型26.875（IEEE 754双精度，8字节，小端存储为00 00 00 00 00 E0 3A 40）
双浮点型集.添加双浮点型(26.875, 4)
// 炫语言：输出总大小与十六进制内容
调试输出("双浮点型集总大小：" + 到文本(双浮点型集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)双浮点型集.取地址(), 双浮点型集.取大小())
// 输出结果：
// 双浮点型集总大小：12字节（文本4字节 + 双浮点型8字节）
// 双浮点型集十六进制内容：54 65 6D 70 00 00 00 00 00 E0 3A 40
// 字节解析：
// 1. 文本：54=“T”、65=“e”、6D=“m”、70=“p”（ANSI-ASCII编码，符合文档“添加文本A”单字节规则）；
// 2. 双浮点型：00 00 00 00 00 E0 3A 40=26.875（C++ IEEE 754双精度：0x403AE00000000000小端存储，8字节）；
// 3. 规则匹配：总大小=4+8=12字节，若原数据为引用类型，已断开引用生成新实例，符合备注要求

复制代码

--
23.添加双浮点型连续

// 示例：添加多个双浮点型到末尾（默认位置-1）
// 炫语言：定义字节集，存储ANSI-ASCII文本与末尾追加的连续双浮点型数据
字节集双浮点连续集
// 炫语言：添加ANSI-ASCII文本"Doubles:"（8个字符，每个1字节，共8字节，不补终止符）
双浮点连续集.添加文本A(A"Doubles:", 假)
// 炫语言：调用addDoubles()，默认插入末尾，添加2个连续双浮点型{1.23, 4.56}（IEEE 754双精度，每个占8字节）
双浮点连续集.添加双浮点型连续({1.23, 4.56})
// 炫语言：输出字节集总大小与十六进制内容
调试输出("双浮点连续集总大小：" + 到文本(双浮点连续集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)双浮点连续集.取地址(), 双浮点连续集.取大小())
// 输出结果：
// 双浮点连续集总大小：24字节
// 双浮点连续集十六进制内容：44 6F 75 62 6C 65 73 3A AE 47 E1 7A 14 AE F3 3F 3D 0A D7 A3 70 3D 12 40
// 字节解析：44="D"、6F="o"、75="u"、62="b"、6C="l"、65="e"、73="s"、3A=":"（文本8字节）；AE 47 E1 7A 14 AE F3 3F=双浮点型1.23（IEEE 754双精度，小端存储）、3D 0A D7 A3 70 3D 12 40=双浮点型4.56（IEEE 754双精度，小端存储）（各8字节，共16字节），总大小=8+16=24字节

复制代码

--
24.添加字符型

// 示例：添加宽字符到字节集
// 炫语言：定义字节集，存储宽字符数据
字节集字符集
// 炫语言：添加宽字符'A'（Unicode编码，占2字节）
字符集.添加字符型('A')
// 炫语言：输出字节集大小与十六进制内容
调试输出("添加字符'A'后大小：" + 到文本(字符集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)字符集.取地址(), 字符集.取大小())
// 输出结果：
// 添加字符'A'后大小：2字节
// 十六进制内容：41 00
// 字节解析：41 00='A'（Unicode小端存储，0x0041）
// 炫语言：继续在位置0插入宽字符'中'（Unicode编码，占2字节）
字符集.添加字符型('中', 0)
// 炫语言：输出插入后的字节集状态
调试输出("插入字符'中'后大小：" + 到文本(字符集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)字符集.取地址(), 字符集.取大小())
// 输出结果：
// 插入字符'中'后大小：4字节
// 十六进制内容：2D 4E 41 00
// 字节解析：2D 4E='中'（Unicode小端存储，0x4E2D）；41 00='A'，总大小=2+2=4字节

复制代码

--
25.添加字符连续

// 示例：添加多个宽字符到字节集
// 炫语言：定义字节集，存储连续宽字符数据
字节集字符连续集
// 炫语言：添加连续宽字符{'H','e','l','l','o'}（每个宽字符占2字节）
字符连续集.添加字符连续({'H','e','l','l','o'})
// 炫语言：输出字节集大小与十六进制内容
调试输出("添加Hello后大小：" + 到文本(字符连续集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)字符连续集.取地址(), 字符连续集.取大小())
// 输出结果：
// 添加Hello后大小：10字节
// 十六进制内容：48 00 65 00 6C 00 6C 00 6F 00
// 字节解析：48 00='H'、65 00='e'、6C 00='l'、6C 00='l'、6F 00='o'（Unicode小端存储）
// 炫语言：在位置2插入连续宽字符{'世','界'}（每个宽字符占2字节）
字符连续集.添加字符连续({'世','界'}, 2)
// 炫语言：输出插入后的字节集状态
调试输出("插入'世界'后大小：" + 到文本(字符连续集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)字符连续集.取地址(), 字符连续集.取大小())
// 输出结果：
// 插入'世界'后大小：14字节
// 十六进制内容：48 00 16 4E 4C 75 65 00 6C 00 6C 00 6F 00
// 字节解析：48 00='H'；16 4E='世'（Unicode 0x4E16小端存储）、4C 75='界'（Unicode 0x754C小端存储）；65 00='e'、6C 00='l'、6C 00='l'、6F 00='o'，总大小=10+4=14字节

复制代码

--
26.添加字节型连续

// 示例：添加多个字节数据到字节集
// 炫语言：定义字节集，存储连续字节数据
字节集字节连续集
// 炫语言：添加连续字节数据{0x12, 0x34, 0x56, 0x78}（每个字节占1字节）
字节连续集.添加字节型连续({0x12, 0x34, 0x56, 0x78})
// 炫语言：输出字节集大小与十六进制内容
调试输出("添加字节数据后大小：" + 到文本(字节连续集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)字节连续集.取地址(), 字节连续集.取大小())
// 输出结果：
// 添加字节数据后大小：4字节
// 十六进制内容：12 34 56 78
// 字节解析：12、34、56、78为原始字节值，顺序存储
// 炫语言：在位置2插入连续字节数据{0xAB, 0xCD, 0xEF}（每个字节占1字节）
字节连续集.添加字节型连续({0xAB, 0xCD, 0xEF}, 2)
// 炫语言：输出插入后的字节集状态
调试输出("插入字节数据后大小：" + 到文本(字节连续集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)字节连续集.取地址(), 字节连续集.取大小())
// 输出结果：
// 插入字节数据后大小：7字节
// 十六进制内容：12 34 AB CD EF 56 78
// 字节解析：12 34=原数据前两个字节；AB CD EF=插入的三个字节；56 78=原数据后两个字节，总大小=4+3=7字节

复制代码

--
27.添加字节型

// 示例：添加单个字节数据到字节集
// 炫语言：定义字节集，存储字节数据
字节集字节集数据
// 炫语言：添加字节数据0xAA到末尾
字节集数据.添加字节型(0xAA)
// 炫语言：输出字节集大小与十六进制内容
调试输出("添加字节0xAA后大小：" + 到文本(字节集数据.取大小()) + "字节")
调试输出十六进制((常量字符型A*)字节集数据.取地址(), 字节集数据.取大小())
// 输出结果：
// 添加字节0xAA后大小：1字节
// 十六进制内容：AA
// 字节解析：AA为原始字节值
// 炫语言：在位置0插入字节数据0x55
字节集数据.添加字节型(0x55, 0)
// 炫语言：输出插入后的字节集状态
调试输出("插入字节0x55后大小：" + 到文本(字节集数据.取大小()) + "字节")
调试输出十六进制((常量字符型A*)字节集数据.取地址(), 字节集数据.取大小())
// 输出结果：
// 插入字节0x55后大小：2字节
// 十六进制内容：55 AA
// 字节解析：55=插入的字节值；AA=原字节值，总大小=1+1=2字节

复制代码

--
28.添加十六进制

// 示例：添加十六进制字符串到字节集
// 炫语言：定义字节集，存储十六进制数据
字节集十六进制集
// 炫语言：添加十六进制字符串"48656C6C6F"（对应ASCII文本"Hello"）
十六进制集.添加十六进制("48656C6C6F")
// 炫语言：输出字节集大小与十六进制内容
调试输出("添加十六进制字符串后大小：" + 到文本(十六进制集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)十六进制集.取地址(), 十六进制集.取大小())
// 输出结果：
// 添加十六进制字符串后大小：5字节
// 十六进制内容：48 65 6C 6C 6F
// 字节解析：48='H'、65='e'、6C='l'、6C='l'、6F='o'
// 炫语言：在位置2插入十六进制字符串"776F726C64"（对应ASCII文本"world"）
十六进制集.添加十六进制("776F726C64", 2)
// 炫语言：输出插入后的字节集状态
调试输出("插入十六进制字符串后大小：" + 到文本(十六进制集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)十六进制集.取地址(), 十六进制集.取大小())
// 输出结果：
// 插入十六进制字符串后大小：10字节
// 十六进制内容：48 65 77 6F 72 6C 64 6C 6C 6F
// 字节解析：48='H'、65='e'；77='w'、6F='o'、72='r'、6C='l'、64='d'；6C='l'、6C='l'、6F='o'，总大小=5+5=10字节

复制代码

--
29.添加变整型

// 示例：添加变整型数据到字节集
// 炫语言：定义字节集，存储变整型数据
字节集变整型集
// 炫语言：添加变整型值123（变整型编码，占4字节）
变整型集.添加变整型(123)
// 炫语言：输出字节集大小与十六进制内容
调试输出("添加变整型123后大小：" + 到文本(变整型集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)变整型集.取地址(), 变整型集.取大小())
// 输出结果：
// 添加变整型123后大小：4字节
// 十六进制内容：7B 00 00 00
// 字节解析：7B 00 00 00=123（小端存储，4字节）
// 炫语言：在位置0插入变整型值300（变整型编码，占4字节）
变整型集.添加变整型(300, 0)
// 炫语言：输出插入后的字节集状态
调试输出("插入变整型300后大小：" + 到文本(变整型集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)变整型集.取地址(), 变整型集.取大小())
// 输出结果：
// 插入变整型300后大小：8字节
// 十六进制内容：2C 01 00 00 7B 00 00 00
// 字节解析：2C 01 00 00=300（小端存储，4字节）；7B 00 00 00=原值123，总大小=4+4=8字节

复制代码

--
30.添加变整型连续

// 示例：添加多个变整型数据到字节集
// 炫语言：定义字节集，存储连续变整型数据
字节集变整型连续集
// 炫语言：添加连续变整型{123, 456, 789}（每个变整型占4字节）
变整型连续集.添加变整型连续({123, 456, 789})
// 炫语言：输出字节集大小与十六进制内容
调试输出("添加变整型连续后大小：" + 到文本(变整型连续集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)变整型连续集.取地址(), 变整型连续集.取大小())
// 输出结果：
// 添加变整型连续后大小：12字节
// 十六进制内容：7B 00 00 00 C8 01 00 00 15 03 00 00
// 字节解析：7B 00 00 00=123、C8 01 00 00=456、15 03 00 00=789（每个变整型4字节，小端存储）
// 炫语言：在位置4插入连续变整型{1000, 2000}（每个变整型占4字节）
变整型连续集.添加变整型连续({1000, 2000}, 4)
// 炫语言：输出插入后的字节集状态
调试输出("插入变整型连续后大小：" + 到文本(变整型连续集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)变整型连续集.取地址(), 变整型连续集.取大小())
// 输出结果：
// 插入变整型连续后大小：20字节
// 十六进制内容：7B 00 00 00 E8 03 00 00 D0 07 00 00 C8 01 00 00 15 03 00 00
// 字节解析：7B 00 00 00=原第一个值123；E8 03 00 00=1000、D0 07 00 00=2000（插入的两个变整型）；C8 01 00 00=原第二个值456、15 03 00 00=原第三个值789，总大小=12+8=20字节

复制代码

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

[模块] 基础模块-字节集示例21-30