基础模块-队列类示例1-7

qq1073176068 · 发表于 2025-9-29 18:10:06

本帖最后由 qq1073176068 于 2025-9-30 16:32 编辑

1.初始化

// 1. 定义模板队列类（存储整型数据）
队列类<整型> intQueue
// 2. 调用初始化()方法，启用多线程访问保护（必须先初始化）
intQueue.初始化()
调试输出("整型队列初始化完成") // 输出结果：整型队列初始化完成
// 3. 初始化后执行“加入”操作（按“先进先出”顺序添加10、20、30，队列内顺序：10→20→30）
intQueue.加入(10)
intQueue.加入(20)
intQueue.加入(30)
// 4. 调用“取大小”验证元素数量
调试输出("整型队列元素数量：" + 到文本(intQueue.取大小())) // 输出结果：整型队列元素数量：3
// 5. 调用“弹出”移除队列首个元素（队列“先进先出”特性，首个元素10被弹出）
整型 poppedVal = intQueue.弹出()
调试输出("弹出的末尾元素：" + 到文本(poppedVal)) // 输出结果：弹出的末尾元素：10
调试输出("弹出后队列元素数量：" + 到文本(intQueue.取大小())) // 输出结果：弹出后队列元素数量：2
// 6. 调用“是否为空”判断队列状态（此时队列含20、30，非空）
调试输出("整型队列是否为空：" + 到文本(intQueue.是否为空())) // 输出结果：整型队列是否为空：0
// 7. 调用“清空”移除所有元素，再验证空状态
intQueue.清空()
调试输出("清空后队列是否为空：" + 到文本(intQueue.是否为空())) // 输出结果：清空后队列是否为空：1
// 8. 调用“释放”释放队列内存资源（不再使用时调用）
intQueue.释放()
调试输出("整型队列资源释放完成") // 输出结果：整型队列资源释放完成

复制代码

// 1. 定义模板队列类（存储文本型数据，遵循“先进先出”逻辑）
队列类<文本型> strQueue
// 2. 调用初始化()方法（必须先初始化，否则后续操作会异常）
strQueue.初始化()
调试输出("文本型队列初始化完成") // 输出结果：文本型队列初始化完成
// 3. 初始化后执行“加入”操作（按顺序添加文本元素，队列内顺序：用户登录→用户操作→用户退出）
strQueue.加入("用户登录：admin")
strQueue.加入("用户操作：修改密码")
strQueue.加入("用户退出：admin")
// 4. 调用“取大小”查看当前元素总数
调试输出("文本型队列元素数量：" + 到文本(strQueue.取大小())) // 输出结果：文本型队列元素数量：3
// 5. 第一次调用“弹出”（移除队列首个元素，即最早加入的“用户登录：admin”）
文本型 poppedStr1 = strQueue.弹出()
调试输出("第一次弹出的元素：" + poppedStr1) // 输出结果：第一次弹出的元素：用户登录：admin
// 6. 第二次调用“弹出”（移除当前队列首个元素“用户操作：修改密码”）
文本型 poppedStr2 = strQueue.弹出()
调试输出("第二次弹出的元素：" + poppedStr2) // 输出结果：第二次弹出的元素：用户操作：修改密码
// 7. 调用“是否为空”判断状态（此时队列剩余“用户退出：admin”，非空）
调试输出("两次弹出后队列是否为空：" + 到文本(strQueue.是否为空())) // 输出结果：两次弹出后队列是否为空：0
// 8. 调用“清空”移除剩余元素，再调用“释放”释放资源（不再使用队列时执行）
strQueue.清空()
strQueue.释放()
调试输出("文本型队列清空并释放完成") // 输出结果：文本型队列清空并释放完成

复制代码

--
2.释放

