C语言字符串函数以及内存函数（strlen、strcpy、strstr、strtok、memset、memmove等）

一、字符串函数

C语言当中的字符串其实就是以 \0 结尾的字符数组，所以 \0 就是字符串的结束标志。例如 char arr[] = " hello "; 中，编译器会自动在 o 后面自动补齐 \0，但是如果采用这种方式的话，编译器就不会自动补齐了 char arr1[] = { ‘h’, ‘e’, ‘l’, ‘l’, ‘o’ };。合理使用下面的字符串函数，可以大大增加开发的效率。

strlen 函数

strlen 函数是用来求字符串长度的函数，字符串的长度是 \0 之前字符的个数。

strlen 函数的定义：
size_t strlen( const char *string );
求字符串的长度，并不会对字符串进行修改，所以使用了 const 修饰。
这里的 size_t 是 unsigned int 无符号整数。

模拟实现 strlen 函数

方法一（计数器）：

int my_strlen(const char* ch)
{
	assert(ch);
	int count = 0;
	while (*ch != '\0')
	{
		count++;
		ch++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	int res = my_strlen(arr);
	printf("%d\n", res);
	return 0;
}

进入函数后，只要不是 \0 就加一，直到字符串结尾。
assert 的作用是避免传入的是空字符串。

方法二（递归）：

int my_strlen(const char* ch)
{
	if (*ch != '\0')
	{
		return 1 + my_strlen(ch + 1);
	}
	return 0;
}

只要不是 \0，地址加一，继续使用此函数，直到最后。

方法三（地址减地址）：

最后一个字符的地址减去第一个字符的地址，就可以得到它们之间的个数

int my_strlen(char* end)
{
	char* start = end;	//拿到第一个字符地址
	while (*end != '\0')
	{
		end++;  //直到最后一个字符
	}
	return end - start;
}

strcpy 函数

strcpy 函数是字符串拷贝函数，也就是将一个字符串复制到另一个字符串中。
char* strcpy(char *strDestination,
        const char *strSource );
strcpy 函数将 strSource(包括终止空字符)复制到 strDestination 指定的位置，也就是会将源字符串的内容以及 \0 拷贝到目标空间。

使用 strcpy 函数注意问题：

• 源字符串必须以 \0 结束。如果没有字符串结束标志，那么就不知道究竟到哪里字符串才结束，也就不能正常拷贝。
• 目标空间必须够存放源字符串的内容。
• 目标空间需可变。

模拟实现 strcpy 函数

char* my_strcpy(char* des, char* src)
{
	assert(des && src);	//防止目标空间和源字符串为空
	char* s = des;
	while (*src != '\0')
	{
		*des++ = *src++;
	}
	return s;
}

strcat 函数

strcat函数将strSource附加到strDestination，并以空字符结束结果字符串。
char* strcat(char *strDestination,
       const char *strSource );
简而言之就是，将参数2 (abc) 和参数1 (123) 拼接起来赋值给参数1 (变成123abc)。

和 strcpy 函数一样，strcat 函数也需要注意以下几个细节：

• 源字符串必须以 \0 结束。
• 目标空间必须够存放源字符串的内容。
• 目标空间需可变。
• 不能自己追加自己。如果自己追加自己。那第一个字符就把 \0 给替换了，那就找不到结束的位置，就会一直追加，所以不能自己追加自己。

模拟实现 strcat 函数

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* res = dest;
	while (*dest)
	{
		dest++;		//找到目标字符串的结束位置
	}
	//将源字符串复制到目标字符串
	while (*dest++ = *src++)
	{
		;
	}
	return res;
}

strcmp 函数

字符串比较函数：
int strcmp( const char *string1, const char *string2 );
用来比较两个字符串（比较的是ASCII码值）:
返回值         Relationship of string1 to string2
 < 0           string1 less than string2
  0           string1 identical to string2
 >0           string1 greater than string2

具体看下面例子：

//不同编译器，返回值可能不一样
int main()
{
	printf("%d\n", strcmp("abc", "aba"));	//1
	printf("%d\n", strcmp("abc", "abc"));	//0
	printf("%d\n", strcmp("abc", "abd"));	//-1
	printf("%d\n", strcmp("abc", "ab"));	//1
	return 0;
}

模拟实现 strcmp 函数

int my_strcmp(char* str1, char* str2)
{
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	//这里不一定返回-1，返回的是两个字符的ASCII码值的差值。
	return *str1 - *str2;
}
int main()
{
	printf("%d\n", my_strcmp("abc", "aba"));	//2
	printf("%d\n", my_strcmp("abc", "abc"));	//0
	printf("%d\n", my_strcmp("abc", "abd"));	//-1
	//99，abc比ab多了c，而c的ASCII码值为99，所以返回99
	printf("%d\n", my_strcmp("abc", "ab"));		//99
	return 0;
}

