基础模块-动态数组示例1-15

qq1073176068 · 发表于 2025-9-29 14:10:17

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

1.取首

// 1. 定义整型动态数组（变量名：arr，2个字母，符合2-5个字母要求）
动态数组<整型> arr
// 2. 向动态数组添加元素（模拟实际数据存储）
arr.添加(10)
arr.添加(20)
arr.添加(30)
// 3. 调用取首()方法，获取数组第一个成员
整型 firstVal = arr.取首()
// 4. 调试输出结果，验证取首功能
调试输出("整型动态数组内容：10, 20, 30")
调试输出("调用取首()获取的第一个成员：" + 到文本(firstVal))
// 输出结果：
// 整型动态数组内容：10, 20, 30
// 调用取首()获取的第一个成员：10

复制代码

// 1. 定义文本型动态数组（变量名：txtArr，5个字母，符合要求）
动态数组<文本型> txtArr
// 2. 向数组添加文本元素
txtArr.添加("Hello")
txtArr.添加("XuanYuYan")
txtArr.添加("Test")
// 3. 调用取首()方法，获取首个文本成员
文本型 firstTxt = txtArr.取首()
// 4. 调试输出结果
调试输出("文本型动态数组内容：Hello, XuanYuYan, Test")
调试输出("调用取首()获取的第一个成员：" + firstTxt)
// 输出结果：
// 文本型动态数组内容：Hello, XuanYuYan, Test
// 调用取首()获取的第一个成员：Hello

复制代码

// 1. 定义空的浮点型动态数组（变量名：fltArr，5个字母）
动态数组<浮点型> fltArr
// 2. 先判断数组是否为空，避免取首时的异常
如果 (fltArr.是否为空() == 1) // 1表示真（空）
{
调试输出("浮点型动态数组为空，无法调用取首()获取成员")
}
否则
{
浮点型 firstFlt = fltArr.取首()
调试输出("数组第一个浮点成员：" + 到文本(firstFlt))
}
// 输出结果：
// 浮点型动态数组为空，无法调用取首()获取成员

复制代码

--
2.取尾

// 1. 定义整型动态数组（变量名：intArr，5个字母，符合2-5个字母要求）
动态数组<整型> intArr
// 2. 向数组添加整型元素（模拟业务数据）
intArr.添加(5)
intArr.添加(15)
intArr.添加(25)
intArr.添加(35)
// 3. 调用取尾()方法，获取数组末尾成员
整型 lastInt = intArr.取尾()
// 4. 调试输出验证结果
调试输出("整型动态数组元素：5, 15, 25, 35")
调试输出("调用取尾()获取的末尾成员：" + 到文本(lastInt))
// 输出结果：
// 整型动态数组元素：5, 15, 25, 35
// 调用取尾()获取的末尾成员：35

复制代码

// 1. 定义文本型动态数组（变量名：strArr，5个字母）
动态数组<文本型> strArr
// 2. 向数组添加文本元素（如日志信息）
strArr.添加("日志1：启动成功")
strArr.添加("日志2：加载配置")
strArr.添加("日志3：执行完成")
// 3. 调用取尾()方法，获取最后一条日志
文本型 lastStr = strArr.取尾()
// 4. 调试输出结果
调试输出("文本型动态数组（日志）：日志1：启动成功, 日志2：加载配置, 日志3：执行完成")
调试输出("调用取尾()获取的末尾日志：" + lastStr)
// 输出结果：
// 文本型动态数组（日志）：日志1：启动成功, 日志2：加载配置, 日志3：执行完成
// 调用取尾()获取的末尾日志：日志3：执行完成

复制代码

// 1. 定义浮点型动态数组（变量名：fltArr，5个字母）
动态数组<浮点型> fltArr
// 2. 先添加1个元素（模拟单元素数组场景）
fltArr.添加(3.14159)
// 3. 调用取尾()获取唯一元素（同时也是末尾元素）
浮点型 lastFlt = fltArr.取尾()
调试输出("单元素浮点型数组：[3.14159]")
调试输出("调用取尾()获取的末尾成员：" + 到文本(lastFlt))
// 4. 清空数组，验证空数组取尾逻辑
fltArr.清空()
如果 (fltArr.是否为空() == 1)
{
调试输出("浮点型数组已清空，无法调用取尾()获取成员")
}
// 输出结果：
// 单元素浮点型数组：[3.14159]
// 调用取尾()获取的末尾成员：3.14159
// 浮点型数组已清空，无法调用取尾()获取成员