// 示例1：整型队列释放操作（释放≠清空，保留残留元素）
队列类<整型> intQueue
// 1. 初始化+加入+弹出（残留3个元素：30、40、50）
intQueue.初始化()
intQueue.加入(10)
intQueue.加入(20)
intQueue.加入(30)
intQueue.加入(40)
intQueue.加入(50)
intQueue.弹出() // 弹10
intQueue.弹出() // 弹20
调试输出("加入元素后 - 队列大小：" + 到文本(intQueue.取大小())) // 输出结果：加入元素后 - 队列大小：3
// 2. 释放（不删残留元素）
intQueue.释放()
调试输出("整型队列已执行释放操作") // 输出结果：整型队列已执行释放操作
调试输出("释放后尝试访问队列（验证释放效果）：") // 输出结果：释放后尝试访问队列（验证释放效果）：
// 3. 重新初始化（保留残留3个，再加6个新元素，总9个）
intQueue.初始化()
intQueue.加入(60)
intQueue.加入(70)
intQueue.加入(80)
intQueue.加入(90)
intQueue.加入(100)
intQueue.加入(110)
调试输出("重新初始化后 - 队列大小：" + 到文本(intQueue.取大小())) // 输出结果：重新初始化后 - 队列大小：9
// 4. 最终释放
intQueue.释放()
调试输出("整型队列最终释放完成") // 输出结果：整型队列最终释放完成

复制代码

// 示例2：文本型队列释放操作（释放≠清空，残留元素复用）
队列类<文本型> logQueue
// 1. 初始化+加入+弹出（残留“操作2”）
logQueue.初始化()
logQueue.加入("操作1：打开文件")
logQueue.加入("操作2：编辑内容")
logQueue.弹出() // 弹“操作1”
调试输出("文本型队列初始状态 - 大小：" + 到文本(logQueue.取大小())) // 输出结果：文本型队列初始状态 - 大小：2
// 2. 释放（不删“操作2”）
logQueue.释放()
调试输出("文本型队列释放完成（业务流程结束）") // 输出结果：文本型队列释放完成（业务流程结束）
// 3. 重新初始化（直接弹出残留的“操作2”）
调试输出("后续业务需复用队列 - 重新初始化：") // 输出结果：后续业务需复用队列 - 重新初始化：
logQueue.初始化()
调试输出("重新初始化后 - 队列元素：" + logQueue.弹出()) // 输出结果：重新初始化后 - 队列元素：操作2：编辑内容
// 4. 最终释放
logQueue.释放()
调试输出("文本型队列最终释放，资源回收完成") // 输出结果：文本型队列最终释放，资源回收完成

复制代码

--
3.加入

// 示例1：整型队列调用加入()，添加元素到末尾
队列类<整型> intQueue
// 1. 初始化队列（必须先初始化）
intQueue.初始化()
// 2. 调用加入()，向队列末尾添加整型元素
intQueue.加入(10)
intQueue.加入(20)
intQueue.加入(30)
// 3. 验证加入结果（队列大小为3，末尾元素为30）
调试输出("加入3个整型元素后 - 队列大小：" + 到文本(intQueue.取大小())) // 输出结果：加入3个整型元素后 - 队列大小：3
intQueue.弹出() // 弹首元素10
intQueue.弹出() // 弹首元素20
调试输出("弹出2个元素后，末尾残留元素：" + 到文本(intQueue.取大小())) // 输出结果：弹出2个元素后，末尾残留元素：1
// 4. 释放队列
intQueue.释放()
调试输出("整型队列释放完成") // 输出结果：整型队列释放完成

复制代码

// 示例2：文本型队列调用加入()，添加文本到末尾
队列类<文本型> strQueue
// 1. 初始化队列
strQueue.初始化()
// 2. 调用加入()，向队列末尾添加文本元素
strQueue.加入("消息1：接收数据")
strQueue.加入("消息2：处理数据")
// 3. 验证加入结果（队列大小为2，弹出首元素后残留末尾元素）
调试输出("加入2条文本后 - 队列大小：" + 到文本(strQueue.取大小())) // 输出结果：加入2条文本后 - 队列大小：2
strQueue.弹出() // 弹首元素“消息1”
调试输出("弹出首元素后，末尾残留：" + strQueue.弹出()) // 输出结果：弹出首元素后，末尾残留：消息2：处理数据
// 4. 释放队列
strQueue.释放()
调试输出("文本型队列释放完成") // 输出结果：文本型队列释放完成

