C语言从strcpy到自定义字符串处理函数的原理解析

char* strcpy(char* dest, const char* src);

#include <stdio.h>   // 引入标准输入输出库，提供printf等函数
#include <string.h>  // 引入字符串处理库，提供strcpy等字符串操作函数
int main() {         // 主函数，程序执行入口
    char src[] = "hello, world!";  // 定义并初始化源字符串数组，数组长度由编译器自动计算（包含结尾的'\0'）
    char dest[50];                // 定义目标字符数组，分配50字节空间确保能容纳源字符串内容
    strcpy(dest, src);  // 使用字符串拷贝函数：将src的内容（包括结尾的'\0'）复制到dest数组中
    printf("源字符串: %s\n", src);   // 格式化输出源字符串内容，%s对应src数组首地址
    printf("目标字符串: %s\n", dest);// 格式化输出目标字符串内容，%s对应dest数组首地址
    return 0;           // 程序正常退出，返回0给操作系统
}                      // 主函数体结束

char* strcat(char* dest, const char* src);

#include <stdio.h>   // 引入标准输入输出库，提供printf等格式化输出功能
#include <string.h>  // 引入字符串处理库，提供strcat等字符串连接函数
int main() {         // 主函数，程序执行的入口点
    char dest[50] = "hello";  // 定义并初始化目标字符数组，分配50字节空间，初始内容为"hello"（包含结尾的'\0'）
    char src[] = ", world!";  // 定义源字符串数组，内容为", world!"，数组长度由编译器自动计算（包含结尾的'\0'）
    strcat(dest, src);  // 字符串连接函数：将src的内容追加到dest末尾（自动覆盖dest原有的'\0'并在新结尾添加'\0'）
    printf("连接后的字符串: %s\n", dest);  // 输出结果，%s格式符读取dest数组内容直到遇到'\0'
    return 0;           // 程序正常结束，返回0表示执行成功
}                      // 主函数体结束

int strcmp(const char* str1, const char* str2);

#include <stdio.h>   // 引入标准输入输出库，提供printf等格式化输出功能
#include <string.h>  // 引入字符串处理库，提供strcmp等字符串比较函数
int main() {         // 主函数，程序执行的入口点
    char str1[] = "apple";   // 定义并初始化字符数组str1，内容为"apple"（包含结尾的'\0'，长度自动计算为6）
    char str2[] = "banana";  // 定义并初始化字符数组str2，内容为"banana"（包含结尾的'\0'，长度自动计算为7）
    int result = strcmp(str1, str2);  // 调用字符串比较函数：逐个字符比较str1和str2的ascii值
                                      // 返回值规则：
                                      // - 若str1 < str2 返回负数
                                      // - 若str1 == str2 返回0
                                      // - 若str1 > str2 返回正数
    // 根据比较结果进行分支判断
    if (result < 0) {                     // 当str1字典序小于str2时
        printf("%s 小于 %s\n", str1, str2); // 输出比较结果（此处因'a'的ascii码小于'b'会触发此分支）
    } else if (result == 0) {             // 当两个字符串完全相同时
        printf("%s 等于 %s\n", str1, str2);
    } else {                              // 当str1字典序大于str2时
        printf("%s 大于 %s\n", str1, str2);
    }
    return 0;           // 程序正常结束，返回0表示执行成功
}                      // 主函数体结束

size_t strlen(const char* str);

#include <stdio.h>   // 引入标准输入输出库，提供printf等格式化输出功能
#include <string.h>  // 引入字符串处理库，提供strlen等字符串操作函数
int main() {         // 主函数，程序执行的入口点
    char str[] = "hello, world!";  // 定义并初始化字符数组，内容为"hello, world!"，数组长度自动计算为14（包含结尾的'\0'）
    size_t length = strlen(str);   // 调用字符串长度计算函数：返回字符串有效字符数（不包含结尾的'\0'），结果存入无符号整型size_t变量
    printf("字符串: %s\n", str);      // 输出原始字符串内容，%s格式符读取字符数组直到遇到'\0'
    printf("字符串长度: %zu\n", length); // 输出字符串长度，%zu是size_t类型的专用格式说明符
    return 0;           // 程序正常结束，返回0表示执行成功
}                      // 主函数体结束
/*
代码特性说明：
1. strlen() 计算的是实际可见字符数量（"hello, world!"共13个有效字符）
2. sizeof(str) 会返回14（包含结尾的'\0'），但strlen(str)返回13
3. size_t 是标准库专门为表示内存/字符串长度设计的无符号整型（通常相当于unsigned int或unsigned long）
4. 字符数组初始化时编译器自动添加'\0'，因此不需要手动设置字符串终止符
*/

