自定义实现字符串处理函数

1.strlen

int strlen(const char *str)
{
    if(NULL == str) 
        return 0;
    int len = 0;
    while((*str++) != '\0')
        len++;
    return len; 
}

2.strcmp

int strcmp(const char *str1,const char *str2)
{
    if(NULL == str1 && NULL == str2)
        return 0;
    int ret = 0;
    while(!(ret=*(unsigned char*)str1 - *(unsigned char*)str2) && *str1) //依次比较各个字符是否相等
    {
        str1++;
        str2++;
    }
    
    if(ret < 0)
    {
        ret = -1;
    }
    else if(ret > 0)
    {
        ret = 1;
    }
    
    return ret;
}

3.strcpy

char* strcpy(char *strDestination,const char* strSource)
{
    if(NULL == strDestination && NULL == strSource)
        return NULL;
    
    char *strD = strDestination;
    while((*strDestination++ = *strSource++) != '\0');   
    return strD;
}

4.strcat

char *strcat(char *strDest,const char *strSrc)
{
    char* address= strDest;
    if(NULL == strDest && NULL == strSrc)
        return NULL;
        
    while(*strDest++);
    while(*strDest++ = *strSrc++);
    return address;      
}

5.strstr

char* strstr(const char* dest, const char* src) {
	char* tdest = dest;
	char* tsrc = src;
	int i = 0;//tdest 主串的元素下标位置，从下标0开始找，可以通过变量进行设置，从其他下标开始找！
	int j = 0;//tsrc 子串的元素下标位置
	while (i < strlen(tdest) && j < strlen(tsrc))
	{
		if (tdest[i] == tsrc[j])//字符相等，则继续匹配下一个字符
		{
			i++;
			j++;
		}
		else//在匹配过程中发现有一个字符和子串中的不等，马上回退到 下一个要匹配的位置
		{
			i = i - j + 1;
			j = 0;
		}
	}
	//循环完了后j的值等于strlen(tsrc) 子串中的字符已经在主串中都连续匹配到了
	if (j == strlen(tsrc))
	{
		return tdest + i - strlen(tsrc);
	}
 
	return NULL;
}

6.memcpy

void *memcpy(void *dst, const void *src, size_t size)
{

    char *psrc;  //源地址
    char *pdst;  //目标地址
 
    if(NULL == dst || NULL == src)
    {
        return NULL;
    }

    if((src < dst) && (char *)src + size > (char *)dst)  //源地址在前，需要自后//向前拷贝
    {
        psrc = (char *)src + size - 1;
        pdst = (char *)dst + size - 1;
        while(size--)
        {
            *pdst-- = *psrc--;
        }
    }
    else   //源地址在后，直接逐个拷贝*pdst++ = *psrc++即可
    {
        psrc = (char *)src;
        pdst = (char *)dst;
        while(size--)
        {
            *pdst++ = *psrc++;
        }
    }
    return dst;
}

7.itoa

char *itoa(int value, char *str, unsigned int radix)
{
    char list[] = "0123456789ABCDEF";
    unsigned int tmp_value;
    int i, j, k;
    if (NULL == str) {
            return NULL;
    }
    if (2 != radix && 8 != radix && 10 != radix && 16 != radix) {
            return NULL;
    }
    i = 0;
    k = 0;
    if (radix == 10 && value < 0) {
            tmp_value = (unsigned int)(0 - value);
            str[i++] = '-';
            k = 1;
    } else {
            tmp_value = (unsigned int)value;
    }
    do {
            str[i++] = list[tmp_value%radix];
            tmp_value /= radix;
    } while(tmp_value);
    str[i] = '\0';
    //翻转
    char tmp;
    for (j = k; j < (i+k)/2; j++) {
            tmp = str[j];
            str[j] = str[i+k-j-1];
            str[i+k-j-1] = tmp;
    }
    return str;
}

8.atoi

enum Status {kValid = 0,kInvalid};
int g_nStatus = kValid;

int atoi(const char* str)
{
    g_nStatus = kInvalid;
    long long num = 0;
    if(NULL != str)
    {
        const char* digit = str;
        bool mimus = false;
        
        if(*digit == '+')
        {
            digit++;
        }
        else if(*digit == '-')
        {
            digit++;
            mimus = true;
        }
        
        while(*digit != '\0')
        {
            if(*digit >= '0' && *digit <= '9')
            {
                num = num * 10 + (*digit - '0');
                if(num > std::numeric_limits<int>::max())
                {
                    num = 0;
                    break;
                }
                digit++;
            }
            else
            {
                num = 0;
                break;
            }
        }
        
        if(*digit == '\0')
        {
            g_nStatus = kValid;
            if(mimus)
                num = 0 - num;
        }    
    }
    
    return num;
}