复制代码

--
3.置大小

// 1. 定义整型动态数组（变量名：intArr，符合2-5个字母要求）
动态数组<整型> intArr
// 2. 向数组添加初始元素（共5个成员）
intArr.添加(10)
intArr.添加(20)
intArr.添加(30)
intArr.添加(40)
intArr.添加(50)
// 3. 输出置大小前的数组状态（循环遍历打印所有元素）
调试输出("置大小前 - 整型数组元素：")
变量循环 (整型 i=0; i<intArr.取大小(); i++)
{
如果 (i == intArr.取大小() - 1)
{
调试输出(到文本(intArr.取成员(i))) // 最后一个元素不打印逗号
}
否则
{
调试输出(到文本(intArr.取成员(i)) + ", ")
}
}
调试输出("置大小前 - 数组成员数量：" + 到文本(intArr.取大小()))
// 置大小前 - 整型数组元素：
// 10,
// 20,
// 30,
// 40,
// 50
// 置大小前 - 数组成员数量：5
// 4. 调用置大小()，将成员数量设为3（超出的后2个元素被截断）
intArr.置大小(3)
// 5. 输出置大小后的结果，验证截断效果
调试输出("置大小后（数量=3） - 数组成员数量：" + 到文本(intArr.取大小()))
调试输出("置大小后 - 数组前3个元素（原有数据不变）：" + 到文本(intArr.取首()) + ", " + 到文本(intArr.取成员(1)) + ", " + 到文本(intArr.取尾()))
// 置大小后（数量=3） - 数组成员数量：3
// 置大小后 - 数组前3个元素（原有数据不变）：10, 20, 30

复制代码

// 1. 定义文本型动态数组（变量名：strArr，符合2-5字母要求）
动态数组<文本型> strArr
// 2. 添加初始元素（2个成员）
strArr.添加("Hello")
strArr.添加("XuanYuYan")
// 3. 打印置大小前状态（C++风格：变量单独声明，分步输出）
整型 preSize = strArr.取大小()
文本型 preElem0 = strArr.取成员(0)
调试输出("置大小前 - 元素数量：")
调试输出(到文本(preSize))
调试输出("置大小前 - 第1个元素：")
调试输出(preElem0)
// 置大小前 - 元素数量：
// 2
// 置大小前 - 第1个元素：
// Hello
// 4. 调用置大小()扩容到5个成员
strArr.置大小(5)
// 5. 打印置大小后状态（C++风格：先判断逻辑，再输出结果）
整型 afterSize = strArr.取大小()
文本型 afterElem1 = strArr.取成员(1)
文本型 newElem2 = strArr.取成员(2)
逻辑型 isEmpty = (newElem2.取大小() == 0)
调试输出("置大小后 - 元素数量：")
调试输出(到文本(afterSize))
调试输出("置大小后 - 原有第2个元素：")
调试输出(afterElem1)
调试输出("置大小后 - 新增元素（索引2）是否为空：")
调试输出(到文本(isEmpty))
// 置大小后 - 元素数量：
// 5
// 置大小后 - 原有第2个元素：
// XuanYuYan
// 置大小后 - 新增元素（索引2）是否为空：
// 1（真）

复制代码

--
4.取大小

// 1. 定义整型动态数组（变量名：intArr，符合2-5字母要求）
动态数组<整型> intArr
// 2. 向数组添加元素
intArr.添加(10)
intArr.添加(20)
intArr.添加(30)
// 3. 调用取大小()获取成员数量，分步存储与输出（C++风格）
整型 arrSize = intArr.取大小()
调试输出("数组初始成员数量：")
调试输出(到文本(arrSize))
// 数组初始成员数量：
// 3
// 4. 新增元素后，再次调用取大小()
intArr.添加(40)
整型 newArrSize = intArr.取大小()
调试输出("新增元素后成员数量：")
调试输出(到文本(newArrSize))
// 新增元素后成员数量：
// 4
// 5. 调用置大小()截断数组，验证取大小()返回结果
intArr.置大小(2)
整型 finalSize = intArr.取大小()
调试输出("截断后最终成员数量：")
调试输出(到文本(finalSize))
// 截断后最终成员数量：
// 2

复制代码

--
5.添加

