C常用的字符串函数实现

/**
 查找字符串 source 中 是否有指定的子串出现,如果有返回第一个匹配的字符

 @param source 源
 @param chars 目标
 @return 返回值
 */
char *find_char0(char const *source, char const *chars) {
    if (source == NULL || chars == NULL) {
        return NULL;
    }
    char const *sc1, *sc2;
    for (sc1 = source; *sc1 != '\0'; ++sc1) {
        for (sc2 = chars; *sc2 != '\0'; ++sc2) {
            if (*sc1 == *sc2) {
                return (char *)sc1;
            }
        }
    }
    return NULL;
}

/**
 字符串copy 实现

 @param dest 目的字符串指针
 @param src 源字符串指针
 @return 返回值
 */
char *strcpy_(char *dest, const char *src){
    char *ret = dest;
    assert(dest != NULL);
    while ((*dest++ = *src++)) {
        ;
    }
    return ret;
}

/**
 字符串拼接

 @param dest 目标字符串指针
 @param src 源字符串指针
 @return 目标字符串作为返回值
 */
char *strcat_(char *dest, const char *src) {
    char *ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    //找到dest指向字符串的末尾 '\0'
    while (*dest != '\0') {//注意此处while 不能写成(*dest++ != '\0'),因为一个循环结束前又++操作会跳过 '\0'
        dest++;
    }

    //拷贝src指向的内容
    while ((*dest ++ = *src++)) {
        ;
    }

    return ret;
}

/**
 查找一个字符中是否包含某一子串

 @param str 给定的长字符串
 @param substr 子串
 @return 是否包含子串 不包含返回NULL 包含非NULL
 */
char *strstr_(const char *str, const char *substr){
    assert(str != NULL);
    assert(substr != NULL);

    if (*substr == '\0') {
        return str;
    }
    while (*str) {
        const char *s1 = str;
        const char *s2 = substr;
        while (*s1 && *s2 && *s1 == *s2) {
            s1++;
            s2++;
        }
        if (*s2 == '\0') {//遍历到s2结尾
            return str;//返回str 因为 str 记录了初始值的位置
        }
        str++;
    }
    return NULL;

}

/**
 字符串比较

 @param str1 字符串1
 @param str2 字符串2
 @return 比较结果 >0 = 0 <0
 */
int strcmp_(const char* str1, const char *str2){
    assert(str1 != NULL);
    assert(str2 != NULL);
    while (*str1 == *str2) {
        if (*str1 == '\0') {
            return 0;
        }
        str1++;
        str2++;
    }
    //*str1 > *str2,返回值大于0 ,*str1 = *str2,返回值等于0 ,*str1 < *str2,返回值小于0
    return *str1 - *str2;
}

/**
 内存拷贝

 @param dest 目标位置
 @param src 源位置
 @param count 长度 字节为单位
 @return 目的位置地址
 */
char *memcpy_(void *dest, const void *src, size_t count) {
    void *ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    while (count) {
        *(char*)dest = *(char*)src;
        dest = (char*)dest+1;
        src = (char*)src+1;
        count--;
    }
    return ret;
}

/**
 反向拷贝

 @param dest 目的地址
 @param src 源地址
 @param count 长度 字节为单位
 @return 过程函数,无返回值
 */
void *memmove_(void *dest, void *src, size_t count) {
    void *ret = dest;
    char *str1 = (char*)dest;
    char *str2 = (char*)src;
    assert(dest != NULL);
    assert(src != NULL);
    if (str1 > str2) {
        while (count--) {
            *(str1 + count) = *(str2 + count);
        }
    }else {
        while (count--) {
            *str1++ = *str2++;
        }
    }
    return ret;
}

/**
 反转字符串实现,不借助新的数组

 @param s 字符串
 @return 反转后的字符串
 */
void *strrev(char *s) {
    //h指向s的头部
    char *h = s;
    char *t = s;
    char ch;

    //t指向s的尾部
    while(*t++){};
    t--;//与t++抵消
    t--;//往回跳过结束符 '\0'

    //当h 和 t未重合时,交换它们所指向的字符
    while (h<t) {
        ch = *h;
        *h++ = *t;
        *t-- = ch;
    }
    return s;
}