字符串扩展
数值解析、替换、填充、分割——对标 C++ std::string 的解析能力。
导入写法CN
导入 字符串扩展::{字符串转整数, 替换, 分割};数值解析
三个解析函数把字符串转为数值,失败(空串/非法字符)返回 错误(6)(无效参数)。解析按 UTF-8 字节进行。
解析.cnCN
导入 字符串扩展::{字符串转整数, 字符串转浮点, 字符串转布尔};
函数 主() -> 整32 {
结果<整64, 整32> 整值 = 字符串转整数("12345");
如果 (整值.正常) { 打印(整值.值); } 否则 { 打印("解析失败"); } // 12345
结果<浮64, 整32> 浮值 = 字符串转浮点("3.5");
如果 (浮值.正常) { 打印(浮值.值); } 否则 { 打印("解析失败"); } // 3.5
结果<布尔, 整32> 布值 = 字符串转布尔("真");
如果 (布值.正常) { 打印(布值.值); } 否则 { 打印("解析失败"); } // 真
结果<整64, 整32> 坏 = 字符串转整数("12甲");
如果 (!坏.正常) { 打印("解析失败"); }
返回 0;
}输出:12345 3.500000 真 解析失败
字符串转整数
函数 字符串转整数(字符串 输入) -> 结果<整64, 整32>
把字符串解析为 64 位整数。允许前后空白与前导正负号;遇到非法字符即失败。
| 参数 | 类型 | 说明 |
|---|---|---|
输入 | 字符串 | 待解析的字符串 |
返回 正常(值);非法/空串 → 错误(6)。
主.cnCN
导入 字符串扩展::替换;
导入 字符串扩展::填充左;
导入 字符串扩展::填充右;
导入 字符串扩展::分割;
函数 主() -> 整32 {
打印("===== 字符串扩展库(Task 6.5)=====");
// ==================== 1. 字符串转整数 ====================
整32 标志1 = 0;
整64 整1 = 解析::转整数("123", &标志1);
如果 (标志1 == 1) {
打印("转整数(123): ", 整1); // 123
} 否则 {
打印("转整数(123) 失败");
}
整32 标志2 = 0;
整64 整2 = 解析::转整数("-42", &标志2);
如果 (标志2 == 1) {
打印("转整数(-42): ", 整2); // -42
} 否则 {
打印("转整数(-42) 失败");
}
// 非法输入:"abc" 不是数字 → 成功标志 0(值归零 0)
整32 标志3 = 0;
整64 整3 = 解析::转整数("abc", &标志3);
如果 (标志3 == 1) {
打印("转整数(abc): ", 整3);
} 否则 {
打印("转整数(abc) 失败"); // 失败
}
// 前导空格 + 尾部换行(strtoll 允许首尾空白)
整32 标志4 = 0;
整64 整4 = 解析::转整数(" 99 ", &标志4);
如果 (标志4 == 1) {
打印("转整数( 99 ): ", 整4); // 99
} 否则 {
打印("转整数( 99 ) 失败");
}
// ==================== 2. 字符串转浮点 ====================
整32 标志5 = 0;
浮64 浮1 = 解析::转浮点("3.14", &标志5);
如果 (标志5 == 1) {
打印("转浮点(3.14): ", 浮1); // 3.140000
} 否则 {
打印("转浮点(3.14) 失败");
}
整32 标志6 = 0;
浮64 浮2 = 解析::转浮点("-0.5", &标志6);
如果 (标志6 == 1) {
打印("转浮点(-0.5): ", 浮2); // -0.500000
} 否则 {
打印("转浮点(-0.5) 失败");
}
// ==================== 3. 字符串转布尔 ====================
整32 标志7 = 0;
整64 布1 = 解析::转布尔("真", &标志7);
如果 (标志7 == 1) {
打印("转布尔(真): ", 布1); // 1
} 否则 {
打印("转布尔(真) 失败");
}
整32 标志8 = 0;
整64 布2 = 解析::转布尔("假", &标志8);
如果 (标志8 == 1) {
打印("转布尔(假): ", 布2); // 0
} 否则 {
打印("转布尔(假) 失败");
}
整32 标志9 = 0;
整64 布3 = 解析::转布尔("true", &标志9);
如果 (标志9 == 1) {
打印("转布尔(true): ", 布3); // 1
} 否则 {
打印("转布尔(true) 失败");
}
// ==================== 4. 替换(模块函数) ====================
字符串 替换结果 = 替换("hello world", "world", "CN语言");
打印("替换(world→CN语言): ", 替换结果); // hello CN语言
// 目标不存在 → 返回原样副本
字符串 替换无 = 替换("hello world", "xyz", "CN语言");
打印("替换(xyz): ", 替换无); // hello world
// 多次出现全部替换
字符串 替换多 = 替换("a-b-c", "-", "+");
打印("替换多(a-b-c): ", 替换多); // a+b+c
// ==================== 5. 填充左 / 填充右(模块函数) ====================
字符串 左1 = 填充左("42", 5, '0');
打印("填充左(42,5,'0'): ", 左1); // 00042
字符串 右1 = 填充右("42", 5, '*');
打印("填充右(42,5,'*'): ", 右1); // 42***
// 已超长度 → 原样
字符串 左2 = 填充左("12345", 3, '0');
打印("填充左(超长): ", 左2); // 12345
// ==================== 6. 分割(模块函数,字符串* 数组) ====================
字符串[4] 片段;
结果<整64, 整32> 分割结果 = 分割("apple,banana,cherry", ",", 片段, 4);
如果 (分割结果.正常) {
打印("分割数量: ", 分割结果.值); // 3
打印("分割[0]: ", 片段[0]); // apple
打印("分割[1]: ", 片段[1]); // banana
打印("分割[2]: ", 片段[2]); // cherry
整64 释放索引 = 0;
当 (释放索引 < 分割结果.值) {
字符串释放(片段[释放索引]);
释放索引++;
}
} 否则 {
打印("分割失败 错误码: ", 分割结果.错误);
}
// 数组不足 → 错误(6)
字符串[2] 小片段;
结果<整64, 整32> 溢出结果 = 分割("a,b,c,d", ",", 小片段, 2);
如果 (溢出结果.正常) {
打印("分割溢出: ", 溢出结果.值);
} 否则 {
打印("分割溢出错误码: ", 溢出结果.错误); // 6
}
打印("===== 字符串扩展库测试完成 =====");
返回 0;
}输出:===== 字符串扩展库(Task 6.5)===== 转整数(123): 123 转整数(-42): -42 转整数(abc) 失败 转整数( 99 ): 99 转浮点(3.14): 3.140000 转浮点(-0.5): -0.500000 转布尔(真): 1 转布尔(假): 0 转布尔(true): 1 替换(world→CN语言): hello CN语言 替换(xyz): hello world 替换多(a-b-c): a+b+c 填充左(42,5,'0'): 00042 填充右(42,5,'*'): 42*** 填充左(超长): 12345 分割数量: 3 分割[0]: apple 分割[1]: banana 分割[2]: cherry 分割溢出错误码: 6 ===== 字符串扩展库测试完成 =====
字符串转浮点
函数 字符串转浮点(字符串 输入) -> 结果<浮64, 整32>
把字符串解析为 64 位浮点数(支持小数点形式)。
| 参数 | 类型 | 说明 |
|---|---|---|
输入 | 字符串 | 待解析的字符串 |
返回 正常(值);非法 → 错误(6)。
主.cnCN
导入 字符串扩展::替换;
导入 字符串扩展::填充左;
导入 字符串扩展::填充右;
导入 字符串扩展::分割;
函数 主() -> 整32 {
打印("===== 字符串扩展库(Task 6.5)=====");
// ==================== 1. 字符串转整数 ====================
整32 标志1 = 0;
整64 整1 = 解析::转整数("123", &标志1);
如果 (标志1 == 1) {
打印("转整数(123): ", 整1); // 123
} 否则 {
打印("转整数(123) 失败");
}
整32 标志2 = 0;
整64 整2 = 解析::转整数("-42", &标志2);
如果 (标志2 == 1) {
打印("转整数(-42): ", 整2); // -42
} 否则 {
打印("转整数(-42) 失败");
}
// 非法输入:"abc" 不是数字 → 成功标志 0(值归零 0)
整32 标志3 = 0;
整64 整3 = 解析::转整数("abc", &标志3);
如果 (标志3 == 1) {
打印("转整数(abc): ", 整3);
} 否则 {
打印("转整数(abc) 失败"); // 失败
}
// 前导空格 + 尾部换行(strtoll 允许首尾空白)
整32 标志4 = 0;
整64 整4 = 解析::转整数(" 99 ", &标志4);
如果 (标志4 == 1) {
打印("转整数( 99 ): ", 整4); // 99
} 否则 {
打印("转整数( 99 ) 失败");
}
// ==================== 2. 字符串转浮点 ====================
整32 标志5 = 0;
浮64 浮1 = 解析::转浮点("3.14", &标志5);
如果 (标志5 == 1) {
打印("转浮点(3.14): ", 浮1); // 3.140000
} 否则 {
打印("转浮点(3.14) 失败");
}
整32 标志6 = 0;
浮64 浮2 = 解析::转浮点("-0.5", &标志6);
如果 (标志6 == 1) {
打印("转浮点(-0.5): ", 浮2); // -0.500000
} 否则 {
打印("转浮点(-0.5) 失败");
}
// ==================== 3. 字符串转布尔 ====================
整32 标志7 = 0;
整64 布1 = 解析::转布尔("真", &标志7);
如果 (标志7 == 1) {
打印("转布尔(真): ", 布1); // 1
} 否则 {
打印("转布尔(真) 失败");
}
整32 标志8 = 0;
整64 布2 = 解析::转布尔("假", &标志8);
如果 (标志8 == 1) {
打印("转布尔(假): ", 布2); // 0
} 否则 {
打印("转布尔(假) 失败");
}
整32 标志9 = 0;
整64 布3 = 解析::转布尔("true", &标志9);
如果 (标志9 == 1) {
打印("转布尔(true): ", 布3); // 1
} 否则 {
打印("转布尔(true) 失败");
}
// ==================== 4. 替换(模块函数) ====================
字符串 替换结果 = 替换("hello world", "world", "CN语言");
打印("替换(world→CN语言): ", 替换结果); // hello CN语言
// 目标不存在 → 返回原样副本
字符串 替换无 = 替换("hello world", "xyz", "CN语言");
打印("替换(xyz): ", 替换无); // hello world
// 多次出现全部替换
字符串 替换多 = 替换("a-b-c", "-", "+");
打印("替换多(a-b-c): ", 替换多); // a+b+c
// ==================== 5. 填充左 / 填充右(模块函数) ====================
字符串 左1 = 填充左("42", 5, '0');
打印("填充左(42,5,'0'): ", 左1); // 00042
字符串 右1 = 填充右("42", 5, '*');
打印("填充右(42,5,'*'): ", 右1); // 42***
// 已超长度 → 原样
字符串 左2 = 填充左("12345", 3, '0');
打印("填充左(超长): ", 左2); // 12345
// ==================== 6. 分割(模块函数,字符串* 数组) ====================
字符串[4] 片段;
结果<整64, 整32> 分割结果 = 分割("apple,banana,cherry", ",", 片段, 4);
如果 (分割结果.正常) {
打印("分割数量: ", 分割结果.值); // 3
打印("分割[0]: ", 片段[0]); // apple
打印("分割[1]: ", 片段[1]); // banana
打印("分割[2]: ", 片段[2]); // cherry
整64 释放索引 = 0;
当 (释放索引 < 分割结果.值) {
字符串释放(片段[释放索引]);
释放索引++;
}
} 否则 {
打印("分割失败 错误码: ", 分割结果.错误);
}
// 数组不足 → 错误(6)
字符串[2] 小片段;
结果<整64, 整32> 溢出结果 = 分割("a,b,c,d", ",", 小片段, 2);
如果 (溢出结果.正常) {
打印("分割溢出: ", 溢出结果.值);
} 否则 {
打印("分割溢出错误码: ", 溢出结果.错误); // 6
}
打印("===== 字符串扩展库测试完成 =====");
返回 0;
}输出:===== 字符串扩展库(Task 6.5)===== 转整数(123): 123 转整数(-42): -42 转整数(abc) 失败 转整数( 99 ): 99 转浮点(3.14): 3.140000 转浮点(-0.5): -0.500000 转布尔(真): 1 转布尔(假): 0 转布尔(true): 1 替换(world→CN语言): hello CN语言 替换(xyz): hello world 替换多(a-b-c): a+b+c 填充左(42,5,'0'): 00042 填充右(42,5,'*'): 42*** 填充左(超长): 12345 分割数量: 3 分割[0]: apple 分割[1]: banana 分割[2]: cherry 分割溢出错误码: 6 ===== 字符串扩展库测试完成 =====
字符串转布尔
函数 字符串转布尔(字符串 输入) -> 结果<布尔, 整32>
识别「真/假」(以及数值 0/非 0)。
| 参数 | 类型 | 说明 |
|---|---|---|
输入 | 字符串 | 待解析的字符串 |
返回 正常(布尔值);无法识别 → 错误(6)。
主.cnCN
导入 字符串扩展::替换;
导入 字符串扩展::填充左;
导入 字符串扩展::填充右;
导入 字符串扩展::分割;
函数 主() -> 整32 {
打印("===== 字符串扩展库(Task 6.5)=====");
// ==================== 1. 字符串转整数 ====================
整32 标志1 = 0;
整64 整1 = 解析::转整数("123", &标志1);
如果 (标志1 == 1) {
打印("转整数(123): ", 整1); // 123
} 否则 {
打印("转整数(123) 失败");
}
整32 标志2 = 0;
整64 整2 = 解析::转整数("-42", &标志2);
如果 (标志2 == 1) {
打印("转整数(-42): ", 整2); // -42
} 否则 {
打印("转整数(-42) 失败");
}
// 非法输入:"abc" 不是数字 → 成功标志 0(值归零 0)
整32 标志3 = 0;
整64 整3 = 解析::转整数("abc", &标志3);
如果 (标志3 == 1) {
打印("转整数(abc): ", 整3);
} 否则 {
打印("转整数(abc) 失败"); // 失败
}
// 前导空格 + 尾部换行(strtoll 允许首尾空白)
整32 标志4 = 0;
整64 整4 = 解析::转整数(" 99 ", &标志4);
如果 (标志4 == 1) {
打印("转整数( 99 ): ", 整4); // 99
} 否则 {
打印("转整数( 99 ) 失败");
}
// ==================== 2. 字符串转浮点 ====================
整32 标志5 = 0;
浮64 浮1 = 解析::转浮点("3.14", &标志5);
如果 (标志5 == 1) {
打印("转浮点(3.14): ", 浮1); // 3.140000
} 否则 {
打印("转浮点(3.14) 失败");
}
整32 标志6 = 0;
浮64 浮2 = 解析::转浮点("-0.5", &标志6);
如果 (标志6 == 1) {
打印("转浮点(-0.5): ", 浮2); // -0.500000
} 否则 {
打印("转浮点(-0.5) 失败");
}
// ==================== 3. 字符串转布尔 ====================
整32 标志7 = 0;
整64 布1 = 解析::转布尔("真", &标志7);
如果 (标志7 == 1) {
打印("转布尔(真): ", 布1); // 1
} 否则 {
打印("转布尔(真) 失败");
}
整32 标志8 = 0;
整64 布2 = 解析::转布尔("假", &标志8);
如果 (标志8 == 1) {
打印("转布尔(假): ", 布2); // 0
} 否则 {
打印("转布尔(假) 失败");
}
整32 标志9 = 0;
整64 布3 = 解析::转布尔("true", &标志9);
如果 (标志9 == 1) {
打印("转布尔(true): ", 布3); // 1
} 否则 {
打印("转布尔(true) 失败");
}
// ==================== 4. 替换(模块函数) ====================
字符串 替换结果 = 替换("hello world", "world", "CN语言");
打印("替换(world→CN语言): ", 替换结果); // hello CN语言
// 目标不存在 → 返回原样副本
字符串 替换无 = 替换("hello world", "xyz", "CN语言");
打印("替换(xyz): ", 替换无); // hello world
// 多次出现全部替换
字符串 替换多 = 替换("a-b-c", "-", "+");
打印("替换多(a-b-c): ", 替换多); // a+b+c
// ==================== 5. 填充左 / 填充右(模块函数) ====================
字符串 左1 = 填充左("42", 5, '0');
打印("填充左(42,5,'0'): ", 左1); // 00042
字符串 右1 = 填充右("42", 5, '*');
打印("填充右(42,5,'*'): ", 右1); // 42***
// 已超长度 → 原样
字符串 左2 = 填充左("12345", 3, '0');
打印("填充左(超长): ", 左2); // 12345
// ==================== 6. 分割(模块函数,字符串* 数组) ====================
字符串[4] 片段;
结果<整64, 整32> 分割结果 = 分割("apple,banana,cherry", ",", 片段, 4);
如果 (分割结果.正常) {
打印("分割数量: ", 分割结果.值); // 3
打印("分割[0]: ", 片段[0]); // apple
打印("分割[1]: ", 片段[1]); // banana
打印("分割[2]: ", 片段[2]); // cherry
整64 释放索引 = 0;
当 (释放索引 < 分割结果.值) {
字符串释放(片段[释放索引]);
释放索引++;
}
} 否则 {
打印("分割失败 错误码: ", 分割结果.错误);
}
// 数组不足 → 错误(6)
字符串[2] 小片段;
结果<整64, 整32> 溢出结果 = 分割("a,b,c,d", ",", 小片段, 2);
如果 (溢出结果.正常) {
打印("分割溢出: ", 溢出结果.值);
} 否则 {
打印("分割溢出错误码: ", 溢出结果.错误); // 6
}
打印("===== 字符串扩展库测试完成 =====");
返回 0;
}输出:===== 字符串扩展库(Task 6.5)===== 转整数(123): 123 转整数(-42): -42 转整数(abc) 失败 转整数( 99 ): 99 转浮点(3.14): 3.140000 转浮点(-0.5): -0.500000 转布尔(真): 1 转布尔(假): 0 转布尔(true): 1 替换(world→CN语言): hello CN语言 替换(xyz): hello world 替换多(a-b-c): a+b+c 填充左(42,5,'0'): 00042 填充右(42,5,'*'): 42*** 填充左(超长): 12345 分割数量: 3 分割[0]: apple 分割[1]: banana 分割[2]: cherry 分割溢出错误码: 6 ===== 字符串扩展库测试完成 =====
替换与填充
返回值均为拥有型字符串(调用方 RAII 自动释放)。替换按字节偏移处理;目标为空串时原样返回。
替换
函数 替换(字符串 输入, 字符串 目标, 字符串 替换为) -> 字符串
把 输入 中所有出现的 目标 替换为 替换为,返回新串(输入不变)。内置安全计数器(上限 100 次)防自包含死循环;目标不存在时返回原样副本。
| 参数 | 类型 | 说明 |
|---|---|---|
输入 | 字符串 | 原始字符串 |
目标 | 字符串 | 被替换的子串(空串=原样返回) |
替换为 | 字符串 | 替换成的子串 |
返回 替换后的新字符串。
主.cnCN
导入 字符串扩展::替换;
导入 字符串扩展::填充左;
导入 字符串扩展::填充右;
导入 字符串扩展::分割;
函数 主() -> 整32 {
打印("===== 字符串扩展库(Task 6.5)=====");
// ==================== 1. 字符串转整数 ====================
整32 标志1 = 0;
整64 整1 = 解析::转整数("123", &标志1);
如果 (标志1 == 1) {
打印("转整数(123): ", 整1); // 123
} 否则 {
打印("转整数(123) 失败");
}
整32 标志2 = 0;
整64 整2 = 解析::转整数("-42", &标志2);
如果 (标志2 == 1) {
打印("转整数(-42): ", 整2); // -42
} 否则 {
打印("转整数(-42) 失败");
}
// 非法输入:"abc" 不是数字 → 成功标志 0(值归零 0)
整32 标志3 = 0;
整64 整3 = 解析::转整数("abc", &标志3);
如果 (标志3 == 1) {
打印("转整数(abc): ", 整3);
} 否则 {
打印("转整数(abc) 失败"); // 失败
}
// 前导空格 + 尾部换行(strtoll 允许首尾空白)
整32 标志4 = 0;
整64 整4 = 解析::转整数(" 99 ", &标志4);
如果 (标志4 == 1) {
打印("转整数( 99 ): ", 整4); // 99
} 否则 {
打印("转整数( 99 ) 失败");
}
// ==================== 2. 字符串转浮点 ====================
整32 标志5 = 0;
浮64 浮1 = 解析::转浮点("3.14", &标志5);
如果 (标志5 == 1) {
打印("转浮点(3.14): ", 浮1); // 3.140000
} 否则 {
打印("转浮点(3.14) 失败");
}
整32 标志6 = 0;
浮64 浮2 = 解析::转浮点("-0.5", &标志6);
如果 (标志6 == 1) {
打印("转浮点(-0.5): ", 浮2); // -0.500000
} 否则 {
打印("转浮点(-0.5) 失败");
}
// ==================== 3. 字符串转布尔 ====================
整32 标志7 = 0;
整64 布1 = 解析::转布尔("真", &标志7);
如果 (标志7 == 1) {
打印("转布尔(真): ", 布1); // 1
} 否则 {
打印("转布尔(真) 失败");
}
整32 标志8 = 0;
整64 布2 = 解析::转布尔("假", &标志8);
如果 (标志8 == 1) {
打印("转布尔(假): ", 布2); // 0
} 否则 {
打印("转布尔(假) 失败");
}
整32 标志9 = 0;
整64 布3 = 解析::转布尔("true", &标志9);
如果 (标志9 == 1) {
打印("转布尔(true): ", 布3); // 1
} 否则 {
打印("转布尔(true) 失败");
}
// ==================== 4. 替换(模块函数) ====================
字符串 替换结果 = 替换("hello world", "world", "CN语言");
打印("替换(world→CN语言): ", 替换结果); // hello CN语言
// 目标不存在 → 返回原样副本
字符串 替换无 = 替换("hello world", "xyz", "CN语言");
打印("替换(xyz): ", 替换无); // hello world
// 多次出现全部替换
字符串 替换多 = 替换("a-b-c", "-", "+");
打印("替换多(a-b-c): ", 替换多); // a+b+c
// ==================== 5. 填充左 / 填充右(模块函数) ====================
字符串 左1 = 填充左("42", 5, '0');
打印("填充左(42,5,'0'): ", 左1); // 00042
字符串 右1 = 填充右("42", 5, '*');
打印("填充右(42,5,'*'): ", 右1); // 42***
// 已超长度 → 原样
字符串 左2 = 填充左("12345", 3, '0');
打印("填充左(超长): ", 左2); // 12345
// ==================== 6. 分割(模块函数,字符串* 数组) ====================
字符串[4] 片段;
结果<整64, 整32> 分割结果 = 分割("apple,banana,cherry", ",", 片段, 4);
如果 (分割结果.正常) {
打印("分割数量: ", 分割结果.值); // 3
打印("分割[0]: ", 片段[0]); // apple
打印("分割[1]: ", 片段[1]); // banana
打印("分割[2]: ", 片段[2]); // cherry
整64 释放索引 = 0;
当 (释放索引 < 分割结果.值) {
字符串释放(片段[释放索引]);
释放索引++;
}
} 否则 {
打印("分割失败 错误码: ", 分割结果.错误);
}
// 数组不足 → 错误(6)
字符串[2] 小片段;
结果<整64, 整32> 溢出结果 = 分割("a,b,c,d", ",", 小片段, 2);
如果 (溢出结果.正常) {
打印("分割溢出: ", 溢出结果.值);
} 否则 {
打印("分割溢出错误码: ", 溢出结果.错误); // 6
}
打印("===== 字符串扩展库测试完成 =====");
返回 0;
}输出:===== 字符串扩展库(Task 6.5)===== 转整数(123): 123 转整数(-42): -42 转整数(abc) 失败 转整数( 99 ): 99 转浮点(3.14): 3.140000 转浮点(-0.5): -0.500000 转布尔(真): 1 转布尔(假): 0 转布尔(true): 1 替换(world→CN语言): hello CN语言 替换(xyz): hello world 替换多(a-b-c): a+b+c 填充左(42,5,'0'): 00042 填充右(42,5,'*'): 42*** 填充左(超长): 12345 分割数量: 3 分割[0]: apple 分割[1]: banana 分割[2]: cherry 分割溢出错误码: 6 ===== 字符串扩展库测试完成 =====
填充左
函数 填充左(字符串 输入, 整64 目标长度, 字符 填充) -> 字符串
长度不足 目标长度 时在左侧补 填充 字符(右对齐排版);已达标原样返回。
| 参数 | 类型 | 说明 |
|---|---|---|
输入 | 字符串 | 原始字符串 |
目标长度 | 整64 | 目标总长度 |
填充 | 字符 | 填充用的字符 |
返回 填充后的新字符串。
主.cnCN
导入 字符串扩展::替换;
导入 字符串扩展::填充左;
导入 字符串扩展::填充右;
导入 字符串扩展::分割;
函数 主() -> 整32 {
打印("===== 字符串扩展库(Task 6.5)=====");
// ==================== 1. 字符串转整数 ====================
整32 标志1 = 0;
整64 整1 = 解析::转整数("123", &标志1);
如果 (标志1 == 1) {
打印("转整数(123): ", 整1); // 123
} 否则 {
打印("转整数(123) 失败");
}
整32 标志2 = 0;
整64 整2 = 解析::转整数("-42", &标志2);
如果 (标志2 == 1) {
打印("转整数(-42): ", 整2); // -42
} 否则 {
打印("转整数(-42) 失败");
}
// 非法输入:"abc" 不是数字 → 成功标志 0(值归零 0)
整32 标志3 = 0;
整64 整3 = 解析::转整数("abc", &标志3);
如果 (标志3 == 1) {
打印("转整数(abc): ", 整3);
} 否则 {
打印("转整数(abc) 失败"); // 失败
}
// 前导空格 + 尾部换行(strtoll 允许首尾空白)
整32 标志4 = 0;
整64 整4 = 解析::转整数(" 99 ", &标志4);
如果 (标志4 == 1) {
打印("转整数( 99 ): ", 整4); // 99
} 否则 {
打印("转整数( 99 ) 失败");
}
// ==================== 2. 字符串转浮点 ====================
整32 标志5 = 0;
浮64 浮1 = 解析::转浮点("3.14", &标志5);
如果 (标志5 == 1) {
打印("转浮点(3.14): ", 浮1); // 3.140000
} 否则 {
打印("转浮点(3.14) 失败");
}
整32 标志6 = 0;
浮64 浮2 = 解析::转浮点("-0.5", &标志6);
如果 (标志6 == 1) {
打印("转浮点(-0.5): ", 浮2); // -0.500000
} 否则 {
打印("转浮点(-0.5) 失败");
}
// ==================== 3. 字符串转布尔 ====================
整32 标志7 = 0;
整64 布1 = 解析::转布尔("真", &标志7);
如果 (标志7 == 1) {
打印("转布尔(真): ", 布1); // 1
} 否则 {
打印("转布尔(真) 失败");
}
整32 标志8 = 0;
整64 布2 = 解析::转布尔("假", &标志8);
如果 (标志8 == 1) {
打印("转布尔(假): ", 布2); // 0
} 否则 {
打印("转布尔(假) 失败");
}
整32 标志9 = 0;
整64 布3 = 解析::转布尔("true", &标志9);
如果 (标志9 == 1) {
打印("转布尔(true): ", 布3); // 1
} 否则 {
打印("转布尔(true) 失败");
}
// ==================== 4. 替换(模块函数) ====================
字符串 替换结果 = 替换("hello world", "world", "CN语言");
打印("替换(world→CN语言): ", 替换结果); // hello CN语言
// 目标不存在 → 返回原样副本
字符串 替换无 = 替换("hello world", "xyz", "CN语言");
打印("替换(xyz): ", 替换无); // hello world
// 多次出现全部替换
字符串 替换多 = 替换("a-b-c", "-", "+");
打印("替换多(a-b-c): ", 替换多); // a+b+c
// ==================== 5. 填充左 / 填充右(模块函数) ====================
字符串 左1 = 填充左("42", 5, '0');
打印("填充左(42,5,'0'): ", 左1); // 00042
字符串 右1 = 填充右("42", 5, '*');
打印("填充右(42,5,'*'): ", 右1); // 42***
// 已超长度 → 原样
字符串 左2 = 填充左("12345", 3, '0');
打印("填充左(超长): ", 左2); // 12345
// ==================== 6. 分割(模块函数,字符串* 数组) ====================
字符串[4] 片段;
结果<整64, 整32> 分割结果 = 分割("apple,banana,cherry", ",", 片段, 4);
如果 (分割结果.正常) {
打印("分割数量: ", 分割结果.值); // 3
打印("分割[0]: ", 片段[0]); // apple
打印("分割[1]: ", 片段[1]); // banana
打印("分割[2]: ", 片段[2]); // cherry
整64 释放索引 = 0;
当 (释放索引 < 分割结果.值) {
字符串释放(片段[释放索引]);
释放索引++;
}
} 否则 {
打印("分割失败 错误码: ", 分割结果.错误);
}
// 数组不足 → 错误(6)
字符串[2] 小片段;
结果<整64, 整32> 溢出结果 = 分割("a,b,c,d", ",", 小片段, 2);
如果 (溢出结果.正常) {
打印("分割溢出: ", 溢出结果.值);
} 否则 {
打印("分割溢出错误码: ", 溢出结果.错误); // 6
}
打印("===== 字符串扩展库测试完成 =====");
返回 0;
}输出:===== 字符串扩展库(Task 6.5)===== 转整数(123): 123 转整数(-42): -42 转整数(abc) 失败 转整数( 99 ): 99 转浮点(3.14): 3.140000 转浮点(-0.5): -0.500000 转布尔(真): 1 转布尔(假): 0 转布尔(true): 1 替换(world→CN语言): hello CN语言 替换(xyz): hello world 替换多(a-b-c): a+b+c 填充左(42,5,'0'): 00042 填充右(42,5,'*'): 42*** 填充左(超长): 12345 分割数量: 3 分割[0]: apple 分割[1]: banana 分割[2]: cherry 分割溢出错误码: 6 ===== 字符串扩展库测试完成 =====
填充右
函数 填充右(字符串 输入, 整64 目标长度, 字符 填充) -> 字符串
长度不足时在右侧补 填充 字符(左对齐排版)。
| 参数 | 类型 | 说明 |
|---|---|---|
输入 | 字符串 | 原始字符串 |
目标长度 | 整64 | 目标总长度 |
填充 | 字符 | 填充用的字符 |
返回 填充后的新字符串。
主.cnCN
导入 字符串扩展::替换;
导入 字符串扩展::填充左;
导入 字符串扩展::填充右;
导入 字符串扩展::分割;
函数 主() -> 整32 {
打印("===== 字符串扩展库(Task 6.5)=====");
// ==================== 1. 字符串转整数 ====================
整32 标志1 = 0;
整64 整1 = 解析::转整数("123", &标志1);
如果 (标志1 == 1) {
打印("转整数(123): ", 整1); // 123
} 否则 {
打印("转整数(123) 失败");
}
整32 标志2 = 0;
整64 整2 = 解析::转整数("-42", &标志2);
如果 (标志2 == 1) {
打印("转整数(-42): ", 整2); // -42
} 否则 {
打印("转整数(-42) 失败");
}
// 非法输入:"abc" 不是数字 → 成功标志 0(值归零 0)
整32 标志3 = 0;
整64 整3 = 解析::转整数("abc", &标志3);
如果 (标志3 == 1) {
打印("转整数(abc): ", 整3);
} 否则 {
打印("转整数(abc) 失败"); // 失败
}
// 前导空格 + 尾部换行(strtoll 允许首尾空白)
整32 标志4 = 0;
整64 整4 = 解析::转整数(" 99 ", &标志4);
如果 (标志4 == 1) {
打印("转整数( 99 ): ", 整4); // 99
} 否则 {
打印("转整数( 99 ) 失败");
}
// ==================== 2. 字符串转浮点 ====================
整32 标志5 = 0;
浮64 浮1 = 解析::转浮点("3.14", &标志5);
如果 (标志5 == 1) {
打印("转浮点(3.14): ", 浮1); // 3.140000
} 否则 {
打印("转浮点(3.14) 失败");
}
整32 标志6 = 0;
浮64 浮2 = 解析::转浮点("-0.5", &标志6);
如果 (标志6 == 1) {
打印("转浮点(-0.5): ", 浮2); // -0.500000
} 否则 {
打印("转浮点(-0.5) 失败");
}
// ==================== 3. 字符串转布尔 ====================
整32 标志7 = 0;
整64 布1 = 解析::转布尔("真", &标志7);
如果 (标志7 == 1) {
打印("转布尔(真): ", 布1); // 1
} 否则 {
打印("转布尔(真) 失败");
}
整32 标志8 = 0;
整64 布2 = 解析::转布尔("假", &标志8);
如果 (标志8 == 1) {
打印("转布尔(假): ", 布2); // 0
} 否则 {
打印("转布尔(假) 失败");
}
整32 标志9 = 0;
整64 布3 = 解析::转布尔("true", &标志9);
如果 (标志9 == 1) {
打印("转布尔(true): ", 布3); // 1
} 否则 {
打印("转布尔(true) 失败");
}
// ==================== 4. 替换(模块函数) ====================
字符串 替换结果 = 替换("hello world", "world", "CN语言");
打印("替换(world→CN语言): ", 替换结果); // hello CN语言
// 目标不存在 → 返回原样副本
字符串 替换无 = 替换("hello world", "xyz", "CN语言");
打印("替换(xyz): ", 替换无); // hello world
// 多次出现全部替换
字符串 替换多 = 替换("a-b-c", "-", "+");
打印("替换多(a-b-c): ", 替换多); // a+b+c
// ==================== 5. 填充左 / 填充右(模块函数) ====================
字符串 左1 = 填充左("42", 5, '0');
打印("填充左(42,5,'0'): ", 左1); // 00042
字符串 右1 = 填充右("42", 5, '*');
打印("填充右(42,5,'*'): ", 右1); // 42***
// 已超长度 → 原样
字符串 左2 = 填充左("12345", 3, '0');
打印("填充左(超长): ", 左2); // 12345
// ==================== 6. 分割(模块函数,字符串* 数组) ====================
字符串[4] 片段;
结果<整64, 整32> 分割结果 = 分割("apple,banana,cherry", ",", 片段, 4);
如果 (分割结果.正常) {
打印("分割数量: ", 分割结果.值); // 3
打印("分割[0]: ", 片段[0]); // apple
打印("分割[1]: ", 片段[1]); // banana
打印("分割[2]: ", 片段[2]); // cherry
整64 释放索引 = 0;
当 (释放索引 < 分割结果.值) {
字符串释放(片段[释放索引]);
释放索引++;
}
} 否则 {
打印("分割失败 错误码: ", 分割结果.错误);
}
// 数组不足 → 错误(6)
字符串[2] 小片段;
结果<整64, 整32> 溢出结果 = 分割("a,b,c,d", ",", 小片段, 2);
如果 (溢出结果.正常) {
打印("分割溢出: ", 溢出结果.值);
} 否则 {
打印("分割溢出错误码: ", 溢出结果.错误); // 6
}
打印("===== 字符串扩展库测试完成 =====");
返回 0;
}输出:===== 字符串扩展库(Task 6.5)===== 转整数(123): 123 转整数(-42): -42 转整数(abc) 失败 转整数( 99 ): 99 转浮点(3.14): 3.140000 转浮点(-0.5): -0.500000 转布尔(真): 1 转布尔(假): 0 转布尔(true): 1 替换(world→CN语言): hello CN语言 替换(xyz): hello world 替换多(a-b-c): a+b+c 填充左(42,5,'0'): 00042 填充右(42,5,'*'): 42*** 填充左(超长): 12345 分割数量: 3 分割[0]: apple 分割[1]: banana 分割[2]: cherry 分割溢出错误码: 6 ===== 字符串扩展库测试完成 =====
分割
C 风格输出参数边界:结果写入调用方准备的 字符串* 数组。数组长度须为编译期常量(数组声明限制),故以「数组+长度」传参。切分出的每个元素是动态分配串,用完须逐一 字符串释放。
分割 不安全
不安全 函数 分割(字符串 输入, 字符串 分隔符, 字符串* 结果数组, 整64 数组长度) -> 结果<整64, 整32>
按 分隔符 把 输入 切成若干段写入 结果数组,返回实际段数。数组装不下剩余内容 → 错误(6)(已填元素由调用方释放);分隔符为空串 → 错误(6)。
| 参数 | 类型 | 说明 |
|---|---|---|
输入 | 字符串 | 原始字符串 |
分隔符 | 字符串 | 切分用分隔串(不可为空) |
结果数组 | 字符串* | 调用方准备的输出数组 |
数组长度 | 整64 | 输出数组容量 |
返回 正常(实际段数);数组不足/分隔符空 → 错误(6)。
主.cnCN
导入 字符串扩展::替换;
导入 字符串扩展::填充左;
导入 字符串扩展::填充右;
导入 字符串扩展::分割;
函数 主() -> 整32 {
打印("===== 字符串扩展库(Task 6.5)=====");
// ==================== 1. 字符串转整数 ====================
整32 标志1 = 0;
整64 整1 = 解析::转整数("123", &标志1);
如果 (标志1 == 1) {
打印("转整数(123): ", 整1); // 123
} 否则 {
打印("转整数(123) 失败");
}
整32 标志2 = 0;
整64 整2 = 解析::转整数("-42", &标志2);
如果 (标志2 == 1) {
打印("转整数(-42): ", 整2); // -42
} 否则 {
打印("转整数(-42) 失败");
}
// 非法输入:"abc" 不是数字 → 成功标志 0(值归零 0)
整32 标志3 = 0;
整64 整3 = 解析::转整数("abc", &标志3);
如果 (标志3 == 1) {
打印("转整数(abc): ", 整3);
} 否则 {
打印("转整数(abc) 失败"); // 失败
}
// 前导空格 + 尾部换行(strtoll 允许首尾空白)
整32 标志4 = 0;
整64 整4 = 解析::转整数(" 99 ", &标志4);
如果 (标志4 == 1) {
打印("转整数( 99 ): ", 整4); // 99
} 否则 {
打印("转整数( 99 ) 失败");
}
// ==================== 2. 字符串转浮点 ====================
整32 标志5 = 0;
浮64 浮1 = 解析::转浮点("3.14", &标志5);
如果 (标志5 == 1) {
打印("转浮点(3.14): ", 浮1); // 3.140000
} 否则 {
打印("转浮点(3.14) 失败");
}
整32 标志6 = 0;
浮64 浮2 = 解析::转浮点("-0.5", &标志6);
如果 (标志6 == 1) {
打印("转浮点(-0.5): ", 浮2); // -0.500000
} 否则 {
打印("转浮点(-0.5) 失败");
}
// ==================== 3. 字符串转布尔 ====================
整32 标志7 = 0;
整64 布1 = 解析::转布尔("真", &标志7);
如果 (标志7 == 1) {
打印("转布尔(真): ", 布1); // 1
} 否则 {
打印("转布尔(真) 失败");
}
整32 标志8 = 0;
整64 布2 = 解析::转布尔("假", &标志8);
如果 (标志8 == 1) {
打印("转布尔(假): ", 布2); // 0
} 否则 {
打印("转布尔(假) 失败");
}
整32 标志9 = 0;
整64 布3 = 解析::转布尔("true", &标志9);
如果 (标志9 == 1) {
打印("转布尔(true): ", 布3); // 1
} 否则 {
打印("转布尔(true) 失败");
}
// ==================== 4. 替换(模块函数) ====================
字符串 替换结果 = 替换("hello world", "world", "CN语言");
打印("替换(world→CN语言): ", 替换结果); // hello CN语言
// 目标不存在 → 返回原样副本
字符串 替换无 = 替换("hello world", "xyz", "CN语言");
打印("替换(xyz): ", 替换无); // hello world
// 多次出现全部替换
字符串 替换多 = 替换("a-b-c", "-", "+");
打印("替换多(a-b-c): ", 替换多); // a+b+c
// ==================== 5. 填充左 / 填充右(模块函数) ====================
字符串 左1 = 填充左("42", 5, '0');
打印("填充左(42,5,'0'): ", 左1); // 00042
字符串 右1 = 填充右("42", 5, '*');
打印("填充右(42,5,'*'): ", 右1); // 42***
// 已超长度 → 原样
字符串 左2 = 填充左("12345", 3, '0');
打印("填充左(超长): ", 左2); // 12345
// ==================== 6. 分割(模块函数,字符串* 数组) ====================
字符串[4] 片段;
结果<整64, 整32> 分割结果 = 分割("apple,banana,cherry", ",", 片段, 4);
如果 (分割结果.正常) {
打印("分割数量: ", 分割结果.值); // 3
打印("分割[0]: ", 片段[0]); // apple
打印("分割[1]: ", 片段[1]); // banana
打印("分割[2]: ", 片段[2]); // cherry
整64 释放索引 = 0;
当 (释放索引 < 分割结果.值) {
字符串释放(片段[释放索引]);
释放索引++;
}
} 否则 {
打印("分割失败 错误码: ", 分割结果.错误);
}
// 数组不足 → 错误(6)
字符串[2] 小片段;
结果<整64, 整32> 溢出结果 = 分割("a,b,c,d", ",", 小片段, 2);
如果 (溢出结果.正常) {
打印("分割溢出: ", 溢出结果.值);
} 否则 {
打印("分割溢出错误码: ", 溢出结果.错误); // 6
}
打印("===== 字符串扩展库测试完成 =====");
返回 0;
}输出:===== 字符串扩展库(Task 6.5)===== 转整数(123): 123 转整数(-42): -42 转整数(abc) 失败 转整数( 99 ): 99 转浮点(3.14): 3.140000 转浮点(-0.5): -0.500000 转布尔(真): 1 转布尔(假): 0 转布尔(true): 1 替换(world→CN语言): hello CN语言 替换(xyz): hello world 替换多(a-b-c): a+b+c 填充左(42,5,'0'): 00042 填充右(42,5,'*'): 42*** 填充左(超长): 12345 分割数量: 3 分割[0]: apple 分割[1]: banana 分割[2]: cherry 分割溢出错误码: 6 ===== 字符串扩展库测试完成 =====