// 1. 定义整型动态数组（变量名：intArr，符合2-5字母要求）
动态数组<整型> intArr
// 2. 调用add()添加单个整型成员，分步输出（C++风格）
intArr.添加(10)
整型 size1 = intArr.取大小()
调试输出("添加10后，成员数量：")
调试输出(到文本(size1))
调试输出("当前数组第1个成员：")
调试输出(到文本(intArr.取成员(0)))
// 添加10后，成员数量：
// 1
// 当前数组第1个成员：
// 10
// 3. 连续添加多个成员，验证批量添加逻辑
intArr.添加(20)
intArr.添加(30)
整型 size2 = intArr.取大小()
调试输出("连续添加20、30后，成员数量：")
调试输出(到文本(size2))
调试输出("当前数组最后1个成员（取尾）：")
调试输出(到文本(intArr.取尾()))
// 连续添加20、30后，成员数量：
// 3
// 当前数组最后1个成员（取尾）：
// 30
// 4. 定义文本型动态数组，验证不同类型成员添加
动态数组<文本型> strArr
strArr.添加("XuanYuYan")
文本型 elem = strArr.取成员(0)
调试输出("文本数组添加成员后，内容：")
调试输出(elem)
// 文本数组添加成员后，内容：
// XuanYuYan

复制代码

--
6.插入

// 1. 定义整型动态数组（变量名：intArr，符合2-5字母要求）
动态数组<整型> intArr
// 2. 先添加初始成员，建立基础数据
intArr.添加(10)
intArr.添加(30)
整型 initSize = intArr.取大小()
调试输出("初始数组成员数量：")
调试输出(到文本(initSize))
调试输出("初始数组第2个成员（索引1）：")
调试输出(到文本(intArr.取成员(1)))
// 初始数组成员数量：
// 2
// 初始数组第2个成员（索引1）：
// 30
// 3. 调用insert()，在索引1位置插入20（C++风格：先声明插入值，再调用方法）
整型 insertVal = 20
intArr.插入(1, insertVal)
// 插入后验证：数量增加1，插入位置值正确
整型 afterInsSize = intArr.取大小()
整型 insElem = intArr.取成员(1)
调试输出("插入20后成员数量：")
调试输出(到文本(afterInsSize))
调试输出("索引1位置的成员（插入值）：")
调试输出(到文本(insElem))
// 插入20后成员数量：
// 3
// 索引1位置的成员（插入值）：
// 20
// 4. 文本型数组验证：在开头（索引0）插入内容
动态数组<文本型> strArr
strArr.添加("World")
文本型 strVal = "Hello "
strArr.插入(0, strVal)
// 验证插入结果
文本型 firstElem = strArr.取成员(0)
调试输出("文本数组插入后第1个成员：")
调试输出(firstElem)
// 文本数组插入后第1个成员：
// Hello

复制代码

--
7.弹出

// 1. 定义整型动态数组（变量名：intArr，符合2-5字母要求）
动态数组<整型> intArr
// 2. 添加初始成员（3个元素：10、20、30）
intArr.添加(10)
intArr.添加(20)
intArr.添加(30)
// 输出初始状态
整型 initSize = intArr.取大小()
整型 initLast = intArr.取尾()
调试输出("初始数组 - 成员数量：")
调试输出(到文本(initSize))
调试输出("初始数组 - 末尾成员：")
调试输出(到文本(initLast))
// 初始数组 - 成员数量：
// 3
// 初始数组 - 末尾成员：
// 30
// 3. 调用弹出()，移除末尾成员（30）
intArr.弹出()
// 输出弹出后状态
整型 afterPopSize1 = intArr.取大小()
整型 afterPopLast1 = intArr.取尾()
调试输出("弹出1次后 - 成员数量：")
调试输出(到文本(afterPopSize1))
调试输出("弹出1次后 - 新末尾成员：")
调试输出(到文本(afterPopLast1))
// 弹出1次后 - 成员数量：
// 2
// 弹出1次后 - 新末尾成员：
// 20
// 4. 再次调用弹出()，继续移除末尾成员（20）
intArr.弹出()
// 输出最终状态
整型 finalSize = intArr.取大小()
整型 finalLast = intArr.取尾()
调试输出("弹出2次后 - 成员数量：")
调试输出(到文本(finalSize))
调试输出("弹出2次后 - 最终末尾成员：")
调试输出(到文本(finalLast))
// 弹出2次后 - 成员数量：
// 1
// 弹出2次后 - 最终末尾成员：
// 10

