基础模块-字节集示例1-10

qq1073176068 · 发表于 2025-9-27 11:36:40

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

1.置大小

// 示例1：基础内存分配与填充
// 炫语言：定义字节集（2字，存分配的内存）
字节集内存集
// 炫语言：分配4字节内存，获取地址
字节型 *内存址 = 内存集.置大小(4)
// 炫语言：输出内存十六进制
调试输出十六进制((常量字符型A*)内存址, 4)
// 输出：00 00 00 00

复制代码

// 炫语言：定义ANSI编码文本（A标识多字节，“12测”GBK编码占4字节）
文本型A 测试文 = A"12测"
// 炫语言：定义字节集，存储文本内存数据
字节集文本集
// 炫语言：分配4字节内存（匹配文本大小），获取内存地址
字节型* 文本址 = 文本集.置大小(测试文.取大小())
// 炫语言：复制文本内存数据到字节集
内存复制(文本址, 测试文.取地址(), 测试文.取大小())
// 炫语言：输出还原后的文本（ANSI转Unicode）
调试输出("还原文本：" + A2W((常量字符型A*)文本址))
// 炫语言：输出字节集十六进制内容（匹配实际存储）
调试输出十六进制((常量字符型A*)文本集.取地址(), 文本集.取大小())
// 输出结果：
// 还原文本：12测
// 十六进制输出：31 32 B2 E2
// 字节解析：31（“1”）、32（“2”）、B2 E2（“测”，GBK双字节编码）

复制代码

--
2.调整大小