复制代码

--
4.弹出

// 示例1：整型队列调用弹出()，返回并移除首个成员
队列类<整型> intQueue
// 1. 初始化+加入元素（队列顺序：5→15→25）
intQueue.初始化()
intQueue.加入(5)
intQueue.加入(15)
intQueue.加入(25)
// 2. 调用弹出()，返回首个成员并移除
整型 popVal1 = intQueue.弹出()
调试输出("第一次弹出的首个成员：" + 到文本(popVal1)) // 输出结果：第一次弹出的首个成员：5
// 3. 再次弹出，验证队列顺序
整型 popVal2 = intQueue.弹出()
调试输出("第二次弹出的首个成员：" + 到文本(popVal2)) // 输出结果：第二次弹出的首个成员：15
调试输出("弹出2次后队列大小：" + 到文本(intQueue.取大小())) // 输出结果：弹出2次后队列大小：1
// 4. 释放队列
intQueue.释放()

复制代码

// 示例2：文本型队列调用弹出()，返回并移除首个文本成员
队列类<文本型> strQueue
// 1. 初始化+加入文本（队列顺序："任务1"→"任务2"→"任务3"）
strQueue.初始化()
strQueue.加入("任务1：备份数据")
strQueue.加入("任务2：同步文件")
strQueue.加入("任务3：生成报告")
// 2. 弹出首个文本成员，接收返回值
文本型 popStr = strQueue.弹出()
调试输出("弹出的首个任务：" + popStr) // 输出结果：弹出的首个任务：任务1：备份数据
// 3. 验证剩余成员（队列首元素变为"任务2"）
调试输出("剩余任务数量：" + 到文本(strQueue.取大小())) // 输出结果：剩余任务数量：2
调试输出("当前首个任务：" + strQueue.弹出()) // 输出结果：当前首个任务：任务2：同步文件
// 4. 释放队列
strQueue.释放()

复制代码

--
5.是否为空

// 示例1：整型队列调用是否为空()，判断队列空状态
队列类<整型> intQueue
// 1. 初始化后直接判断（队列无元素，返回真）
intQueue.初始化()
调试输出("初始化后队列是否为空：" + 到文本(intQueue.是否为空())) // 输出结果：初始化后队列是否为空：1（真）
// 2. 加入元素后判断（队列有元素，返回假）
intQueue.加入(80)
intQueue.加入(90)
调试输出("加入2个整型元素后是否为空：" + 到文本(intQueue.是否为空())) // 输出结果：加入2个整型元素后是否为空：0（假）
// 3. 弹出所有元素后判断（队列空，返回真）
intQueue.弹出()
intQueue.弹出()
调试输出("弹出所有元素后是否为空：" + 到文本(intQueue.是否为空())) // 输出结果：弹出所有元素后是否为空：1（真）
// 4. 释放队列
intQueue.释放()

复制代码

// 示例2：文本型队列调用是否为空()，结合业务逻辑判断
队列类<文本型> logQueue
// 1. 初始化+加入日志（非空，返回假）
logQueue.初始化()
logQueue.加入("日志1：系统启动")
调试输出("加入1条日志后是否为空：" + 到文本(logQueue.是否为空())) // 输出结果：加入1条日志后是否为空：0（假）
// 2. 弹出日志后判断（空，返回真）
logQueue.弹出()
调试输出("弹出日志后是否为空：" + 到文本(logQueue.是否为空())) // 输出结果：弹出日志后是否为空：1（真）
// 3. 复用队列：加入新日志后再次判断（非空，返回假）
logQueue.加入("日志2：用户登录")
调试输出("重新加入日志后是否为空：" + 到文本(logQueue.是否为空())) // 输出结果：重新加入日志后是否为空：0（假）
// 4. 释放队列
logQueue.释放()