复制代码

--
8.取数据

// 1. 定义整型动态数组（变量名：intArr，符合2-5字母要求）
动态数组<整型> intArr
// 2. 添加初始成员（3个元素：10、20、30）
intArr.添加(10)
intArr.添加(20)
intArr.添加(30)
// 输出数组基础信息
整型 arrSize = intArr.取大小()
调试输出("数组成员数量：")
调试输出(到文本(arrSize))
// 数组成员数量：
// 3
// 3. 调用取数据()，获取数组数据首地址（C++风格：匹配常量指针类型）
常量整型* dataAddr = intArr.取数据()
// 通过地址访问数组元素（模拟指针取值，验证地址有效性）
整型 firstElem = *dataAddr // 访问首元素（索引0）
整型 secondElem = *(dataAddr + 1) // 访问索引1元素
调试输出("通过数据地址访问 - 索引0元素：")
调试输出(到文本(firstElem))
调试输出("通过数据地址访问 - 索引1元素：")
调试输出(到文本(secondElem))
// 通过数据地址访问 - 索引0元素：
// 10
// 通过数据地址访问 - 索引1元素：
// 20
// 4. 文本型数组验证：获取文本数据地址
动态数组<文本型> strArr
strArr.添加("Hello")
strArr.添加("XuanYuYan")
// 取文本数组数据首地址，通过地址访问末尾元素
常量文本型* strDataAddr = strArr.取数据()
文本型 lastStr = *(strDataAddr + 1) // 访问索引1元素
调试输出("文本数组通过地址访问 - 索引1元素：")
调试输出(lastStr)
// 文本数组通过地址访问 - 索引1元素：
// XuanYuYan

复制代码

--
9.取成员

// 1. 定义整型动态数组（变量名：intArr，符合2-5字母要求）
动态数组<整型> intArr
// 2. 添加初始成员（4个元素：5、15、25、35）
intArr.添加(5)
intArr.添加(15)
intArr.添加(25)
intArr.添加(35)
// 输出数组总成员数，明确索引范围
整型 arrSize = intArr.取大小()
调试输出("数组成员总数：")
调试输出(到文本(arrSize))
// 数组成员总数：
// 4
// 3. 调用取成员()，获取指定索引成员（C++风格：先声明接收变量，再取值）
// 取索引1的成员（15）
整型 elem1 = intArr.取成员(1)
调试输出("索引1对应的成员值：")
调试输出(到文本(elem1))
// 索引1对应的成员值：
// 15
// 取索引3的成员（35，末尾元素）
整型 elem3 = intArr.取成员(3)
调试输出("索引3对应的成员值（末尾）：")
调试输出(到文本(elem3))
// 索引3对应的成员值（末尾）：
// 35
// 4. 文本型数组验证：获取指定索引文本成员
动态数组<文本型> strArr
strArr.添加("炫语言")
strArr.添加("动态数组")
strArr.添加("取成员")
// 取索引2的文本成员
文本型 strElem2 = strArr.取成员(2)
调试输出("文本数组索引2对应的成员值：")
调试输出(strElem2)
// 文本数组索引2对应的成员值：
// 取成员

复制代码

--
10.置成员

// 1. 定义整型动态数组（变量名：intArr，符合2-5字母要求）
动态数组<整型> intArr
// 2. 添加初始成员（索引0：10，索引1：20，索引2：30）
intArr.添加(10)
intArr.添加(20)
intArr.添加(30)
// 3. 输出修改前索引2的值（验证初始状态）
调试输出("修改前 - 整型数组索引2的值：" + 到文本(intArr.取成员(2)))
// 4. 调用置成员()：将索引2的30修改为300
intArr.置成员(2, 300)
// 5. 输出修改后索引2的值（验证修改结果）
调试输出("修改后 - 整型数组索引2的值：" + 到文本(intArr.取成员(2)))
// 6. 验证其他索引值未被影响（索引0和1保持初始值）
调试输出("修改后 - 整型数组索引0的值：" + 到文本(intArr.取成员(0)))
调试输出("修改后 - 整型数组索引1的值：" + 到文本(intArr.取成员(1)))
// 输出结果（注释版）：
// 修改前 - 整型数组索引2的值：30 // 初始索引2值为30
// 修改后 - 整型数组索引2的值：300 // 置成员()后索引2值更新为300
// 修改后 - 整型数组索引0的值：10 // 未修改的索引0保持10
// 修改后 - 整型数组索引1的值：20 // 未修改的索引1保持20

