模拟实现字符串相关函数

一、题目

1、求字符串长度。

2、字符串拷贝。

3、字符串连接。

4、字符查找函数。

5、字符串查找函数。

二、代码：

//编写一个my_strlen函数，他类似于strlen函数，但是他能够处理由于使用strn--函数而创建的未能以null字节结尾的字符串。
int my_strlen(char *str,int n)  //求字符串长度
{
    int lenth = 0;
    while (lenth<n)
    {
        if (*(str++) == '\0')
            break;
        ++lenth;
    }
    return lenth;
}

//编写一个my_strcpy函数，它类似于strcpy函数，但他不会溢出目标数组。复制的结果必须是一个真正的字符串
void my_strcpy(char *dst,char const *src,int n) //字符串拷贝函数（n是原字符串的长度）
{
    while (--n) //n控制溢出
    {
        if (*src == '\0')
            break;
        *(dst++) = *(src++);
    }
    *dst='\0';
}

//编写一个my_strcat函数，它类似于strcat函数，但他不会溢出目标数组。复制的结果必须是一个真正的字符串
void my_strcat(char *dst,char const *src,int n)//字符串连接（n为原字符串的长度，控制原字符串）
{
    while (n--) //找到原字符串的结束
    {
        if (*dst == '\0')
            break;
        dst++;
    }
    do 
    {
        *dst++ = *src++; //连接
        if ((--n)==0)
            break;
    } while (*src);
    *dst = '\0'; //加上字符串结束标志
}

//编写一个my_strcpy_end函数，它类似于strcpy函数，但他返回指向目标字符串结尾的得指针不会溢出目标数组。复制的结果必须是一个真正的字符串
char* my_strcpy_end(char *dst,char const *src,int n)
{
    while (--n) //n控制溢出
    {
        if (*src == '\0')
            break;
        *(dst++) = *(src++);
    }
    *dst='\0';
    return dst;
}

//编写一个my_strchr函数，他类似于strchr函数，只是他返回最后一次出现ch这个字符的地址。
char *my_strchr(char  *str,int ch)
{
    char *result = NULL;
    while (*str)
    {
        if (ch == (int)*str)
            result = str;
        str++;
    }
    return result;
}

//编写一个my_strchr函数，他类似于strchr函数，只是他返回第n次出现ch这个字符的地址。
char *my_strnchr(char  *str,int ch,int n)
{
    char *result = NULL;
    while (*str)
    {
        if ((int)*str == ch)
        {
            result = str;
            if (0 == --n)
               break;
        }
        str++;
    }
    return result;
}

//编写一个count_chars函数，该函数在第一个参数中进行查找，并返回chars中被匹配字符的个数。
int count_chars(char const*str,char const *chars)
{
    char const *tmp = str;
    int count = 0;
    while (*chars)
    {
        tmp = str;
        while (*tmp)
        {
            if (*tmp == *chars)
            {
                count++;
                break;
            }
            tmp++;
        }
        chars++;
    }
    return count;
}

//编写一个函数，原型：palindrome(char *str)，如果参数字符串是回文就返回1，不是回文返回
//(回文:Madam ,I'm Adam.忽略所有非字母字符)
int palindrome(char *str)
{
    char *tmp = str;
    while (*str)
        str++;
    str-=1;
    while (tmp<str)
    {
        if (*tmp>='a' && *tmp<='z' || *tmp>='A' && *tmp<='Z')
        {
            if (*str>='a' && *str<='z' || *str>='A' && *str<='Z')
            {
                *tmp = tolower(*tmp);
                *str = tolower(*str);
                if (*tmp != *str)
                    return 0;
                tmp++,str--;
            }
            else
                str--;
        }
        else
            tmp++;
    }
    return 1;
}

//写一个函数，找出参数2的字符串再参数1字符串中匹配的次数。
int count_target(char const* str,char *target)
{
    int count = 0;
    while (*str)
    {
        char *tmp = target;
        if (*tmp == *str)
        {
            while (*tmp)
            {
                if (*tmp == *str)
                {
                    tmp++,str++;
                }
                else
                    break;
            }
            if ('\0'==*tmp)
            {
                count++;
            }
        }
        else
           str++;
    }
    return count;
}