常见字符串函数及其模拟实现

在程序中，我们经常需要对字符串进行相关处理，那么开门见山，我将一一介绍常见的字符串函数。

目录

1.strlen函数

2.strcpy函数和strncpy函数

3.strcat函数和strncat函数

4.strcmp函数和strncmp函数

5.memcpy函数和memmove函数

6.strstr函数

7.strtok函数

8.strerror函数

---

1.strlen函数

定义：size_t strlen ( const char * str )

该函数用于求字符串的长度，以'\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数，该函数较为简单，下面我们看strlen函数的模拟实现

3种模拟实现：

//1.计数器实现
unsigned int my_strlen2(const char* arr)
{
	assert(arr);
	int count = 0;
	while (*(arr++) != '\0')
	{
		count++;
	}
	return count;
}

//2.递归实现
unsigned int my_strlen1(const char* arr)
{
	assert(arr);
	if (*arr != '\0')
		return my_strlen1(arr + 1) + 1;
	else
		return 0;
}

//3.指针相减得元素个数的方式
unsigned int my_strlen3(const char* arr)
{
	char* tmp = arr;
	while (*arr != '\0')
		arr++;
	return arr - tmp;
}

2.strcpy函数和strncpy函数

strcpy函数

定义：char* strcpy(char * destination, const char * source )

该函数用于拷贝字符串，将src(source)的字符串内容拷贝到dest(destination)中，dest 必须有足够的空间放置 src 所包含的字符串（包含结束符NULL），返回值为dest字符串的起始地址

模拟实现：

char* my_strcpy(char* p1,const char* p2)
{
	char* tmp = p1;
  assert(p1&&p2);
	while ((*p1++ = *p2++) != '\0')
	{
		;
	}
	return tmp;
}

strncpy函数-定义：char *strncpy( char *strDest, const char *strSource, size_t n)

同样用于拷贝字符串，其相比strcpy，多了参数n用于指定需要拷贝的长度，会将字符串src前n个字符拷贝到字符串dest。strncpy()不会向dest追加结束标记'\0'，因此如果src的前n个字节不含'\0'字符，则结果不会以'\0'字符结束，可能导致错误。如果src的长度小于n个字节，则以'\0'填充dest直到复制完n个字节，因此若n的值过大，则其将其余数据全置为'\0'的行为会导致效率低下

关于两者区别参考原文:strcpy()与strncpy()的区别:http://t.csdn.cn/bNlxC

模拟实现:

char* my_strncpy(char* dest, const char* src, size_t num)
{
	assert(dest && src);
	char* tmp = dest;
	size_t n = strlen(src);
	int p = num - n;
//如果指定num的长度小于等于字符串长度
	if (num <= n)
	{
		while (num--)
			*dest++ = *src++;
	}
//否则多余的部分以'\0'填充
	else
	{
		while (n--)
			*dest++ = *src++;
		while (p--)
			*dest++ = '\0';
	}
	return tmp;
}

3.strcat函数和strncat函数

strcat函数-定义：char *strcat( char *strDestination, const char *strSource )

将src字符串内容向dest进行追加，返回值同样为dest字符串的起始地址，且dest需要有足够大的空间容纳下源字符串的内容。

模拟实现：

char* my_strcat(char* p1, char* p2)
{
	assert(p1 && p2);
	char* tmp = p1;
	while (*p1！='\0')
		p1++;
	while (*p1++ = *p2++)
	{
		;
	}
	return tmp;
}

strncat函数-定义：char *strncat( char *strDest, const char *strSource, size_t n)

同样多了一个参数n,用来指定追加字符数目，strncat()将会从字符串src的开头拷贝n个字符到dest字符串尾部，dest要有足够的空间来容纳要拷贝的字符串。如果n大于字符串src的长度，那么仅将src全部追加到dest的尾部。strncat()会将dest字符串最后的'\0'覆盖掉，字符追加完成后，再追加'\0'。

模拟实现:
 

char* my_strncat(char* dest, const char* src, size_t num)
{
	assert(dest && src);
	char* tmp = dest;
	while (*dest != '\0')
		dest++;
	while ((num--) && (*dest++ = *src++))
	{
		;
	}
    //若num<字符串长度，则需向末尾追加'\0'
	if ((num+1) == 0)
	{
		*dest='\0';
	}
	return  tmp;
}

4.strcmp函数和strncmp函数

strcmp函数-定义:int strcmp( const char *string1, const char *string2 )

strcmp函数用于比较字符串大小，需要注意的是，比较规则并不是按字符串长度决定，而是将两个字符串自左至右逐个字符相比（按ASCII码值大小比较），直到出现不同的字符或遇到’\0’为止。按照C语言规定，返回值遵守以下情况，因此不同编译器的strcmp返回值并不一定相同，但正负按照以下规则：

< 0	string1 less than string2
0	string1 identical to string2
> 0	string1 greater than string2

模拟实现:
 