char* strstr(const char* haystack, const char* needle);

#include <stdio.h>   // 引入标准输入输出库，提供printf等格式化输出功能
#include <string.h>  // 引入字符串处理库，提供strstr等字符串查找函数
int main() {         // 主函数，程序执行的入口点
    char haystack[] = "hello, world!";  // 定义并初始化"目标字符串"（被搜索的原始字符串），自动包含结尾的'\0'
    char needle[] = "world";            // 定义并初始化"待查找子串"，自动包含结尾的'\0'
    // 使用strstr函数在haystack中查找needle的首次出现位置
    // 返回值：
    // - 找到时：返回指向首次匹配位置的指针
    // - 未找到时：返回null
    char* result = strstr(haystack, needle);  
    if (result != null) {  // 判断是否找到子字符串
        // 输出找到的结果：
        // %s 输出子串内容，%p 输出子串在内存中的起始地址（指针值）
        printf("子字符串 %s 在 %s 中的起始位置: %p\n", needle, haystack, result);
    } else {
        // 输出未找到的提示信息
        printf("子字符串 %s 未找到\n", needle);
    }
    return 0;           // 程序正常结束，返回0表示执行成功
}                      // 主函数体结束
/*
代码特性说明：
1. strstr() 执行区分大小写的搜索，例如"world"将无法匹配"world"
2. 查找成功时返回的指针指向目标字符串中的匹配位置，可以直接用于偏移计算：
   示例输出地址对应的实际偏移量为 7（haystack[7] = 'w'）
3. %p 格式符专门用于打印指针地址，实际输出格式取决于系统（可能显示十六进制地址）
4. 字符串初始化时编译器会自动添加'\0'，因此：
   - sizeof(haystack) = 14字节（包含'\0'）
   - strlen(haystack) = 13字符（不包含'\0'）
*/

#include <stdio.h>   // 引入标准输入输出库，提供printf等格式化输出功能
#include <string.h>  // 引入字符串处理库，提供strlen和strcpy等字符串操作函数
int main() {         // 主函数，程序执行的入口点
    char src[] = "hello, world!";  // 定义并初始化源字符数组，内容包含结尾的'\0'，数组长度由编译器自动计算（14字节）
    // 动态计算目标数组长度：strlen获取src有效字符数（13），+1为结尾的'\0'预留空间
    char dest[strlen(src) + 1];  // 声明目标字符数组，使用变长数组（vla）特性，总大小为14字节
    strcpy(dest, src);  // 执行字符串拷贝：将src内容（包含结尾'\0'）完整复制到dest数组中
    printf("源字符串: %s\n", src);   // 输出源字符串内容，%s通过逐字符读取直到遇到'\0'
    printf("目标字符串: %s\n", dest); // 输出目标字符串，验证复制结果
    return 0;           // 程序正常退出，返回0表示执行成功
}                      // 主函数体结束
/*
关键实现细节：
1. strlen(src) 返回值为13（不包含结尾'\0'），因此dest数组大小为13+1=14
2. strcpy执行时：
   - 先复制'h''e''l''l''o'...等可见字符
   - 最后自动复制结尾的'\0'终止符
3. 目标数组使用栈内存分配，vla特性要求编译器支持c99及以上标准
4. 此实现相比固定大小数组更安全，能自动适配不同长度的源字符串
5. 字符串输出时printf通过首地址指针逐字节读取，直到遇到'\0'结束
*/

