C语言字符串函数

 

一，strlen

求字符串长度

 size_t strlen ( const char * str );

字符串已经'\0'作为结束标志，strlen函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0'）

参数指向的字符串必须要以'\0'结束

注意参数的返回值为szie_t ，是无符号的

代码模拟实现：

size_t my_strlen(const char*str)
{
	size_t count = 0;
	while (*str)
	{
		count++;
		str++;
	}

	return count;
}

 

二，strcp

char* strcpy(char * destination, const char * source );

源字符串必须是以'\0'结束

会将源字符串中的'\0'拷贝到目标空间

目标空间必须足够大，以确保能存放源字符串

目标空间必须可变

char *my_strcpy(char * dest, const char *src)
{
	char* ret = dest;
	assert(dest !=NULL);
	assert(src !=NULL);
	while ( (*dest++) = (*src++))
	{
	    ;
	}
	return ret;
}

 

三，strcmp

int strcmp ( const char * str1, const char * str2 );

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

int my_strcmp (const char * src, const char * dst)
{
int ret = 0 ;
assert(src != NULL);
assert(dest != NULL);
while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
   {
       ++src, ++dst;
   }
if ( ret < 0 )
   {
       ret = -1 ;
   }
else if ( ret > 0 )
   {
     ret = 1 ;
   }
return( ret );
}

 

四，strstr

char * strstr ( const char *str2, const char * str1);

返回str1中第一次出现str2的指针，如果str2不是str1的一部分，则返回空指针。

匹配过程不包括终止的空字符，但它在此停止。

char *my_strstr(char *str1, const char *str2)
{
	char * cp = (char*)str1;
	char *s1;
	char *s2;
	if (!*str2)
	{
		return ((char*)str1);
	}
	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;
		while ( *s1 && *s2 && (*s1-*s2))
		{
			s1++;
			s2++;
		}
		if (!*s2)
		{
			return (cp);
		}
		cp++;
	}
	return (NULL);
}

 

五，memcpy

void * memcpy ( void * destination, const void * source, size_t num );

函数memcpy从source的位置开始后复制num字节的数据到destination的内存位置

这个函数在遇到'\0'的时候并不会停下来

如果source和destination有任何的重叠，复制的结果都是未定义的。

void * my_memcpy(void *dst,  const void *src, size_t count)
{
	void *ret = dst;
	assert(dst);
	assert(src);
	while (count--)
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}

六，memmove

void * memmove ( void * destination, const void * source, size_t num );

和memcpy的差别就是memmove函数处理的源内存块和目标内存块的是可以重叠的

如果源空间和目标空间出现重叠，就得使用memmove函数处理

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);
}