模拟实现字符串函数strlen，strcpy，strcat，strcmp

&一.求字符串长度（strlen）
&二.长度不受限制的字符串函数（strcpy，strcat，strcmp）
&三.长度受限制的字符串函数介绍（strncpy，strncat，strncmp）
&四.字符串查找（strstr，strtok）

1.求字符串长度（strlen）(string length)（字符串通常放在常量字符串中或者字符数组中，字符串常量适用于那些对它不做修改的字符串函数）

size_t strlen ( const char * str );

1）字符串已 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
2）参数指向的字符串必须要以 ‘\0’ 结束。
3）注意函数的返回值为size_t，是无符号的（ 易错 ），size_t无符号整型相当于unsigned int
4）学会strlen函数的模拟实现

模拟实现方法一

//模拟实现strlen，求字符串长度(方法一）
//识别字符串中的每个字符，如果不是’\0’，计数器count++，直到找到’\0’为止，返回计数器coun的值
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
        assert(str != NULL);//断言str不是空指针
        int count = 0;//计数器
        while (*str != '\0')
        {
               count++;//每识别一个不是'\0'的字符，计数器+1
               str++;//指向下一个字符的地址
        }
        return count;//返回计数器的值
}
int main()
{
        char arr[] = "abcdef";
        int len = my_strlen(arr);
        printf("%d\n", len);
        return 0;
}

模拟实现方法二：递归

//模拟实现strlen，求字符串长度（方法二）
//递归方法实现
//my_strlen(“abcdef”)->
//1 + my_strlen(“bcdef”)->
//1 + 1 + my_strlen(“cdef”)->
//1 + 1 + 1 + my_strlen(“def”)->
//1 + 1 + 1 + 1 + my_strlen(“ef”)->
//1 + 1 + 1 + 1 + 1 + my_strlen(“f”)->
//1 + 1 + 1 + 1 + 1 + 1 + my_strlen(" ")->
//1 + 1 + 1 + 1 + 1 + 1 + 0
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
        assert(str != NULL);
        if (*str != '\0')
               return 1 + my_strlen(str + 1);//不断递归调用，直到*str= '\0’
        else
               return 0;
}
int main()
{
        char arr[] = "abcdef";
        int len = my_strlen(arr);
        printf("%d\n", len);
        return 0;
}

模拟实现方法三：指针-指针

//模拟实现strlen，求字符串长度（方法三）
//指针 - 指针，得到元素个数
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
        assert(str != NULL);
        const char* start = str;//start指向元素地址
        while (*str != '\0')
        {
               str++;
        }
        return str - start;//str指向'\0'的地址
}
int main()
{
        char arr[] = "abcdef";
        int len = my_strlen(arr);
        printf("%d\n", len);
        return 0;
}

2.字符串拷贝strcpy

char* strcpy(char* destination,const char* source);

模拟实现方法一：

//模拟实现strcpy(方法一）
#include<stdio.h>
#include<assert.h>
void my_strcpy(char* dest, const char* src)
{
        assert(dest != NULL);
        assert(src != NULL);
        while (*dest++=*src++)
        {
               ;
        }
}
int main()
{
        char* str1 = "abcdef";
        char arr[20] = "XXXXXXXXXX";
        my_strcpy(arr, str1);
        printf("%s\n", arr);
        return 0;
}

模拟实现方法二：

//模拟实现strcpy(方法三）
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
        char* start = dest;
        assert(dest != NULL);
        assert(src != NULL);
        while (*dest++ = *src++)
        {
               ;
        }
        return start;
}
int main()
{
        char* str1 = "abcdef";
        char arr[20] = "XXXXXXXXXX";
        printf("%s\n", my_strcpy(arr, str1));
        return 0;
}

3.字符串追加strcat

char* strcat(char* destination,const char* source);

1)源字符串必须以’\0’结束
2）会将源字符串中的’\0’拷贝到目标空间
3）目标空间必须足够大，以确保能存放源字符串
4）目标空间必须可变
5）学会模拟实现