复制代码

// 1. 定义文本型动态数组（变量名：txtArr）
动态数组<文本型> txtArr
// 2. 添加初始文本成员（索引0："Hello"，索引1："Test"）
txtArr.添加("Hello")
txtArr.添加("Test")
// 3. 输出修改前索引1的值（验证初始状态）
调试输出("修改前 - 文本数组索引1的值：" + txtArr.取成员(1))
// 4. 调用置成员()：将索引1的"Test"修改为"XuanYuYan"
txtArr.置成员(1, "XuanYuYan")
// 5. 输出修改后索引1的值（验证修改结果）
调试输出("修改后 - 文本数组索引1的值：" + txtArr.取成员(1))
// 输出结果（注释版）：
// 修改前 - 文本数组索引1的值：Test // 初始索引1值为"Test"
// 修改后 - 文本数组索引1的值：XuanYuYan // 置成员()后索引1值更新为"XuanYuYan"

复制代码

--
11.交换

方法不对！报错，暂时没有研究出来。
--

12.是否为空
// 1. 定义空整型动态数组（未添加任何成员）
动态数组<整型> emptyIntArr
// 定义非空整型动态数组（添加成员）
动态数组<整型> nonEmptyIntArr
nonEmptyIntArr.添加(10)
nonEmptyIntArr.添加(20)
// 2. 调用是否为空()判断状态，用逻辑型变量接收结果（1=真，0=假）
逻辑型 isEmpty1 = emptyIntArr.是否为空()
逻辑型 isEmpty2 = nonEmptyIntArr.是否为空()
// 3. 调试输出判断结果
调试输出("=== 基础场景：空数组 vs 非空数组 ===")
调试输出("空数组（未添加成员）是否为空：" + 到文本(isEmpty1) + "（1=真，0=假）")
调试输出("非空数组（含10、20）是否为空：" + 到文本(isEmpty2) + "（1=真，0=假）")
调试输出("非空数组当前成员数：" + 到文本(nonEmptyIntArr.取大小()))
// 输出结果：
// === 基础场景：空数组 vs 非空数组 ===
// 空数组（未添加成员）是否为空：1（1=真，0=假）
// 非空数组（含10、20）是否为空：0（1=真，0=假）
// 非空数组当前成员数：2

复制代码

// 1. 定义文本型动态数组（存储用户输入）
动态数组<文本型> userInputArr
// 2. 初始判断（数组为空）
调试输出("=== 业务场景：动态判断数组状态 ===")
调试输出("初始状态 - 数组是否为空：" + 到文本(userInputArr.是否为空()))
// 3. 模拟添加用户输入（数组变为非空）
userInputArr.添加("用户名：admin")
userInputArr.添加("密码：123456")
调试输出("添加2条输入后 - 数组是否为空：" + 到文本(userInputArr.是否为空()))
调试输出("当前输入条数：" + 到文本(userInputArr.取大小()))
// 4. 模拟清空输入（数组恢复为空）
userInputArr.清空()
调试输出("清空输入后 - 数组是否为空：" + 到文本(userInputArr.是否为空()))
调试输出("清空后输入条数：" + 到文本(userInputArr.取大小()))
// 输出结果：
// === 业务场景：动态判断数组状态 ===
// 初始状态 - 数组是否为空：1
// 添加2条输入后 - 数组是否为空：0
// 当前输入条数：2
// 清空输入后 - 数组是否为空：1
// 清空后输入条数：0

复制代码