复制代码

--
6.清空

// 示例1：整型队列调用清空()，删除所有成员
队列类<整型> intQueue
// 1. 初始化+加入元素（队列含3个元素：100、200、300）
intQueue.初始化()
intQueue.加入(100)
intQueue.加入(200)
intQueue.加入(300)
调试输出("清空前队列大小：" + 到文本(intQueue.取大小())) // 输出结果：清空前队列大小：3
// 2. 调用清空()，删除所有整型成员
intQueue.清空()
// 3. 验证清空效果（队列空，大小为0）
调试输出("清空后队列是否为空：" + 到文本(intQueue.是否为空())) // 输出结果：清空后队列是否为空：1（真）
调试输出("清空后队列大小：" + 到文本(intQueue.取大小())) // 输出结果：清空后队列大小：0
// 4. 清空后可重新加入元素
intQueue.加入(400)
调试输出("重新加入元素后大小：" + 到文本(intQueue.取大小())) // 输出结果：重新加入元素后大小：1
intQueue.释放()

复制代码

// 示例2：文本型队列调用清空()，删除所有文本成员
队列类<文本型> strQueue
// 1. 初始化+加入文本（队列含2条消息："通知1"、"通知2"）
strQueue.初始化()
strQueue.加入("通知1：版本更新")
strQueue.加入("通知2：数据备份")
调试输出("清空前队列大小：" + 到文本(strQueue.取大小())) // 输出结果：清空前队列大小：2
// 2. 调用清空()，删除所有文本成员
strQueue.清空()
// 3. 验证清空效果（无残留元素）
调试输出("清空后是否为空：" + 到文本(strQueue.是否为空())) // 输出结果：清空后是否为空：1（真）
// 4. 释放队列
strQueue.释放()

复制代码

--
7.取大小

// 示例1：整型队列调用取大小()，获取成员数量
队列类<整型> intQueue
// 1. 初始化后取大小（队列空，大小为0）
intQueue.初始化()
调试输出("初始化后队列大小：" + 到文本(intQueue.取大小())) // 输出结果：初始化后队列大小：0
// 2. 加入元素后取大小（添加3个整型元素，大小为3）
intQueue.加入(15)
intQueue.加入(25)
intQueue.加入(35)
调试输出("加入3个元素后大小：" + 到文本(intQueue.取大小())) // 输出结果：加入3个元素后大小：3
// 3. 弹出元素后取大小（移除1个元素，大小为2）
intQueue.弹出()
调试输出("弹出1个元素后大小：" + 到文本(intQueue.取大小())) // 输出结果：弹出1个元素后大小：2
// 4. 清空后取大小（删除所有元素，大小为0）
intQueue.清空()
调试输出("清空后队列大小：" + 到文本(intQueue.取大小())) // 输出结果：清空后队列大小：0
intQueue.释放()

复制代码

// 示例2：文本型队列调用取大小()，结合业务场景获取数量
队列类<文本型> taskQueue
// 1. 初始化+加入任务（添加2条任务，大小为2）
taskQueue.初始化()
taskQueue.加入("任务1：整理文档")
taskQueue.加入("任务2：发送邮件")
调试输出("初始任务数量：" + 到文本(taskQueue.取大小())) // 输出结果：初始任务数量：2
// 2. 处理任务（弹出1条，剩余1条）
taskQueue.弹出()
调试输出("处理1条任务后剩余数量：" + 到文本(taskQueue.取大小())) // 输出结果：处理1条任务后剩余数量：1
// 3. 补充任务后取大小（新增2条，总大小3）
taskQueue.加入("任务3：会议准备")
taskQueue.加入("任务4：数据统计")
调试输出("补充任务后总数量：" + 到文本(taskQueue.取大小())) // 输出结果：补充任务后总数量：3
taskQueue.释放()

复制代码

--

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

[模块] 基础模块-队列类示例1-7