int my_strcmp(const char* p1, const char* p2)
{
	assert(p1 && p2);
	while (*p1==*p2)//字符相等
	{
		if (*p1 == '\0')//字符相等且为'\0'，则字符串完全相等，返回0
			return 0;
		p1++;
		p2++;
	}
	return *p1 - *p2;//字符不等
}

strncmp函数-int strncmp( const char *string1, const char *string2, size_t n )

多一个参数n，可指定比较长度，即比较给定两个字符串前n个字符的大小情况

模拟实现:

int my_strncmp(const char* str1, const char* str2, size_t n)
{
	while ((*str1 == *str2) && *str2 != '\0' && (n--))
	{
		str1++;
		str2++;
	}
	if (*str2 == '\0')
		return 0;
	return *str1 - *str2;
}

5.memcpy函数和memmove函数

memcpy函数

定义:void* my_memcpy(void* dest, void* src,size_t count)

能从存储区 str2 复制 n 个字节到存储区 str1

• str1 -- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
• str2 -- 指向要复制的数据源，类型强制转换为 void* 指针。
• n -- 要被复制的字节数。

模拟实现:

void* my_memcpy(void* dest, void* src,size_t count)
{
    assert(dest && src);
	char* p1 = (char*)dest;
	char* p2 = (char*)src;
	while (count--)
	{
		*p1++ = *p2++;
	}
	return dest;
}

 然而需要注意，若str2内容与str1内容有重叠区域，则可能导致复制出现问题，稍后给出对比，下面先介绍memmove函数

memmove函数

定义:void *memmove( void *dest, const void *src, size_t count )

该函数用法和memcpy函数基本相同，并且相当于memcpy的优化版本，其可以较好解决由于重叠区域而产生的问题

模拟实现:

void* my_memmove(void* dest, void* src, size_t count)
{
	assert(dest && src);
	char* p1 = (char*)dest;
	char* p2 = (char*)src;
	//(dst <= src || (char*)dst >= ((char*)src + count
	if (p2 >= p1 || p1 >= p2 + count)
	{
		while (count--)
		{
			*p1++ = *p2++;
		}
	}
	else
	{
		p1 = p1 + count - 1;
		p2 = p2 + count - 1;
		while (count--)
		{
			*p1-- = *p2--;
		}
	}
	return dest;
}

两个函数模拟实现的区别是，memmove对情况进行了区分。例如，给定一个字符串"abcdef",若src为abc,dest为bcd,此时产生重叠区域bc,若依照memcpy函数从a开始正向复制，则复制一个字符后，母串变为"aacdef",此时src尚未复制的字符信息丢失，便会产生问题。而此时从c开始逆向复制便能解决。

归纳后我们发现，当src>dest或src<dest+count时，采取正向复制，否则采取逆向复制。这样便能够解决复制过程中src串信息丢失的问题。

6.strstr函数

定义:char *strstr( const char *p1, const char *p2 );

此函数用于查找母串p1中是否含有子串p2，若有，返回p1中p2字符串首次出现的地址。否则返回空指针NULL。

模拟实现-普通模式匹配（BF）算法：

char* my_strstr(const char* p1, const char* p2)
{
	assert(p1 && p2);
	while (*p1!='\0')
	{
		char* s1 = (char*)p1;
		char* s2 = (char*)p2;
		while ((*s1 == *s2) && *s2 != '\0')
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return (char*)p1;
		p1++;
	}
	return NULL;
}

其实现过程没有任何技巧，就是简单粗暴地拿一个串同另一个串中的字符一一比对

解决这个问题还有比较高效的方法-KMP算法,感兴趣的可以自行了解

7.strtok函数

定义:char *strtok( char *str1, const char *str2 );

其以str2字符串的任意子串为分隔符(包括str2)，将str1字符串进行分割，其会把分割后的字符串后面一个字符修改为'\0'。例如：str1为"abc-123*hello*-world",str2为"*-",则用此函数获取分割后的各字符串后，str1变为"abc\0123\0hello\0-world"

使用:第一次需传入2个字符串地址，返回值为被分割的第一个子串的地址，然后以NULL作为第一个参数，函数返回值为第2,3.....个子串的地址，直到返回值变为NULL，表示分割完毕，子串获取完成。如下:

#include <string.h>
#include <stdio.h>
 
int main () {
   char str[80] = "abc-123*hello*-world";
   const char s[2] = "*-";
   char *p;
   
   /* 获取第一个子字符串 */
   p = strtok(str, s);
   
   /* 继续获取其他的子字符串 */
   while( p != NULL ) {
      printf( "%s\n", p );
    
      p = strtok(NULL, s);
   }
   
   return 0;
}

8.strerror函数

定义:char *strerror( int errnum );

该函数返回一个指向错误字符串的指针，该错误字符串描述了错误类型

errnum为错误号，通常为errno,在错误发生时会被自动赋予错误号，依次对应特定错误类型。errno的头文件为errno.h

使用:

int main()
{
	printf("%s", strerror(errno));
	return 0;
}

常见字符串函数就介绍到此，希望你能有所收获