字符串函数_str

1.自己实现strlen

//写第一题脑子瓦塔了，传进去指针忘了解引用，并且没有让指针进行后移操作
int mystrlen(char* arr) {
    assert(arr != NULL);
    int len = 0;
    while (*arr != '\0') {
        arr++;
        len++;
    }
    return len;
}

这个题很简单，就不写自己之前写的错误代码了

------------------------------------------------------------------------------------------------

2.自己实现strcpy

char* mystrcpy(char* dest, char* source) {
    assert(dest != NULL);
    assert(source != NULL);
    while (source != '\0') {
        *dest = *source;
        dest++;
        source++;
    }
    *dest = '\0';
    return &dest[0];
}

以上这个代码是错误代码。

char* mystrcpy(char* dest, char* source) {
    assert(dest != NULL);
    assert(source != NULL);
    char* head = dest;
    while (*source != '\0') {
        *dest = *source;
        dest++;
        source++;
    }
    *dest = '\0';
    return head;
}

int main() {
    char arr[] = "abcde";
    char dest[20] = { 0 };
    char* head=mystrcpy(dest, arr);
    printf("%s",head);
    return 0;
}

错误总结，while循环的时候竟然又没有解引用判断反斜杠0！！！！！！，再有就是想要返回头指针的时候就重新定义一个变量不就完了，然后再主函数运行打印的时候自己又遇到了一个问题，忘记了打印字符串的时候，直接传入首地址就可以，打印%s会自动解引用往后找反斜杠0；

3.memmove 函数

//memmove 可以处理内存重叠的问题
void* mymemmove(void* destination, const void* source, size_t num) {
    assert(destination != NULL);
    assert(source != NULL);
    void* ret = destination;
    //这里记住void*类型不能运算，判断地址的原因是防止没有赋值的元素被覆盖,即为解决内存重叠的问题
    //判断之后才能决定从前往后赋值还是从后往前
    if (destination<source || (char*)destination>(char*)source + num) {
        while ((long)num != 0) {
            (char*)destination = (char*)source;
            (char*)destination+=1;
            (char*)source += 1;
            num--;
        }
    }
    else {
        destination = (char*)destination + num - 1;
        source = (char*)source + num - 1;
        while ((long)num != 0) {
            *(char*)destination = *(char*)source;
            (char*)destination -= 1;
            (char*)source -= 1;
            num--;
        }
    }
    return ret;
}

这里memmove和memcpy唯一区别就是它可以解决内存重叠的问题，函数里会有一个对地址的判断，如果目的地址小于员源地址或者目的地址大于源地址加上num的话，就可以正着复制，否则就从最后一个元素开始复制。

4.memcpy函数

void* mymemcpy(void* destination, const void* source, size_t num) {
    assert(destination != NULL);
    assert(source != NULL);
    void* ret = destination;
    for (size_t i = 0; i < num; i++) {
        ((char*)destination)[i] = ((char*)source)[i];
    }
    return ret;
}

会了上面的函数，自然会这一个

5、模拟实现strstr函数

strstr函数判断一个字符串里面是否包含另一个字符串

const char* mystrstr(const char* str1, const char* str2) {
    assert(str1 != NULL);
    assert(str2 != NULL);
    assert(*str1 != '\0');
    assert(*str2 != '\0');
    char* red = str1;
    while (*red != '\0') {
        char* s1 = red;
        char* s2 = str2;
        while(*s1 == *s2&&*s1!='\0'&&*s2!='\0') {
            //指向相同往后比较
            s1++;
            s2++;
        }
        //这里s1和s2判断顺序有讲究，如果先判断s1的话是不对的，如果找到了字符串，恰好s1s2都指向了反斜杠零
        //此时就应该返回正确的指针了如果先判断s1的话就会又red++此时就把正确的答案错过了
        if (*s2 == '\0') {
            return red;
        }
        2.
        //else if (*s1 = '\0') {
        //    red++;
        //}
        3.*s1!=*s2
        //else {
        //    red++;
        //}
        else {
            red++;
        }
    }
    return NULL;
}

6.实现strcmp

int mystrcmp(const char* str1, const char* str2) {
    assert(str1!=NULL);
    assert(str2!=NULL);
    while (*str1 == *str2 && *str1 != '\0' && *str2 != '\0') {
        str1++;
        str2++;
    }
    int ret = str1 - str2;
    if (*str1 == '\0') {
        return -1;
    }
    else if (*str2 == '\0') {
        return 1;
    }
    else return 0;
}

以上是错误的代码，实现原理没有搞清楚，当时就想着从两个字符串的头开始往下走，全比一遍，可是按上面这么写的话，如果第一个字符就不一样，直接返回0，那更是大错特错，值是根据字典序来走的，而不是判断反斜杠零来比长度的；

这是正确的代码

int mystrcmp(const char* str1, const char* str2) {
    assert(str1!=NULL);
    assert(str2!=NULL);
    while (*str1 != '\0' && *str2 != '\0') {
        if (*str1 < *str2) {
            return -1;
        }
        else if (*str1 > *str2) {
            return 1;
        }
        else {
            str1++;
            str2++;
        }
    }
    if (*str1 < *str2) {
        return -1;
    }
    else if (*str1 > *str2) {
        return 1;
    }
    else {
        return 0;
    }
}

7.strcat函数

char* mystrcat(char* dest, const char* src) {
    assert(dest != NULL);
    assert(src != NULL);
    char* p = dest;
    while (*dest != '\0') {
        dest++;
    }
    while (*src != '\0') {
        *dest = *src;
        dest++;
        src++;
    }
    return p;
}

这里还是很简单的，但要保证目的数组空间足够大，先把目的数组指针加加一直到末尾，然后就可以从末尾开始赋值了，结束后然后返回头指针，是不是觉得没问题，错了，要保证最后也要以'\0'结尾啊，不然不就又一直往后找了吗

char* mystrcat(char* dest, const char* src) {
    assert(dest != NULL);
    assert(src != NULL);
    char* p = dest;
    while (*dest != '\0') {
        dest++;
    }
    while (*src != '\0') {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = '\0';
    return p;
}