基础模块-字节集示例31-40

qq1073176068 · 发表于 2025-9-28 08:31:46

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

31.取地址

// 示例：获取字节集数据地址
// 炫语言：定义字节集并添加数据
字节集数据集
数据集.添加文本A(A"Hello", 假)
// 炫语言：获取字节集数据地址
常量字节型* 数据地址 = 数据集.取地址()
// 炫语言：通过地址直接访问和输出数据
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制(数据地址, 数据集.取大小())
// 输出结果：
// 字节集大小：5字节
// 十六进制内容：48 65 6C 6C 6F
// 字节解析：48='H'、65='e'、6C='l'、6C='l'、6F='o'

复制代码

// 炫语言：通过地址修改数据（需要非常量指针）
数据集.替换数据(A"World", 5, 0)
调试输出("修改后数据：")
调试输出十六进制(数据集.取地址(), 数据集.取大小())
// 输出结果：
// 修改后数据：
// 十六进制内容：57 6F 72 6C 64
// 字节解析：57='W'、6F='o'、72='r'、6C='l'、64='d'

复制代码

--
32.取文本指针

// 示例：获取字节集文本指针
// 炫语言：定义字节集并存储Unicode文本
字节集文本数据
文本数据.添加文本("Hello世界", 假)
// 炫语言：获取文本指针（默认从位置0开始）
常量字符型* 文本指针 = 文本数据.取文本指针()
// 炫语言：通过指针创建文本对象并输出
文本型文本内容 = 文本指针
调试输出("文本内容：" + 文本内容)
调试输出("字节集大小：" + 到文本(文本数据.取大小()) + "字节")
// 输出结果：
// 文本内容：Hello世界
// 字节集大小：14字节

复制代码

// 炫语言：从位置10开始获取文本指针（跳过"Hello"的10个字节，指向"世界"）
常量字符型* 部分文本指针 = 文本数据.取文本指针(10)
文本型部分文本内容 = 部分文本指针
调试输出("从位置10开始的文本：" + 部分文本内容)
// 输出结果：
// 从位置10开始的文本：世界
// 炫语言：验证十六进制存储格式
调试输出十六进制((常量字符型A*)文本数据.取地址(), 文本数据.取大小())
// 输出结果：
// 十六进制内容：48 00 65 00 6C 00 6C 00 6F 00 16 4E 4C 75
// 字节解析：48 00='H'、65 00='e'、6C 00='l'、6C 00='l'、6F 00='o'、16 4E='世'、4C 75='界'

复制代码

--
33.取文本指针A

// 示例：获取字节集ANSI文本指针
// 炫语言：定义字节集并存储ANSI文本
字节集文本数据A
文本数据A.添加文本A(A"Hello世界", 假)
// 炫语言：获取ANSI文本指针（默认从位置0开始）
常量字符型A* 文本指针A = 文本数据A.取文本指针A()
// 炫语言：通过指针创建ANSI文本对象并输出
文本型A 文本内容A = 文本指针A
调试输出("ANSI文本内容：" + A2W(文本内容A))
调试输出("字节集大小：" + 到文本(文本数据A.取大小()) + "字节")
// 输出结果：
// ANSI文本内容：Hello世界
// 字节集大小：9字节

复制代码

// 炫语言：从位置5开始获取ANSI文本指针（跳过"Hello"的5个字节，指向"世界"）
常量字符型A* 部分文本指针A = 文本数据A.取文本指针A(5)
文本型A 部分文本内容A = 部分文本指针A
调试输出("从位置5开始的ANSI文本：" + A2W(部分文本内容A))
// 输出结果：
// 从位置5开始的ANSI文本：世界
// 炫语言：验证十六进制存储格式
调试输出十六进制((常量字符型A*)文本数据A.取地址(), 文本数据A.取大小())
// 输出结果：
// 十六进制内容：48 65 6C 6C 6F CA C0 BD E7
// 字节解析：48='H'、65='e'、6C='l'、6C='l'、6F='o'、CA C0='世'、BD E7='界'（GBK编码）

复制代码

--
34.取文本