// 1. 定义浮点型动态数组（模拟传感器数据存储，浮点型存在精度偏差）
动态数组<浮点型> sensorDataArr
// 2. 模拟传感器未采集到数据（数组为空），先判断再操作（避免取首()异常）
调试输出("=== 安全场景：避免空数组操作异常 ===")
如果 (sensorDataArr.是否为空() == 1)
{
调试输出("传感器未采集到数据，无法执行【取首()】操作（避免异常）")
}
否则
{
浮点型 firstData = sensorDataArr.取首()
调试输出("传感器第一条数据：" + 到文本(firstData))
}
// 3. 模拟传感器采集到数据（添加浮点值23.8，因浮点精度存储为23.799999）
sensorDataArr.添加(23.8) // 存储后实际为23.799999（浮点型精度特性）
sensorDataArr.添加(24.1)
sensorDataArr.添加(23.9)
// 4. 数组非空时，安全执行取首()/取尾()操作
如果 (sensorDataArr.是否为空() == 0)
{
浮点型 firstData = sensorDataArr.取首() // 读取到23.799999
浮点型 lastData = sensorDataArr.取尾() // 读取到23.9
调试输出("传感器数据采集完成，共" + 到文本(sensorDataArr.取大小()) + "条")
调试输出("第一条数据：" + 到文本(firstData) + "℃，最后一条数据：" + 到文本(lastData) + "℃")
}
// 输出结果（匹配实际浮点精度）：
// === 安全场景：避免空数组操作异常 ===
// 传感器未采集到数据，无法执行【取首()】操作（避免异常）
// 传感器数据采集完成，共3条
// 第一条数据：23.799999℃，最后一条数据：23.9℃

复制代码

// 1. 定义整型动态数组（存储待处理任务ID）
动态数组<整型> taskIdArr
taskIdArr.添加(1001)
taskIdArr.添加(1002)
taskIdArr.添加(1003)
// 2. 循环处理任务：判断数组非空则继续处理（每次弹出末尾任务）
调试输出("=== 循环场景：判断状态控制循环 ===")
调试输出("初始待处理任务数：" + 到文本(taskIdArr.取大小()))
循环判断首
{
// 处理当前末尾任务
整型 currentTask = taskIdArr.取尾()
调试输出("正在处理任务ID：" + 到文本(currentTask))
// 移除已处理任务
taskIdArr.弹出()
// 检查是否还有未处理任务（结合是否为空()判断）
如果 (taskIdArr.是否为空() == 1)
{
调试输出("所有任务处理完成，退出循环")
跳出 // 数组为空时退出循环
}
}
循环判断尾 (真) // 先执行循环体，再通过内部判断退出
// 输出结果：
// === 循环场景：判断状态控制循环 ===
// 初始待处理任务数：3
// 正在处理任务ID：1003
// 正在处理任务ID：1002
// 正在处理任务ID：1001
// 所有任务处理完成，退出循环

复制代码

--
13.删除

// 1. 定义整型动态数组（存储待处理任务ID）
动态数组<整型> taskIdArr
taskIdArr.添加(1001)
taskIdArr.添加(1002)
taskIdArr.添加(1003)
// 2. 循环处理任务：判断数组非空则继续，处理后删除当前任务
调试输出("=== 循环场景：判断状态控制循环 ===")
调试输出("初始待处理任务数：" + 到文本(taskIdArr.取大小()))
循环判断首
{
// 处理当前末尾任务（取尾获取最新任务）
整型 currentTask = taskIdArr.取尾()
调试输出("正在处理任务ID：" + 到文本(currentTask))
// 调用删除()：删除末尾任务（位置索引=数组大小-1，默认删除1个）
taskIdArr.删除(taskIdArr.取大小() - 1)
// 数组为空时退出循环
如果 (taskIdArr.是否为空() == 1)
{
调试输出("所有任务处理完成，退出循环")
跳出
}
}
循环判断尾 (taskIdArr.是否为空() == 0)
// 输出结果：
// === 循环场景：判断状态控制循环 ===
// 初始待处理任务数：3
// 正在处理任务ID：1003
// 正在处理任务ID：1002
// 正在处理任务ID：1001
// 所有任务处理完成，退出循环

复制代码

// 补充示例：文本数组批量删除（指定删除数量）
// 1. 定义文本动态数组并添加元素
动态数组<文本型> fruitArr
fruitArr.添加("苹果")
fruitArr.添加("香蕉")
fruitArr.添加("橙子")
fruitArr.添加("葡萄")
fruitArr.添加("芒果")
// 2. 调用删除()：从索引1开始，删除3个元素（香蕉、橙子、葡萄）
fruitArr.删除(1, 3)
// 3. 输出结果
调试输出("批量删除后数组大小：" + 到文本(fruitArr.取大小())) // 输出：批量删除后数组大小：2
调试输出("剩余元素1：" + fruitArr.取成员(0)) // 输出：剩余元素1：苹果
调试输出("剩余元素2：" + fruitArr.取成员(1)) // 输出：剩余元素2：芒果

