CN·语言

字符串扩展

数值解析、替换、填充、分割——对标 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 ===== 字符串扩展库测试完成 =====