// 示例：从字节集获取指定位置和长度的文本
// 炫语言：定义字节集并存储Unicode文本
字节集文本数据
文本数据.添加文本("Hello世界ABC", 假)
// 炫语言：从位置0开始获取5个字符的文本（"Hello"）
文本型结果文本1 = 文本数据.取文本(0, 5)
调试输出("位置0，长度5的文本：" + 结果文本1)
// 输出结果：
// 位置0，长度5的文本：Hello
// 炫语言：从位置10开始获取2个字符的文本（"世界"）
文本型结果文本2 = 文本数据.取文本(10, 2)
调试输出("位置10，长度2的文本：" + 结果文本2)
// 输出结果：
// 位置10，长度2的文本：世界
// 炫语言：从位置14开始获取3个字符的文本（"ABC"）
文本型结果文本3 = 文本数据.取文本(14, 3)
调试输出("位置14，长度3的文本：" + 结果文本3)
// 输出结果：
// 位置14，长度3的文本：ABC
// 炫语言：验证完整字节集内容
调试输出("完整字节集大小：" + 到文本(文本数据.取大小()) + "字节")
调试输出十六进制((常量字符型A*)文本数据.取地址(), 文本数据.取大小())
// 输出结果：
// 完整字节集大小：20字节
// 十六进制内容：48 00 65 00 6C 00 6C 00 6F 00 16 4E 4C 75 41 00 42 00 43 00
// 字节解析：48 00='H'、65 00='e'、6C 00='l'、6C 00='l'、6F 00='o'、16 4E='世'、4C 75='界'、41 00='A'、42 00='B'、43 00='C'

复制代码

--
35.取文本A

// 示例：从字节集获取指定位置和长度的ANSI文本
// 炫语言：定义字节集并存储ANSI文本
字节集文本数据A
文本数据A.添加文本A(A"Hello世界ABC", 假)
// 炫语言：从位置0开始获取5字节的ANSI文本（"Hello"）
文本型A 结果文本A1 = 文本数据A.取文本A(0, 5)
调试输出("位置0，长度5字节的ANSI文本：" + A2W(结果文本A1))
// 输出结果：
// 位置0，长度5字节的ANSI文本：Hello
// 炫语言：从位置5开始获取4字节的ANSI文本（"世界"）
文本型A 结果文本A2 = 文本数据A.取文本A(5, 4)
调试输出("位置5，长度4字节的ANSI文本：" + A2W(结果文本A2))
// 输出结果：
// 位置5，长度4字节的ANSI文本：世界
// 炫语言：从位置9开始获取3字节的ANSI文本（"ABC"）
文本型A 结果文本A3 = 文本数据A.取文本A(9, 3)
调试输出("位置9，长度3字节的ANSI文本：" + A2W(结果文本A3))
// 输出结果：
// 位置9，长度3字节的ANSI文本：ABC
// 炫语言：验证完整字节集内容
调试输出("完整字节集大小：" + 到文本(文本数据A.取大小()) + "字节")
调试输出十六进制((常量字符型A*)文本数据A.取地址(), 文本数据A.取大小())
// 输出结果：
// 完整字节集大小：12字节
// 十六进制内容：48 65 6C 6C 6F CA C0 BD E7 41 42 43
// 字节解析：48='H'、65='e'、6C='l'、6C='l'、6F='o'、CA C0='世'、BD E7='界'、41='A'、42='B'、43='C'

复制代码

--
36.取整型

// 示例：从字节集获取整型数据
// 炫语言：定义字节集并存储整型数据
字节集数据集
数据集.添加整型(123456)
// 炫语言：从位置0获取整型数据
整型结果值 = 数据集.取整型(0)
调试输出("位置0的整型值：" + 到文本(结果值))
// 输出结果：
// 位置0的整型值：123456
// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 字节集大小：4字节
// 十六进制内容：40 E2 01 00
// 字节解析：40 E2 01 00=123456（小端存储）

复制代码

// 炫语言：存储多个整型并分别获取
字节集多数据集
多数据集.添加整型连续({100, 200, 300})
// 炫语言：分别获取不同位置的整型值
整型值1 = 多数据集.取整型(0)
整型值2 = 多数据集.取整型(4)
整型值3 = 多数据集.取整型(8)
调试输出("位置0的整型：" + 到文本(值1))
调试输出("位置4的整型：" + 到文本(值2))
调试输出("位置8的整型：" + 到文本(值3))
// 输出结果：
// 位置0的整型：100
// 位置4的整型：200
// 位置8的整型：300

复制代码

--
37.取正整型

// 示例：从字节集获取正整型数据
// 炫语言：定义字节集并存储正整型数据
字节集数据集
数据集.添加正整型(4294967295) // 最大无符号整型值
// 炫语言：从位置0获取正整型数据
正整型结果值 = 数据集.取正整型(0)
调试输出("位置0的正整型值：" + 到文本(结果值))
// 输出结果：
// 位置0的正整型值：4294967295
// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 字节集大小：4字节
// 十六进制内容：FF FF FF FF
// 字节解析：FF FF FF FF=4294967295（小端存储）

复制代码

