strcat，strcmp，strlen，strcpy函数

// strlen函数的实现

int my_strlen(char* const s) 
{
    char *p = s;

    while(*p++);

    return p - s - 1;
}

 strlen计算给定字符串的长度，不包括 '\0' 在内

// strcmp函数的实现

int my_strcmp(const char *str, const char *ptr)
{
    int ret=0;

    while(!(ret = *(unsigned char*)str - *(unsigned char*)ptr) && *str)
    {
        str++;
        ptr++;
    }

    if(ret < 0)
    {
        return -1;
    }
    else if(ret > 0)
    {
         return 1;
    }
    return 0;
}

// 
int strcmp(const char *str1,const char *str2)
{
    assert((*str1!='\0' && *str2!='\0')); //assert(e) e条件不成立，程序结束
    while (*str1 && *str2 && *str1==*str2)
    {
        str1++;
        str2++;
    }

    return *str1-*str2;
}

strcmp比较两个字符串的大小

// strcpy函数的实现

char *my_strcpy(char *str, const char *ptr)
{
    if(str == NULL || ptr == NULL)
    {
        return NULL;
    }
    char *ret = str;
 
    while((*p++ = *s++) != '\0'); // 连 '\0' 复制 
 
     return ret;
}

char *strcpy(char *str, const char *src)
{
    assert((str != NULL) &&  (src != NULL));

    char *address = str;

    while(*src != '\0')   // '\0 '没有复制
    {
        *str++ = *src++;
    }

    *str = '\0';

    return address;
}

        把src所指的由NULL结尾的字符串复制到由dst所指的字符串中，src 和 dst不可以相同，dst必有足够的空间存放复制的字符串。 

        使用strcpy是危险的，因为函数本身是不检查dst指向的空间是否足够存储需要复制的字符串，导致的一个潜在隐患就是字符串溢出。因此，大多数情况下都是用strncpy无疑更加保险的：

 

char *my_strncpy(char *dst, const char *src, size_t n)；

// strncpy函数
char *my_strncpy(char *dst, const char *src, size_t n)
{
	assert(NULL!=dst && NULL!=src);

	char *p = dst;

	while(n)
    {
		if((*dst++ = *src++) == '\0')
        {
			break;
        }
		n--;
	}

	return p;
}

         strcpy将一个字符串复制到另一个字符串中，包括 '\0'

         strncpy将一个字符串下n个字符复制到另一个字符串中

// strcat函数

char *my_strcat(char *str, const char *ptr)
{
    assert(str != NULL && NULL != ptr);

    char *dst = str;
    while(*str++);
    str = str - 1;

    while(*ptr) 
    {
        *str++ = *ptr++;
    }
    *str = '\0';

    return dst;
}

        strcat将一个字符串连接到另一个字符串后面。

         strcat也是不安全的，因为也对缓冲区足够存放连接的字串进行了假设。我们应该使用更安全的：

char *strncat(char *s1, const char *s2, size_t n);

        strcat将一个字符串n个字符连接到另一个字符串后面。