// 炫语言：定义字节集，用于存储待扩容数据
字节集数据集
// 炫语言：添加ANSI文本"!@"（GBK编码，"!"=0x21、"@"=0x40，共2字节）
数据集.添加文本A(A"!@", 假)
// 炫语言：调试输出扩容前的字节集大小与十六进制内容
调试输出("扩容前字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("扩容前十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 炫语言：调整字节集大小为5字节（原2字节→扩容3字节，默认补00，原数据保留在头部）
常量字节型* 扩容址 = 数据集.调整大小(5)
// 炫语言：调试输出扩容后的字节集大小与十六进制内容
调试输出("扩容后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("扩容后十六进制内容：")
调试输出十六进制((常量字符型A*)扩容址, 5)
// 输出结果：
// 扩容前字节集大小：2字节
// 扩容前十六进制内容：21 40
// 扩容后字节集大小：5字节
// 扩容后十六进制内容：21 40 00 00 00
// 字节解析：扩容前2字节为原数据"!@"（21 40）；扩容后新增3字节默认补00，总大小5字节

复制代码

// 炫语言：定义字节集，用于存储数字文本数据
字节集数字集
// 炫语言：添加ANSI文本"12"（GBK编码，"1"=0x31、"2"=0x32，共2字节）
数字集.添加文本A(A"12", 假)
// 炫语言：调试输出扩容前的字节集大小与十六进制内容
调试输出("扩容前字节集大小：" + 到文本(数字集.取大小()) + "字节")
调试输出("扩容前十六进制内容：")
调试输出十六进制((常量字符型A*)数字集.取地址(), 数字集.取大小())
// 炫语言：调整字节集大小为4字节（原2字节→扩容2字节，默认补00，保留原数字数据）
常量字节型* 结果址 = 数字集.调整大小(4)
// 炫语言：调试输出扩容后的字节集大小与十六进制内容
调试输出("扩容后字节集大小：" + 到文本(数字集.取大小()) + "字节")
调试输出("扩容后十六进制内容：")
调试输出十六进制((常量字符型A*)结果址, 4)
// 输出结果：
// 扩容前字节集大小：2字节
// 扩容前十六进制内容：31 32
// 扩容后字节集大小：4字节
// 扩容后十六进制内容：31 32 00 00
// 字节解析：扩容前2字节为原数字文本"12"（31 32）；扩容后新增2字节默认补00，总大小4字节

复制代码

--
3.添加大小

// 炫语言：定义字节集，用于存储带追加内存的数据
字节集数据集
// 炫语言：添加ANSI文本"A"（GBK编码，"A"=0x41，占1字节，不补终止符）
数据集.添加文本A(A"A", 假)
// 炫语言：调试输出追加前的字节集大小与十六进制内容
调试输出("追加前字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("追加前十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 炫语言：末尾追加2字节内存（原1字节→总大小3字节，追加字节默认填充00）
数据集.添加大小(2)
// 炫语言：调试输出追加后的字节集大小与十六进制内容
调试输出("追加后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("追加后十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 追加前字节集大小：1字节
// 追加前十六进制内容：41
// 追加后字节集大小：3字节
// 追加后十六进制内容：41 00 00
// 字节解析：追加前1字节为原数据"A"（41）；追加2字节默认补00，总大小3字节，原数据保留在头部

复制代码

// 炫语言：定义字节集，用于存储多轮追加的数字文本数据
字节集数字集
// 炫语言：添加ANSI文本"12"（GBK编码，"1"=0x31、"2"=0x32，共2字节，不补终止符）
数字集.添加文本A(A"12", 假)
// 炫语言：调试输出初始（追加前）的字节集大小与十六进制内容
调试输出("初始字节集大小：" + 到文本(数字集.取大小()) + "字节")
调试输出("初始十六进制内容：")
调试输出十六进制((常量字符型A*)数字集.取地址(), 数字集.取大小())
// 炫语言：第一次追加1字节（原2字节→3字节，追加字节默认补00）
数字集.添加大小(1)
// 炫语言：调试输出第一次追加后的状态
调试输出("第一次追加后大小：" + 到文本(数字集.取大小()) + "字节")
调试输出("第一次追加后十六进制内容：")
调试输出十六进制((常量字符型A*)数字集.取地址(), 数字集.取大小())
// 炫语言：第二次追加2字节（原3字节→5字节，追加字节默认补00）
数字集.添加大小(2)
// 炫语言：调试输出第二次追加后的最终状态
调试输出("第二次追加后（最终）大小：" + 到文本(数字集.取大小()) + "字节")
调试输出("第二次追加后（最终）十六进制内容：")
调试输出十六进制((常量字符型A*)数字集.取地址(), 数字集.取大小())
// 输出结果：
// 初始字节集大小：2字节
// 初始十六进制内容：31 32
// 第一次追加后大小：3字节
// 第一次追加后十六进制内容：31 32 00
// 第二次追加后（最终）大小：5字节
// 第二次追加后（最终）十六进制内容：31 32 00 00 00
// 字节解析：初始2字节为原数据"12"（31 32）；两次追加共3字节均补00，总大小5字节，原数据始终保留在头部

复制代码

--
4.替换数据

// 炫语言：定义字节集，存储待替换中间数据的文本
字节集数据集
// 炫语言：添加ANSI文本"12345"（GBK编码，"1"-"5"对应0x31-0x35，共5字节，不补终止符）
数据集.添加文本A(A"12345", 假)
// 炫语言：调试输出替换前的字节集大小与十六进制内容
调试输出("替换前字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("替换前十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 炫语言：定义ANSI替换数据"A B"（对应0x41 0x20 0x42，共3字节）
文本型A 替换数据 = A"A B"
// 炫语言：从位置1开始，用替换数据覆盖3字节（原位置1-3的"234"被替换）
数据集.替换数据(替换数据.取地址(), 替换数据.取大小(), 1)
// 炫语言：调试输出替换后的字节集大小与十六进制内容
调试输出("替换后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("替换后十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 替换前字节集大小：5字节
// 替换前十六进制内容：31 32 33 34 35
// 替换后字节集大小：5字节
// 替换后十六进制内容：31 41 20 42 35
// 字节解析：替换仅覆盖指定区域（位置1-3），原位置0的"1"（31）和位置4的"5"（35）保留，总大小不变

复制代码

// 炫语言：定义字节集，存储待替换起始数据的字符文本
字节集字符集
// 炫语言：添加ANSI文本"abcd"（GBK编码，"a"-"d"对应0x61-0x64，共4字节，不补终止符）
字符集.添加文本A(A"abcd", 假)
// 炫语言：调试输出替换前的字节集大小与十六进制内容
调试输出("替换前字节集大小：" + 到文本(字符集.取大小()) + "字节")
调试输出("替换前十六进制内容：")
调试输出十六进制((常量字符型A*)字符集.取地址(), 字符集.取大小())
// 炫语言：定义ANSI替换数据"XY"（对应0x58 0x59，共2字节）
文本型A 新数据 = A"XY"
// 炫语言：从起始位置0开始，用替换数据覆盖2字节（原位置0-1的"ab"被替换）
字符集.替换数据(新数据.取地址(), 新数据.取大小(), 0)
// 炫语言：调试输出替换后的字节集大小与十六进制内容
调试输出("替换后字节集大小：" + 到文本(字符集.取大小()) + "字节")
调试输出("替换后十六进制内容：")
调试输出十六进制((常量字符型A*)字符集.取地址(), 字符集.取大小())
// 输出结果：
// 替换前字节集大小：4字节
// 替换前十六进制内容：61 62 63 64
// 替换后字节集大小：4字节
// 替换后十六进制内容：58 59 63 64
// 字节解析：仅覆盖起始位置0-1的2字节，原位置2的"c"（63）、位置3的"d"（64）保留，总大小不变

复制代码

--
5.添加数据

// 炫语言：定义字节集，存储待追加数据的文本
字节集数据集
// 炫语言：添加ANSI文本"12"（GBK编码，"1"=0x31、"2"=0x32，共2字节，不补终止符）
数据集.添加文本A(A"12", 假)
// 炫语言：调试输出添加前（初始）的字节集大小与十六进制内容
调试输出("添加前字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("添加前十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 炫语言：定义ANSI新增数据"34"（对应0x33、0x34，共2字节）
文本型A 新增数据 = A"34"
// 炫语言：默认位置-1（末尾）添加数据，字节集大小随新增数据长度增加
数据集.添加数据(新增数据.取地址(), 新增数据.取大小())
// 炫语言：调试输出添加后的字节集大小与十六进制内容
调试输出("添加后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("添加后十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 添加前字节集大小：2字节
// 添加前十六进制内容：31 32
// 添加后字节集大小：4字节
// 添加后十六进制内容：31 32 33 34
// 字节解析：新增数据"34"（33 34）追加在原数据"12"（31 32）末尾，总大小=原2字节+新增2字节=4字节

复制代码

// 炫语言：定义字节集，存储待插入数据的字符文本
字节集字符集
// 炫语言：添加ANSI文本"AB"（GBK编码，"A"=0x41、"B"=0x42，共2字节，不补终止符）
字符集.添加文本A(A"AB", 假)
// 炫语言：调试输出插入前的字节集大小与十六进制内容
调试输出("插入前字节集大小：" + 到文本(字符集.取大小()) + "字节")
调试输出("插入前十六进制内容：")
调试输出十六进制((常量字符型A*)字符集.取地址(), 字符集.取大小())
// 炫语言：定义ANSI插入数据"XY"（对应0x58、0x59，共2字节）
文本型A 插入数据 = A"XY"
// 炫语言：在位置1（"A"后、"B"前）插入数据，字节集大小随插入数据长度增加
字符集.添加数据(插入数据.取地址(), 插入数据.取大小(), 1)
// 炫语言：调试输出插入后的字节集大小与十六进制内容
调试输出("插入后字节集大小：" + 到文本(字符集.取大小()) + "字节")
调试输出("插入后十六进制内容：")
调试输出十六进制((常量字符型A*)字符集.取地址(), 字符集.取大小())
// 输出结果：
// 插入前字节集大小：2字节
// 插入前十六进制内容：41 42
// 插入后字节集大小：4字节
// 插入后十六进制内容：41 58 59 42
// 字节解析：插入数据"XY"（58 59）插入到原数据"AB"（41 42）的位置1，总大小=原2字节+插入2字节=4字节，原数据顺序保留

复制代码

--
6.添加文本

// 炫语言：定义字节集，存储Unicode编码的文本数据
字节集文本集
// 炫语言：添加Unicode文本"你好"（不填终止符，每个字符占2字节，"你"=0x4F60、"好"=0x597D，共4字节）
文本集.添加文本("你好", 假)
// 炫语言：调试输出第一次添加后的字节集大小与十六进制内容
调试输出("添加“你好”后大小：" + 到文本(文本集.取大小()) + "字节")
调试输出("添加“你好”后十六进制内容：")
调试输出十六进制((常量字符型A*)文本集.取地址(), 文本集.取大小())
// 炫语言：继续添加Unicode文本"World"（默认不填终止符，每个字母占2字节，共10字节）
文本集.添加文本("World", 假)
// 炫语言：调试输出两次添加后的总大小与十六进制内容
调试输出("添加“World”后总大小：" + 到文本(文本集.取大小()) + "字节")
调试输出("添加后完整十六进制内容：")
调试输出十六进制((常量字符型A*)文本集.取地址(), 文本集.取大小())
// 输出结果：
// 添加“你好”后大小：4字节
// 添加“你好”后十六进制内容：60 4F 7D 59 （注：Unicode字节序为小端，0x4F60对应60 4F，0x597D对应7D 59）
// 添加“World”后总大小：14字节
// 添加后完整十六进制内容：60 4F 7D 59 57 00 6F 00 72 00 6C 00 64 00
// 字节解析：Unicode编码下每个字符占2字节，"World"中"W"=0x0057（57 00）、"o"=0x006F（6F 00）等，总大小=4字节+10字节=14字节

复制代码

// 示例2：在Unicode文本指定位置插入带终止符的内容
// 炫语言：定义字节集（仅声明1次，避免重定义），存储Unicode编码文本数据
字节集混合集
// 炫语言：添加Unicode文本"123"（不补终止符，每个字符2字节，共6字节）
混合集.添加文本("123", 假)
// 炫语言：调试输出添加"123"后的状态
调试输出("添加“123”后大小：" + 到文本(混合集.取大小()) + "字节")
调试输出("添加“123”后十六进制内容：")
调试输出十六进制((常量字符型A*)混合集.取地址(), 混合集.取大小())
// 炫语言：在位置2（"1"后、"2"前）插入Unicode"ABC"+终止符（TRUE，终止符2字节00 00）
// 注："ABC"占6字节（每字符2字节），总插入8字节（无需再次声明“混合集”，直接使用已定义变量）
混合集.添加文本("ABC", 真, 2)
// 炫语言：调试输出插入后的状态
调试输出("插入“ABC”+终止符后总大小：" + 到文本(混合集.取大小()) + "字节")
调试输出("插入后完整十六进制内容：")
调试输出十六进制((常量字符型A*)混合集.取地址(), 混合集.取大小())
// 输出结果：
// 添加“123”后大小：6字节
// 添加“123”后十六进制内容：31 00 32 00 33 00
// 字节解析：Unicode小端存储，31 00="1"、32 00="2"、33 00="3"
// 插入“ABC”+终止符后总大小：20字节
// 插入后完整十六进制内容：31 00 41 00 42 00 43 00 41 00 42 00 43 00 00 00 32 00 33 00
// 字节解析：31 00=原"1"；41 00-43 00=插入"ABC"（含重复）；00 00=终止符；32 00-33 00=原"2""3"

复制代码

--
7.添加文本A

// 示例1：添加文本A到末尾（默认不填终止符）
// 炫语言：定义字节集，用于存储ANSI（GBK编码）文本数据
字节集文本集A
// 第一步：添加ANSI文本"测试"（GBK编码）
// 炫语言：添加"测试"（GBK下"测"=0xB2E2、"试"=0xCAD4，共4字节，不补终止符）
文本集A.添加文本A(A"测试", 假)
// 炫语言：调试输出添加"测试"后的状态（验证初始添加结果）
调试输出("添加“测试”后字节集大小：" + 到文本(文本集A.取大小()) + "字节")
调试输出("添加“测试”后十六进制内容：")
调试输出十六进制((常量字符型A*)文本集A.取地址(), 文本集A.取大小())
// 第二步：追加ANSI文本"123"（ASCII编码）
// 炫语言：添加"123"（ASCII下"1"=0x31、"2"=0x32、"3"=0x33，共3字节，默认追加到末尾，不补终止符）
文本集A.添加文本A(A"123", 假)
// 炫语言：调试输出最终状态（验证追加后总大小与完整内容）
调试输出("追加“123”后字节集总大小：" + 到文本(文本集A.取大小()) + "字节")
调试输出("追加后完整十六进制内容：")
调试输出十六进制((常量字符型A*)文本集A.取地址(), 文本集A.取大小())
// 输出结果：
// 添加“测试”后字节集大小：4字节
// 添加“测试”后十六进制内容：B2 E2 CA D4
// 追加“123”后字节集总大小：7字节
// 追加后完整十六进制内容：B2 E2 CA D4 31 32 33
// 字节解析：B2 E2=“测”、CA D4=“试”、31=“1”、32=“2”、33=“3”，无终止符，总大小=4+3=7字节

复制代码

// 示例2：添加文本A到指定位置+填终止符
// 炫语言：定义字节集，用于存储ANSI编码（ASCII/GBK）的字符数据
字节集字符集A
// 第一步：添加初始ANSI文本"ABC"
// 炫语言：添加"ABC"（ANSI-ASCII编码，"A"=0x41、"B"=0x42、"C"=0x43，共3字节，不补终止符）
字符集A.添加文本A(A"ABC", 假)
// 炫语言：调试输出初始添加后的状态（验证初始数据与大小）
调试输出("添加“ABC”后字节集大小：" + 到文本(字符集A.取大小()) + "字节")
调试输出("添加“ABC”后十六进制内容：")
调试输出十六进制((常量字符型A*)字符集A.取地址(), 字符集A.取大小())
// 第二步：在指定位置插入"XYZ"+终止符
// 炫语言：添加"XYZ"（ANSI-ASCII编码，"X"=0x58、"Y"=0x59、"Z"=0x5A，共3字节）到位置1（"A"后、"B"前），并补ANSI终止符（0x00，1字节）
字符集A.添加文本A(A"XYZ", 真, 1)
// 炫语言：调试输出插入后的最终状态（验证总大小与完整内容）
调试输出("插入“XYZ”+终止符后字节集总大小：" + 到文本(字符集A.取大小()) + "字节")
调试输出("插入后完整十六进制内容：")
调试输出十六进制((常量字符型A*)字符集A.取地址(), 字符集A.取大小())
// 输出结果：
// 添加“ABC”后字节集大小：3字节
// 添加“ABC”后十六进制内容：41 42 43
// 插入“XYZ”+终止符后字节集总大小：7字节
// 插入后完整十六进制内容：41 58 59 5A 00 42 43
// 字节解析：41=原"ABC"的"A"；58=“X”、59=“Y”、5A=“Z”（插入的文本）；00=ANSI终止符；42=原"ABC"的"B"、43=原"ABC"的"C"，总大小=3+3+1=7字节

复制代码

--
8.添加整形

// 示例1：添加整型到末尾（默认位置-1）
// 炫语言：定义字节集，用于存储ANSI文本+整型数据的组合内容
字节集整型集1
// 第一步：添加ANSI编码的文本前缀"数值："
// 炫语言：添加"数值："（ANSI-GBK编码，"数"=0xCAFD、"值"=0xD6B5、"："=0xA3BA，每个汉字/符号占2字节，共6字节，不补终止符）
整型集1.添加文本A(A"数值：", 假)
// 炫语言：调试输出添加文本后的状态（验证文本存储结果，修正原注释中大小与编码的错误）
调试输出("添加“数值：”后字节集大小：" + 到文本(整型集1.取大小()) + "字节")
调试输出("添加“数值：”后十六进制内容：")
调试输出十六进制((常量字符型A*)整型集1.取地址(), 整型集1.取大小())
// 第二步：在字节集末尾追加整型值1234
// 炫语言：添加整型1234（占4字节，小端存储规则：低字节在前，对应十六进制D2 04 00 00），默认追加到末尾
整型集1.添加整型(1234)
// 炫语言：调试输出最终状态（验证文本+整型组合的总大小与完整内容，匹配修正后的文本大小）
调试输出("追加整型1234后字节集总大小：" + 到文本(整型集1.取大小()) + "字节")
调试输出("追加后完整十六进制内容：")
调试输出十六进制((常量字符型A*)整型集1.取地址(), 整型集1.取大小())
// 输出结果：
// 添加“数值：”后字节集大小：6字节
// 添加“数值：”后十六进制内容：CA FD D6 B5 A3 BA
// 追加整型1234后字节集总大小：10字节
// 追加后完整十六进制内容：CA FD D6 B5 A3 BA D2 04 00 00
// 字节解析：CA FD=“数”、D6 B5=“值”、A3 BA=“：”（文本部分，共6字节）；D2 04 00 00=整型1234（小端存储，4字节），总大小=6+4=10字节

复制代码

// 示例2：添加整型到指定位置（位置2）
// 炫语言：定义字节集，用于存储ANSI文本+指定位置插入整型的组合数据
字节集整型集2
// 第一步：添加ANSI编码的初始文本"AB"
// 炫语言：添加"AB"（ANSI-ASCII编码，"A"=0x41、"B"=0x42，每个字符1字节，共2字节，不补终止符）
整型集2.添加文本A(A"AB", 假)
// 炫语言：调试输出添加初始文本后的状态（验证文本存储大小与内容）
调试输出("添加“AB”后字节集大小：" + 到文本(整型集2.取大小()) + "字节")
调试输出("添加“AB”后十六进制内容：")
调试输出十六进制((常量字符型A*)整型集2.取地址(), 整型集2.取大小())
// 第二步：在指定位置（位置2，即"AB"的"B"之后）插入整型值5678
// 炫语言：添加整型5678（占4字节，遵循小端存储规则：低字节在前，计算得5678转十六进制为0x16EE，小端存储为EE 16 00 00），插入位置设为2
整型集2.添加整型(5678, 2)
// 炫语言：调试输出插入整型后的最终状态（验证总大小与完整数据排布）
调试输出("在位置2插入整型5678后字节集总大小：" + 到文本(整型集2.取大小()) + "字节")
调试输出("插入后完整十六进制内容：")
调试输出十六进制((常量字符型A*)整型集2.取地址(), 整型集2.取大小())
// 输出结果：
// 添加“AB”后字节集大小：2字节
// 添加“AB”后十六进制内容：41 42
// 在位置2插入整型5678后字节集总大小：6字节
// 插入后完整十六进制内容：41 42 EE 16 00 00
// 字节解析：41=“A”、42=“B”（初始文本，2字节）；EE 16 00 00=整型5678（小端存储，4字节，插入于“B”后），总大小=2+4=6字节

复制代码

--
9.添加整形连续

// 示例1：添加多个整型到末尾（默认位置-1，匹配实际十六进制输出）
// 炫语言：定义字节集，用于存储ANSI文本+连续整型的组合数据
字节集连续整型集1
// 第一步：添加ANSI-GBK编码的文本前缀"连续值："
// 炫语言：添加"连续值："（GBK编码，"连"=0xC1AC、"续"=0xD0F8、"值"=0xD6B5、"："=0xA3BA，每个占2字节，共8字节，不补终止符）
连续整型集1.添加文本A(A"连续值：", 假)
// 炫语言：调试输出添加文本后的状态
调试输出("添加“连续值：”后字节集大小：" + 到文本(连续整型集1.取大小()) + "字节")
调试输出("添加“连续值：”后十六进制内容：")
调试输出十六进制((常量字符型A*)连续整型集1.取地址(), 连续整型集1.取大小())
// 第二步：在字节集末尾追加3个连续整型（100、200、300）
// 炫语言：添加整型数组{100,200,300}（每个整型4字节，小端存储：100=64 00 00 00；200=C8 00 00 00；300=2C 01 00 00），默认追加到末尾
连续整型集1.添加整型连续({100, 200, 300})
// 炫语言：调试输出追加连续整型后的总大小与完整内容
调试输出("追加整型100+200+300后字节集总大小：" + 到文本(连续整型集1.取大小()) + "字节")
调试输出("追加后完整十六进制内容：")
调试输出十六进制((常量字符型A*)连续整型集1.取地址(), 连续整型集1.取大小())
// 输出结果：
// 添加“连续值：”后字节集大小：8字节
// 添加“连续值：”后十六进制内容：C1 AC D0 F8 D6 B5 A3 BA
// 追加整型100+200+300后字节集总大小：20字节
// 追加后完整十六进制内容：C1 AC D0 F8 D6 B5 A3 BA 64 00 00 00 C8 00 00 00 2C 01 00 00
// 字节解析：C1 AC=“连”、D0 F8=“续”、D6 B5=“值”、A3 BA=“：”（文本8字节）；64 00 00 00=整型100、C8 00 00 00=整型200、2C 01 00 00=整型300（连续整型12字节），总大小=8+12=20字节

复制代码

// 示例2：添加多个整型到指定位置（位置3，匹配实际输出）
// 炫语言：定义字节集，用于存储文本与连续整型组合数据
字节集连续整型集2
// 炫语言：添加ANSI文本"123"（ASCII编码，3字节，不补终止符）
连续整型集2.添加文本A(A"123", 假)
// 炫语言：调试输出添加文本后状态
调试输出("添加“123”后字节集大小：" + 到文本(连续整型集2.取大小()) + "字节")
调试输出("添加“123”后十六进制内容：")
调试输出十六进制((常量字符型A*)连续整型集2.取地址(), 连续整型集2.取大小())
// 炫语言：在位置3插入2个整型{456,789}（各4字节，小端存储）
连续整型集2.添加整型连续({456, 789}, 3)
// 炫语言：调试输出插入后总大小与完整内容
调试输出("在位置3插入整型456+789后字节集总大小：" + 到文本(连续整型集2.取大小()) + "字节")
调试输出("插入后完整十六进制内容：")
调试输出十六进制((常量字符型A*)连续整型集2.取地址(), 连续整型集2.取大小())
// 输出结果：
// 添加“123”后字节集大小：3字节
// 添加“123”后十六进制内容：31 32 33
// 在位置3插入整型456+789后字节集总大小：11字节
// 插入后完整十六进制内容：31 32 33 C8 01 00 00 15 03 00 00
// 字节解析：31=“1”、32=“2”、33=“3”（初始文本3字节）；C8 01 00 00=整型456、15 03 00 00=整型789（连续整型8字节，插入于“123”后），总大小=3+8=11字节

复制代码

--
10.添加正整形

// 示例1：添加正整型到末尾（默认位置-1，匹配实际输出）
// 炫语言：定义字节集，用于存储ANSI文本与正整型组合数据
字节集正整型集1
// 炫语言：添加ANSI-GBK文本"正整数："（"正"=0xD5FD、"整"=0xD5FB、"数"=0xCAFD、"："=0xA3BA，共8字节，不补终止符）
正整型集1.添加文本A(A"正整数：", 假)
// 炫语言：在字节集末尾添加正整型1234（占4字节，小端存储）
正整型集1.添加正整型(1234)
// 炫语言：普通调试输出（匹配实际总大小）
调试输出("字节集：文本“正整数：”+正整型1234，总大小" + 到文本(正整型集1.取大小()) + "字节")
// 炫语言：十六进制输出（匹配实际存储的字节内容）
调试输出("字节集十六进制内容：")
调试输出十六进制((常量字符型A*)正整型集1.取地址(), 正整型集1.取大小())
// 输出结果：
// 字节集：文本“正整数：”+正整型1234，总大小12字节
// 字节集十六进制内容：D5 FD D5 FB CA FD A3 BA D2 04 00 00
// 字节解析：D5 FD=“正”、D5 FB=“整”、CA FD=“数”、A3 BA=“：”（文本8字节）；D2 04 00 00=正整型1234（小端存储，4字节），总大小=8+4=12字节

复制代码

// 示例2：添加正整型到指定位置（位置2，结合文档存储规则验证）
// 炫语言：定义字节集，用于存储ANSI文本与指定位置插入正整型的组合数据
字节集正整型集2
// 炫语言：添加ANSI-ASCII文本“AB”（"A"=0x41、"B"=0x42，共2字节，不补终止符）
正整型集2.添加文本A(A"AB", 假)
// 炫语言：在位置2（“AB”之后）插入正整型123456（4字节，小端存储：123456转十六进制0x1E240，小端顺序40 E2 01 00）
正整型集2.添加正整型(123456, 2)
// 炫语言：普通调试输出（按“文本字节数+正整型字节数”计算总大小）
调试输出("字节集：ANSI文本“AB”后插正整型123456，总大小" + 到文本(正整型集2.取大小()) + "字节")
// 炫语言：十六进制输出（匹配ASCII编码与小端存储规则）
调试输出("字节集十六进制内容：")
调试输出十六进制((常量字符型A*)正整型集2.取地址(), 正整型集2.取大小())
// 输出结果：
// 字节集：ANSI文本“AB”后插正整型123456，总大小6字节
// 字节集十六进制内容：41 42 40 E2 01 00
// 字节解析：41=“A”、42=“B”（ANSI文本2字节）；40 E2 01 00=正整型123456（小端存储4字节，插入于“AB”后），总大小=2+4=6字节

复制代码

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

[模块] 基础模块-字节集示例1-10