C语言中strcpy、strcat、strstr、strchr、strcmp、memcpy、memmove函数的实现

1、strcpy函数

（1）、函数功能：

strcpy函数的意思是：把字符串s2中的内容copy到s1中，连字符串结束标志也一起copy.

（2）、代码实现

#include <stdio.h>
#include <stdlib.h>
const char* my_strcpy (char* arr2, const char* arr1)
{
    const char *ret = arr1;
    while (*arr1)
    {
        *arr2 = *arr1;
        arr2++;
        arr1++;
    }
    *arr2 = *arr1;//此时arr1和arr2都指向'\0'
    return ret;
}
int main()
{
    char arr1[] = {"abcdefgh"};
    char arr2[10] = {"0"};
    my_strcpy (arr2, arr1);
    printf ("arr1 = {%s}\n", arr1);
    printf ("arr2 = {%s}\n", arr2);
    system ("pause");
    return 0;
}
/*
运行结果：
arr1 = {abcdefgh}
arr2 = {abcdefgh}
请按任意键继续. . .
*/

2.实现strcat

（1）、函数功能：

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

strcat() 会将参数 str 字符串复制到参数 dest 所指的字符串尾部；dest 最后的结束字符 NULL 会被覆盖掉，并在连接后的字符串的尾部再增加一个 NULL。

注意：dest 与str所指的内存空间不能重叠，且 dest 要有足够的空间来容纳要复制的字符串。

（2）、代码实现

#include <stdio.h>
#include <stdlib.h>
char* my_strcat(char *dest,const char *str)
{
    char *ret = dest;
    while (*dest)//使dest指向'\0'
    {
        dest ++;
    }
    while(*str)
    {
        *dest++ = *str++;
    }
    *dest = *str;//让此时的*dest = '\0'
    return ret;
}
int main()
{
    char arr1[15] = "abcdefg";
    char arr2[] = "hij";
    printf ("调用前：\narr1 = %s\narr2 = %s\n", arr1, arr2);
    my_strcat(arr1, arr2);
    printf ("调用后：\narr1 = %s\narr2 = %s\n", arr1, arr2);
    system ("pause");
    return 0;
}
/*
运行结果：
调用前：
arr1 = abcdefg
arr2 = hij
调用后：
arr1 = abcdefghij
arr2 = hij
请按任意键继续. . .
*/

3.实现strstr

（1）函数功能：

strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。

（2）代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

char* my_strstr(const char *arr1, const char *arr2)//str2是不是str1的子串
{
    char *p = (char *)arr1;
    char *q = (char *)arr2;
    char *ret = NULL;
    assert(arr1 != NULL);
    assert(arr2 != NULL);
    if (*arr2 == '\0')
    {
        return NULL;
    }
    while(*p)//arr1不等‘\0’
    {
        ret = p;
        while (*p == *q && *q && *p)
        {
            q++;
            p++;
        }
        if(*q == '\0')
        {
            return ret;
        }
        else
        {
            p = ret+1;
            q = (char*)arr2;
            /*p++;*/
        }
    }
    return NULL;
}

int main()
{
    char arr1[10] = "abbbbbcde";
    char arr2[5] = "bbc";
    printf ("%s\n", strstr(arr1, arr2));
    printf ("%s\n", my_strstr(arr1, arr2));
    system ("pause");
    return 0;
}
/*
运行结果：
bbcde
bbcde
请按任意键继续. . .
*/

4.实现strchr

（1）函数功能

从字符串arr中寻找字符a第一次出现的位置，返回指向第一次出现字符character位置的指针，如果没找到则返回NULL。

（2）代码实现

#include <stdio.h>
#include <stdlib.h>
char* my_strchr(char* arr, char a)
{
    while (*arr)
    {
        if(*arr != a)
        {
            arr++;
        }
        else
        {
            return arr;
        }
    }
    return NULL;
}
int main()
{
    char arr[] = "abdenddlmf";
    char a = 'd';
    printf ("%s\n", my_strchr(arr, a));
    system ("pause");
    return 0;
}
/*
运行结果：
denddlmf
请按任意键继续. . .
*/

5.实现strcmp

（1）函数功能：

int my_strcmp (const char* dest, const char* str)

如果dest > str,则返回值大于0，####如果dest = str,则返回值等于0，如果dest < str ,则返回值小于0。

字符大小是按照字符的字典序列进行排列的。

（2）代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int my_strcmp (const char* dest, const char* str)
{
    assert(dest != NULL);
    assert(str != NULL);

    while (*dest!='\0' && *str!='\0')
    {
        if(*dest != *str)
        {
            return *dest-*str;;
        }
        dest++;
        str++;
    }
    return 0;
}
int main()
{
    char arr1[] = "bnjfdbgl";
    char arr2[] = "anjfdbgj";
    printf ("%d\n", my_strcmp (arr1, arr2));
    system ("pause");
    return 0;
}
/*
运行结果：
1
请按任意键继续. . .
*/

6.实现memcpy

（1）代码功能：

函数原型：void* my_memcpy(void* dest,const void* src, size_t n)

函数功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中

（2）代码实现：

#include<stdio.h>
#include <stdlib.h>
#include <string.h>
void* my_memcpy(void* dest,const void* src, size_t n)
{
    void *ret = dest;
    while(n)
    {
        *(char *)dest = *(char *)src;
        dest = (char *)dest+1;
        src = (char *)src+1;
        n--;
    }
    return ret;

}

int main()
{

    char arr1[10] = "bfdinfjs";
    char arr2[10] = "bfdinfjs";
    char arr3[10] = "bb";

    memcpy(arr1+5, arr3, 2);
    my_memcpy(arr2+5, arr3, 2);

    printf ("arr1 = %s\n", arr1);
    printf ("arr2 = %s\n", arr2);
    printf ("arr3 = %s\n", arr3);
    system ("pause");
    return 0;
}
/*
运行结果：
arr1 = bfdinbbs
arr2 = bfdinbbs
arr3 = bb
请按任意键继续. . .
*/

7.实现memmove

（1）函数功能:

与mencpy相同，不同的是当dest和 src 重叠，函数仍能正常工作。

代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void* my_memmove(void* dest, const void* src, size_t n)
{
    void* ret = dest; 
    if (src<dest)
    {
        while(n--)
        {
            *((char *)dest+n) = *((char *)src+n);
        }
    }
    else
    {
        while(n)
        {
            *(char *)dest = *(char *)src;
            dest = (char *)dest + 1;
            src = (char *)src +1;
            n--;
        }
    }
    return ret;
}
void print (int *p, int sz, int num)
{
    int i = 0;
    printf ("arr%d\n", num);
    for (i=0; i<sz; i++)
    {
        printf ("%d ",p[i]);
    }
    printf ("\n");
}
int main()
{
    int arr1[] = {1, 2, 3, 4, 5, 6};
    int arr2[] = {1, 2, 3, 4, 5, 6};
    int sz = sizeof(arr1)/sizeof(arr1[0]);
    memmove (arr1+1, arr1, 12);
    my_memmove(arr2+1, arr2, 12);

    print(arr1, sz, 1);
    print(arr2, sz, 2);
    system ("pause");
    return 0;
}
/*
运行结果：
arr1
1 1 2 3 5 6
arr2
1 1 2 3 5 6
请按任意键继续. . .
*/