c语言字符串相关函数

char *strcat(char *strDest, const char *strSrc) //将源字符串加const，表明其为输入参数
{
	char *address = strDest;                        //该语句若放在assert之后，编译出错
	assert((strDest != NULL) && (strSrc != NULL)); //对源地址和目的地址加非0断言
	while(*strDest)                                //是while(*strDest!=’\0’)的简化形式
	{                                              //若使用while(*strDest++)，则会出错因为循环结束后strDest还会执行一次++,那么strDest
　　		strDest++;                             //将指向'\0'的下一个位置。要在循环体内++；因为要*strDest最后指向该字符串的结束标志’\0’。
　　	} 
　　	while(*strDest++ = *strSrc++);
　　	return address;                               //为了实现链式操作，将目的地址返回
　　}
int __cdecl strcmp (const char * src,const char * dst)
{
	int ret = 0 ;
　　	while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
		++src, ++dst;
	if ( ret < 0 )
		ret = -1 ;
	else if ( ret > 0 )
　　		ret = 1 ;
　　	return( ret );
}

char *strcpy( char *strDestination, const char *strSource )
{
	char *strTemp = strDestination;
	while(*strTemp ++ = *strSource++);
	return strDestination;
}

MSDN的标准定义： 
char *strncpy(char* strDest,const char* strSour,size_t count); 
这个函数的意思是： 
拷贝一个字符串到另外一个字符串，strDest 是目标字符串地址，strSour是源字符串地址， 
size_t是要拷贝的字符个数，当要拷贝的字符个数(size_t count)小于或等于strSour长度， 
strDest的最后不会加\0,当要拷贝的字符个数(size_t count)大于strSour长度，strDest最后会自动追加一个\0,

char * __cdecl strncpy ( char * dest, const char * source, size_t count ) 

{ 
	char *start = dest;

	while (count && (*dest++ = *source++)) /* copy string */ 
		count--;

	if (count) /* pad out with zeroes */ 
		while (--count) 
			*dest++ = '\0';

	return(start); 
}



void * memset(void* buffer, int c, int count)  
{  
    char* pvTo=(char*)buffer;  
    assert(buffer != NULL);  
    while(count-->0)  
        *pvTo++=(char)c;  
    return buffer;  
}  

void *memcpy( void *dest, const void *src, size_t count )
{
	ASSERT((dest != NULL)&&(src != NULL));
	char *temp_dest = (char *)dest;
	char *temp_src = (char *)src;
        while(count--)
	// 不对是否存在重叠区域进行判断
	{
		*temp_dest++ = *temp_src++;
	}
	return dest;
}
void *memmove(void* dst,const void* src, size_t count)
{
	assert((dst!=NULL)&&(src!=NULL));
	char *pDst=(char *)dst;
        char *pSrc=(char *)src;
	//不存在重叠的内存区域
	if((pDst<=pSrc)||(pDst>=pSrc+count))
	{
		while(count--)
		{
			*pDst++=*pSrc++;
		}
	}
	else
	//存在重叠区域，从尾部开始
	{
		pDst+=count-1;
		pSrc+=count-1;
		while(count--)
		{
			*pDst--=*pSrc--;
		
		}
	}
	return dst;
}
int atoi(const char* p)
{
	assert(p!=NULL);
	int neg_flag=0;//标记是否为负号
	int result=0;
	if(p[0]=='+'||p[0]=='-')  
		neg_flag = (*p++!='+');//是负号则neg_flag不为0
	while(*p>='0'&&*p<='9')  
		result = result*10 + (*p++ -'0');
	return neg_flag ? 0-result : result;
}