复制代码

--
14.删除范围

// 1. 定义整型动态数组并添加初始元素（与 C++ vector 初始化 {10,20,30,40,50} 一致）
动态数组<整型> intArr
intArr.添加(10)
intArr.添加(20)
intArr.添加(30)
intArr.添加(40)
intArr.添加(50)
// 2. 输出删除范围前的数组状态（与 C++ 输出删除前 vector 状态一致）
调试输出("删除范围前 - 整型数组大小：" + 到文本(intArr.取大小()))
调试输出("删除范围前 - 数组元素：")
变量循环 (整型 i=0; i<intArr.取大小(); i++)
{
调试输出("intArr[" + 到文本(i) + "] = " + 到文本(intArr.取成员(i)))
}
// 3. 调用删除范围(erase2())，遵循 C++ 左闭右开区间逻辑：
// 参数1=起始索引1（对应 C++ begin()+1），参数2=结束索引2（对应 C++ begin()+3）
// 实际删除区间 [1, 3) → 包含索引1（20）、不包含索引3（40），即删除20、30
intArr.删除范围(1, 3)
// 4. 输出删除范围后的数组状态（与 C++ 输出删除后 vector 状态逻辑一致：
// 原索引3（40）、4（50）前移，最终大小=5-2=3）
调试输出("\n删除范围后（删除索引1-3） - 整型数组大小：" + 到文本(intArr.取大小()))
调试输出("删除范围后 - 剩余数组元素：")
变量循环 (整型 i=0; i<intArr.取大小(); i++)
{
调试输出("intArr[" + 到文本(i) + "] = " + 到文本(intArr.取成员(i)))
}
// 输出结果（与你提供的实际输出完全一致，验证逻辑一致性）：
// 删除范围前 - 整型数组大小：5
// 删除范围前 - 数组元素：
// intArr[0] = 10
// intArr[1] = 20
// intArr[2] = 30
// intArr[3] = 40
// intArr[4] = 50
//
// 删除范围后（删除索引1-3） - 整型数组大小：3
// 删除范围后 - 剩余数组元素：
// intArr[0] = 10
// intArr[1] = 40
// intArr[2] = 50

复制代码

--
15.清空

// 1. 定义整型动态数组并添加业务数据（模拟存储待处理任务ID）
动态数组<整型> taskIds
taskIds.添加(1001)
taskIds.添加(1002)
taskIds.添加(1003)
taskIds.添加(1004)
// 2. 输出清空前数组状态（展示初始数据与大小，1=空，0=非空）
调试输出("清空前 - 整型动态数组（任务ID列表）状态：")
调试输出("数组大小：" + 到文本(taskIds.取大小()) + "（当前存储的任务ID数量）")
调试输出("数组是否为空：" + 到文本(taskIds.是否为空()) + "（1=空，0=非空）")
调试输出("数组末尾任务ID：" + 到文本(taskIds.取尾()) + "（当前最后一条任务ID）")
// 3. 调用清空(clear())方法，删除数组所有元素，释放对应内存（与C++ std::vector::clear()逻辑一致）
taskIds.清空()
// 4. 输出清空后数组状态（验证清空效果，确认元素已全部删除）
调试输出("\n清空后 - 整型动态数组（任务ID列表）状态：")
调试输出("数组大小：" + 到文本(taskIds.取大小()) + "（清空后无任何元素）")
调试输出("数组是否为空：" + 到文本(taskIds.是否为空()) + "（1=空，0=非空）")
// 5. 验证空数组安全操作（清空后数组无元素，调用取首/取尾会触发异常，需先判断是否为空）
如果 (taskIds.是否为空() == 1)
{
调试输出("安全提示：数组已清空，不可调用取首()/取尾()等访问元素的方法")
}
// 输出结果：
// 清空前 - 整型动态数组（任务ID列表）状态：
// 数组大小：4（当前存储的任务ID数量）
// 数组是否为空：0（1=空，0=非空）
// 数组末尾任务ID：1004（当前最后一条任务ID）
//
// 清空后 - 整型动态数组（任务ID列表）状态：
// 数组大小：0（清空后无任何元素）
// 数组是否为空：1（1=空，0=非空）
// 安全提示：数组已清空，不可调用取首()/取尾()等访问元素的方法

复制代码

--

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

[模块] 基础模块-动态数组示例1-15

浏览过的版块