//模拟实现strcat字符串追加
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
        assert(dest);
        assert(src);
        char* start = dest;
        //1.寻找目的空间的'\0'
        while (*dest)
        {
               dest++;
        }
        //2.拷贝数据
        while (*dest++ = *src++)
        {
               ;
        }
        return start;
}
int main()
{
        char arr[20] = "hello ";
        //my_strcat(arr, "world!");
        //printf("%s\n", arr);
        printf("%s\n", my_strcat(arr, "world!"));
        return 0;
}

4.字符串比较strcmp

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

1）第一个字符串大于第二个字符串，则返回大于0的数字
2）第一个字符串等于第二个字符串，则返回0
3）第一个字符串小于第二个字符串，则返回小于0的数字
4）strcmp模拟实现

//模拟实现strcmp字符串比较
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* s1, const char* s2)
{
        while (*s1 == *s2)
        {
               //如果*s1等于0，进入循环的话*s2也等于0，返回0
               if (*s1 == '\0')
                       return 0;
               s1++;
               s2++;
        }
        //如果*s1小于*s2返回一个负数，否则返回一个整数
        return *s1 - *s2;
}
int main()
{
        int ret = my_strcmp("abcd", "abcdef");
        if (ret > 0)
               printf("大于\n");
        else if(ret==0)
               printf("等于\n");
        else
               printf("小于\n");
        return 0;
}

5.strncpy拷贝n个字符

char * strncpy ( char * destination, const char * source, size_t num);

1)拷贝num个字符从源字符串到目标空间。
2)如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

6.strncat追加n个字符

char* strncat（char* destination, const char* source, size_t num);

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main()
{
        char arr1[20] = "abcdef";
        char arr2[] = "cdefab";
        if (strlen(arr1) != strlen(arr2))
        {
               printf("no\n");
               return 0;
        }
        strncat(arr1, arr1, 6);
        char* start = strstr(arr1, arr2);
        if (start == NULL)
               printf("no\n");
        else
               printf("yes\n");
        return 0;
}

7.strncmp，n个字符进行比较，比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

int strncmp(const char* str1,const char* str2, size_t num );

//strncmp指定字符串个数比较
#include<stdio.h>
#include<string.h>
int main()
{
        char arr1[] = "abcdef";
        char arr2[] = "abqeee";
        int ret = strncmp(arr1, arr2, 2);
        printf("%d\n", ret);
        return 0;
}

8.strstr字符串查找，找到返回字符所在地址，找不到返回空指针

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

//strstr字符串查找，查找到了，返回地址，查找不到返回空指针
#include<stdio.h>
#include<string.h>
int main()
{
        char arr[] = "abcdef";
        char* ret = strstr(arr, "cd");
        if (ret != NULL)
        {
               printf("%s\n", ret);
        }
        else
        {
               printf("查找不到\n");
        }
        return 0;
}

9.strtok

char * strtok ( char * str, const char * sep );

1）sep参数是个字符串，定义了用作分隔符的字符集合
2）第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
3）strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
4）strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
5）strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
6）如果字符串中不存在更多的标记，则返回 NULL 指针。

//strtok的作用,遇到分隔符，将分隔符置成'\0'
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main()
{
        char arr1[] = "zzp@bitedu.tech";
        char tmp[30] = { 0 };
        strcpy(tmp, arr1);
        char arr2[] = "@.";
        char* p = NULL;
        for (p = strtok(tmp, arr2); p != NULL; p = strtok(NULL, arr2))
        {
               printf("%s\n", p);
        }
        //p = strtok(tmp, arr2);
        //printf("%s\n",p);
        //p = strtok(NULL, arr2);//NULL在'@'的位置
        //printf("%s\n",p);
        //p = strtok(NULL, arr2);//NULL在'.'的位置
        //printf("%s\n",p);
        return 0;
}