// 炫语言：存储多个正整型并分别获取
字节集多数据集
多数据集.添加正整型连续({1000, 2000, 3000})
// 炫语言：分别获取不同位置的正整型值
正整型值1 = 多数据集.取正整型(0)
正整型值2 = 多数据集.取正整型(4)
正整型值3 = 多数据集.取正整型(8)
调试输出("位置0的正整型：" + 到文本(值1))
调试输出("位置4的正整型：" + 到文本(值2))
调试输出("位置8的正整型：" + 到文本(值3))
// 输出结果：
// 位置0的正整型：1000
// 位置4的正整型：2000
// 位置8的正整型：3000

复制代码

--
38.取长整型

// 示例：从字节集获取长整型数据
// 炫语言：定义字节集并存储长整型数据
字节集数据集
数据集.添加长整型(1234567890123)
// 炫语言：从位置0获取长整型数据
长整型结果值 = 数据集.取长整型(0)
调试输出("位置0的长整型值：" + 到文本(结果值))
// 输出结果：
// 位置0的长整型值：1234567890123
// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 字节集大小：8字节
// 十六进制内容：CB 04 FB 71 1F 01 00 00
// 字节解析：CB 04 FB 71 1F 01 00 00=1234567890123（小端存储）

复制代码

// 炫语言：存储多个长整型并分别获取
字节集多数据集
多数据集.添加长整型连续({10000000000, 20000000000, 30000000000})
// 炫语言：分别获取不同位置的长整型值
长整型值1 = 多数据集.取长整型(0)
长整型值2 = 多数据集.取长整型(8)
长整型值3 = 多数据集.取长整型(16)
调试输出("位置0的长整型：" + 到文本(值1))
调试输出("位置8的长整型：" + 到文本(值2))
调试输出("位置16的长整型：" + 到文本(值3))
// 输出结果：
// 位置0的长整型：10000000000
// 位置8的长整型：20000000000
// 位置16的长整型：30000000000

复制代码

--
39.取正长整型

// 示例：从字节集获取正长整型数据
// 炫语言：定义字节集并存储正长整型数据
字节集数据集
数据集.添加正长整型(18446744073709551615) // 最大无符号64位整型值
// 炫语言：从位置0获取正长整型数据
正长整型结果值 = 数据集.取正长整型(0)
调试输出("位置0的正长整型值：" + 到文本(结果值))
// 输出结果：
// 位置0的正长整型值：18446744073709551615
// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 字节集大小：8字节
// 十六进制内容：FF FF FF FF FF FF FF FF
// 字节解析：FF FF FF FF FF FF FF FF=18446744073709551615（小端存储）

复制代码

// 炫语言：存储多个正长整型并分别获取
字节集多数据集
多数据集.添加正长整型连续({100000000000, 200000000000, 300000000000})
// 炫语言：分别获取不同位置的正长整型值
正长整型值1 = 多数据集.取正长整型(0)
正长整型值2 = 多数据集.取正长整型(8)
正长整型值3 = 多数据集.取正长整型(16)
调试输出("位置0的正长整型：" + 到文本(值1))
调试输出("位置8的正长整型：" + 到文本(值2))
调试输出("位置16的正长整型：" + 到文本(值3))
// 输出结果：
// 位置0的正长整型：100000000000
// 位置8的正长整型：200000000000
// 位置16的正长整型：300000000000

复制代码

--
40.取短整型

// 示例：从字节集获取短整型数据
// 炫语言：定义字节集并存储短整型数据
字节集数据集
数据集.添加短整型(32767) // 最大有符号短整型值
// 炫语言：从位置0获取短整型数据
短整型结果值 = 数据集.取短整型(0)
调试输出("位置0的短整型值：" + 到文本(结果值))
// 输出结果：
// 位置0的短整型值：32767
// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 字节集大小：2字节
// 十六进制内容：FF 7F
// 字节解析：FF 7F=32767（小端存储）

复制代码

// 炫语言：存储多个短整型并分别获取
字节集多数据集
多数据集.添加短整型连续({100, 200, 300})
// 炫语言：分别获取不同位置的短整型值
短整型值1 = 多数据集.取短整型(0)
短整型值2 = 多数据集.取短整型(2)
短整型值3 = 多数据集.取短整型(4)
调试输出("位置0的短整型：" + 到文本(值1))
调试输出("位置2的短整型：" + 到文本(值2))
调试输出("位置4的短整型：" + 到文本(值3))
// 输出结果：
// 位置0的短整型：100
// 位置2的短整型：200
// 位置4的短整型：300

复制代码

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

[模块] 基础模块-字节集示例31-40