#include <stdio.h>   // 引入标准输入输出库，提供printf等格式化输出功能
#include <string.h>  // 引入字符串处理库，提供strlen、strcpy、strcat等字符串操作函数
int main() {         // 主函数，程序执行的入口点
    char str1[] = "hello";  // 定义并初始化第一个源字符串，包含'\0'终止符，数组长度自动计算为6（5字符+1终止符）
    char str2[] = "world";  // 定义并初始化第二个源字符串，包含'\0'终止符，数组长度自动计算为6（5字符+1终止符）
    /* 动态计算目标数组大小：
       strlen(str1) = 5 (不包含终止符)
       strlen(str2) = 5 (不包含终止符)
       +1 为结果字符串的终止符'\0'预留空间
       总分配空间 = 5 + 5 + 1 = 11 字节 */
    char dest[strlen(str1) + strlen(str2) + 1];  // 声明目标字符数组（使用c99变长数组特性）
    strcpy(dest, str1);  // 第一阶段拷贝：将str1内容（包含终止符）完整复制到dest
                         // 此时dest内容为：['h','e','l','l','o','\0',?,?,?,?,?]
    strcat(dest, str2);  // 第二阶段连接：在dest现有内容后追加str2内容
                         // 执行过程：
                         // 1. 找到dest当前的终止符'\0'（索引5）
                         // 2. 从该位置开始复制str2内容（覆盖原终止符）
                         // 3. 追加完成后自动添加新终止符
                         // 最终内容：['h','e','l','l','o','w','o','r','l','d','\0']
    printf("连接后的字符串: %s\n", dest);  // 输出完整连接结果，%s格式符读取直到遇到'\0'
    return 0;           // 程序正常退出，返回状态码0表示执行成功
}                      // 主函数体结束
/*
关键安全说明：
1. 目标数组大小计算策略确保缓冲区安全：
   - strlen返回纯字符数（不含终止符）
   - 总需求空间 = str1_len + str2_len + 1（终止符）
   - 示例：5(hello) + 5(world) + 1 = 11字节
2. 代码兼容性：
   - char dest[...]使用变长数组(vla)，需c99及以上标准支持
   - 旧编译器可使用malloc动态分配：
     char* dest = malloc((strlen(str1)+strlen(str2)+1)*sizeof(char));
3. strcat工作原理：
   - 依赖dest原有的有效终止符定位追加位置
   - 若dest未初始化或未正确终止，可能导致缓冲区溢出
4. 输出验证：
   - 本例将稳定输出"helloworld"（无中间空格，因原始字符串未包含）
   - 如需分隔符需手动添加，如strcat(dest, " ")后再strcat(dest, str2)
*/

#include <stdio.h>  // 引入标准输入输出库，提供printf函数原型
// 自定义字符串拷贝函数实现
char* custom_strcpy(char* dest, const char* src) {  // 参数：目标字符指针，源常量字符指针（防止修改源）
    char* ptr = dest;  // 保存目标数组起始地址指针（用于最终返回）
    // 循环复制源字符串内容到目标地址
    while (*src != '\0') {  // 判断源字符串当前字符是否为终止符
        *ptr = *src;        // 将源字符复制到目标位置
        ptr++;              // 目标指针后移（指向下一个写入位置）
        src++;              // 源指针后移（指向下一个读取字符）
    }
    *ptr = '\0';  // 手动添加字符串终止符（完成目标字符串的标准化格式）
    return dest;   // 返回目标数组起始地址（支持链式调用）
}
int main() {
    // 注意事项：此处strlen需要包含string.h，原代码存在头文件缺失问题
    char src[] = "hello, world!";  // 定义并初始化源字符数组（自动包含'\0'终止符）
    char dest[strlen(src) + 1];    // 声明目标字符数组（使用变长数组vla）
                                   // 数组大小计算：源有效字符数 + 终止符 = 13 + 1 = 14
    custom_strcpy(dest, src);  // 调用自定义拷贝函数完成字符串复制
    printf("源字符串: %s\n", src);   // 输出源字符串验证原始数据
    printf("目标字符串: %s\n", dest); // 输出目标字符串验证复制结果
    return 0;  // 程序正常退出，返回状态码0
}
/*
代码解读：
1. 关键差异对比：
   - 相比标准库的strcpy，这个实现：
     a) 显式展示底层复制过程
     b) 需要手动处理终止符
     c) 不检查目标缓冲区大小（存在安全隐患）
2. 潜在问题说明：
   - 主函数中strlen使用需要#include <string.h>
   - 目标数组若小于源长度会导致缓冲区溢出
   - 建议添加防御性检查：
     if (sizeof(dest) < strlen(src)+1) { /* 错误处理 */ }
3. 指针操作细节：
   - src使用const修饰保证函数内不会修改源字符串
   - ptr维护独立的写位置指针，保留dest原始地址用于返回
   - while循环等价于：while ((*ptr++ = *src++) != '\0') ;
4. vla特性说明：
   - char dest[...] 使用c99变长数组特性
   - 编译时自动计算数组大小（依赖当前src的内容）
   - 若需兼容c89标准应改为固定大小或动态内存分配
*/