模拟实现字符串部分库函数

strcpy

参数：char *strcpy( char *strDestination, const char *strSource );

功能：字符串拷贝函数

注意：
1.源字符串必须以‘\0’结束。
2.函数会将源字符串的‘\0’拷贝到目标空间。
3.目标空间必须足够大，确保能存放源字符串。
4.目标空间必须可变。

模拟实现strcpy:

#include <stdio.h>
#include <string.h>
#include <assert.h>
char* my_strcpy(char *dest, const char *src)//数组元素为字符型，所以指针变量用char*
{
    //dest指向arr的首地址，src指向arr1的首地址，
    char *ret = dest;
    assert(*dest != NULL);//断言
    assert(*src != NULL);   
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main()
{
    char arr[20] = { 'x', 'x', 'x', 'x' ,'x', 'x' };
    char arr1[] = { 'a', 'b', 'c','\0' };

    printf("%s\n", my_strcpy(arr, arr1));
        return 0;
}

关于断言：
使用断言会使字符串为空时，准确报错。增加代码的健壮性，断言只会在调试版本有作用，但会在发布版本里被优化。

关于const：
1.const修饰常变量
该变量就是常变量

2.const修饰指针
a).const放在*左边，修饰的是指针指向的内容
指针指向的内容不能通过指针来改变，指针变量本身可以修改
b).const放在*右边，修饰的是指针指向的内容
指针指向的内容可以通过指针来改变。但是指针变量本身不允许修改

返回 char* 是为了实现链式访问

strlen

参数：size_t strlen( const char *string );

功能：求一个字符串的长度

注意：
1.字符串以’\0’为结束标志，strlen函数返回的是在’\0’前面出现的字符个数（不包含’\0’）。
2.参数指向的字符串必须以’\0’结束。
3.注意函数返回值为size_t，是无符号的（特别注意）

模拟实现strlen

#include <assert.h>
int my_strlen(const char *str)
{
    int count = 0;
    assert(str != NULL);
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

int main()
{
    char *str = "abcdef";

    printf("%d\n", my_strlen(str));
        return 0;
}

模拟strlen函数还可以不用创建临时变量，上节关于递归的博客中专门对这种写法做介绍。

strcat

参数：char *strcat( char *strDestination, const char *strSource );

功能：附加一个字符串

注意：strcat不能进行自身附加。
如果字符串需要自身连接，可以使用strncat。

模拟实现strcat

#include <stdio.h>
#include <assert.h>
char* my_strcat(char* dest, const char* src)
{
   char *ret = dest;
   assert(dest!= NULL);
   assert(src != NULL);
   while (*dest)
   {
        dest++;
   }
   while ((*dest++ = *src++))
   {
        ;
   }
   return ret;
}
int main()
{
   char a[] = "hello ";
   char b[] = "girl";
   printf("%s\n", my_strcat(a,b));
   return 0;
}

strstr

参数：char *strstr( const char *string, const char *strCharSet );

功能：找到子字符串

模拟实现strstr

#include <stdio.h>
#include <assert.h>
char* my_strstr(const char* str1, const char* str2)
{
   assert(str1);
   assert(str2);
   char *p = (char*)str1;
   char *substr = (char*)str2;
   char *s1 = NULL;

   if (*str2 == '\0')
        return NULL;

   while (*p)
   {
        s1 = p;
        substr = str2;
        while (*s1 &&  *substr && (*s1 == *substr))
        {
            s1++;
            substr++;
        }
        if (*substr == '\0')
            return p;
        p++;
   }
}

int main()
{
   char a[] = "i like apple and orange";
   char b[] = "apple";
   printf("%s\n", my_strstr(a, b));
   return 0;
}

strchr

参数：char *strchr( const char *string, int c );
功能：在字符串中查找字符。

模拟实现strchr

#include <stdio.h>
#include <assert.h>
int my_strchr(const char* str, char k)
{
    assert(str != NULL);
    while (*str)
    {
        if (*str == k)
        {
            return str;
        }
        else
        {
            str++;
        }
    }
    return NULL;
}
int main()
{
    char arr[] = "i like orange";
    char ch = 'k';
    my_strchr(arr, ch);
    printf("%s\n", my_strchr(arr, ch));
    return 0;

}

strcmp

参数：int strcmp( const char *string1, const char *string2 );

功能：比较字符串

模拟实现strcmp

#include <stdio.h>

int my_strcmp(const char* src, const char* dest)
{
   int ret = 0;
   while (!(ret = *(unsigned char *)src - *(unsigned char *)dest)&& *dest)//强制类型转换

        ++src,
        ++dest;
        if (ret < 0)
        {
            ret = -1;
        }
        else if (ret > 0)
        {
            ret = 1;
        }
        return (ret);

}
int main()
{
   char a[] = "ilikeapple";
   char b[] = "ilike";

   printf("%d\n", my_strcmp(a, b));
   return 0;
}

memcpy

参数：void *memcpy( void *dest, const void *src, size_t count );

功能：拷贝src所指的内存内容前n个字节到dest所指的内存地址上。

特别的：
与strcpy不同的是,memcpy会完整的复制n个字节,不会因为遇到字符串结束’\0’而结束。
memcpy功能和memmove相同，但是memcpy中dest和source中的区域不能重叠，否则会出现未知结果。

模拟实现memcpy

#include <stdio.h>

void* my_memcpy(void * dst, const void *src, size_t count)
{
   void *ret = dst;
   while (count--)
   {
        *(char *)dst = *(char *)src;
        dst = (char *)dst + 1;
        src = (char *)src + 1;
   }
   return (ret);
}
int main()
{
   char a[] = "xxxxxxxxxx";
   char b[] = "girl";
   int count = 2;
   printf("%s\n", my_memcpy(a, b,count));
}

memmove

模拟实现memove

参数：void *memmove( void *dest, const void *src, size_t count );

功能：mmmove与memcpy功能相同，但memove中dest和source中的区域可以重叠。

#include <stdio.h>
#include <assert.h>
void* my_memmove(void* dst, const void* src, size_t count)
{
   void *ret = dst;
   if (dst <= src || (char*)dst >= ((char*)src + count))
   {
        while (count--)
        {
            *(char*)dst = *(char*)src;
            dst = (char*)dst + 1;
            src = (char*)src + 1;
        }
   }
   else
   {
        dst = (char*)dst +count+ 1;
        src = (char*)src +count+ 1;

        while (count--)
        {
            *(char*)dst = *(char*)src;
            dst = (char*)dst - 1;
            src = (char*)src - 1;
        }
   }
   return (ret);
}
int main()
{
   char a[] = "abcdefgh";
   char b[] = "like";
   int count = 3;
   printf("%s\n", my_memmove(a, b,count));
   return 0;
}