strstr 函数

char *strstr( const char *string, const char *strCharSet );
strstr 函数的作用是：返回一个指向 strCharSet 在 string 中第一次出现的指针。也就是在参数一中 (abcdef)，如果包含参数二 (cdef) 的话，就返回参数一中第一次出现参数二位置的指针 (c 的地址)，不包含则返回一个空指针。

示例代码：

模拟实现 strstr 函数

函数实现过程：

具体实现代码：

char* my_strstr(const char* str1, const char* str2)
{
	const char* s1 = str1;
	const char* s2 = str2;
	const char* p = str1;
	if (*str2 == '\0')
		return (char*)str1;
	while (*p)
	{
		s1 = p;
		s2 = str2;
		while (*s1 && *s2 && (*s1==*s2))
		{
			s1++;
			s2++;
		}
		if (*s2=='\0')
		{
			return (char*)p;
		}
		p++;
	}
	return NULL;
}

strtok 函数

char *strtok( char *strToken, const char *strDelimit );
注意细节：

• 第一个参数指定一个字符串，包含了0或多个由 strDelimit 字符串中一个或多个分隔符分隔的标记。
• strtok 函数找到 strToken 中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记。（此函数会改变被操作的字符串，所以使用 strtok 函数时，参数一的字符串一般都是临时拷贝的内容并且可修改）
• 此函数的参数一不为 NULL ，函数将找到 strToken 中第一个标记，函数将保存它在字符串中的位置。
• 此函数的第一个参数为 NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
• 如果字符串不存在更多的标记，则返回 NULL 指针。

上面不太好理解，还是直接用代码演示：

我们也可以这样使用：

以上就是C语言中常见的字符串库函数的使用及说明，使用这些库函数时需要引入 <string.h> 头文件。

二、内存函数

memcpy函数

void *memcpy( void *dest, const void *src, size_t count );
memcpy 函数是内存拷贝函数，将 src 中 count 个字节拷贝到 dest 中。如果源地址和目的地址重叠，则不保证复制重叠区域内源地址的原始字节后再被覆盖。

模拟实现 memcpy函数

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	char* res = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return res;
}

memcpy 函数适用于拷贝内存不重叠部分，例如：
在数组{1，2，3，4，5，6，7，8，9}中，想把1，2，3，4 拷贝到 3，4，5，6位置上，期望数组变成{1，2，1，2，3，4，7，8，9}，但是使用 memcpy 函数后，结果不一定会达到我们所期望的，为了避免这种拷贝内存重叠的情况，我们可以使用 memmove 函数。

memmove 函数

void *memmove( void *dest, const void *src, size_t count );
memmove 函数从 src 复制字符的字节数到 dest，如果源区域和目标区域的某些区域重叠，memmove 确保在重叠区域的原始源字节被复制后再被覆盖。

模拟实现 memmove 函数

dest 和 src 在不同位置的情况：

具体实现代码：

void* my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* res = dest;
	if (dest<src)
	{	//从前往后拷贝
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{	//从后向前拷贝
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return res;
}

memcmp 函数

int memcmp( const void *buf1, const void *buf2, size_t count );
memcmp 函数比较 buf1 和 buf2 的 count 字节，并返回指示它们之间关系的值，返回值和上面的 strcmp 一样，buf1 大于 buf2，返回1，等于返回0，小于返回 -1。

使用也比较简单：

 int main()
{
	double arr[] = { 1.0001, 2.0, 3.0, 4.0, 5.0 };
	double arr1[] = { 1.0, 2.0, 3.0, 4.0, 5.0 };
	printf("%d\n", memcmp(arr, arr1,8));	//返回1
	return 0;
}

memset 函数

void *memset( void *dest, int c, size_t count );
memset 函数将 dest 的 count 字节设置为字符 c。

代码演示：

int main()
{
	char arr[] = "Hello    World!";	//hello和world之间有4个空格	
	memset(arr+5, '*', 4);
	printf("%s\n", arr);	//输出：Hello****World!
	
	char arr1[] = "abcdef";
	memset(arr1, '#', 3);
	printf("%s\n", arr1);	//输出：###def
	return 0;
}

使用上面的内存函数需要引入 <string.h> 或者 <memory.h> 头文件。

以上就是C语言里常见的字符串函数和内存函数，如有错误，欢迎在评论区指正交流。