【C语言】字符串和内存函数详解

1. 求字符串长度 strlen

1.1 strlen 函数介绍

size_t strlen ( const char * str );

• strlen ——string length
• strlen 的头文件是 #include
• 参数指向的字符串必须要以 ‘\0’ 结束。
• strlen 是求字符串长度的函数，统计的是字符串中\0之前出现的字符个数（不包含 ‘\0’ )。
• 注意函数的返回值为size_t，是无符号的。

示例1：

#include 
#include 
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr1));
	printf("%d\n", strlen(arr2));
	return 0;
}

• arr1 是字符串，字符串的结束标志是 \0,所以 strlen 计算的是 \0之前出现的字符个数,所以是6。
• arr2 是字符，arr2 里面没有 \0, 所以 strlen 计算的时候会一直往下计算直到遇到 \0 才会停下，是个随机值。

示例2

#include 
#include 
int main()
{
	char arr1[] = "abc";
	char arr2[] = "abcdef";
	if (strlen(arr1) - strlen(arr2) > 0)
		printf(">\n");
	else
		printf("<\n");
	return 0;
}

• strlen 计算出 arr1 的值是3，arr2 的值是6，arr1 - arr2 = -3 <0; 怎么会打印 > 呢？
• 因为函数的返回值为size_t，是无符号的。arr1 和 arr2 的返回值是无符号的，两个无符号的值相减的结果也是无符号的，即使结果是-3 也会被当成无符号数处理，一定会大于0，打印的结果就是 > 。

1.2 strlen 函数的模拟实现

方法一：计数器方式

//计数器方式
#include 
#include 
size_t my_strlen(const char* str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

方法二：指针-指针的方式

//指针-指针的方式
#include 
#include 
#include 
size_t my_strlen(const char* str)
{
	assert(str);//确保str不为空指针
	const char* start = str;
	const char* end = str;
	while (*end != '\0')
	{
		end++;
	}
	return end - start;
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

方法三：不能创建临时变量计数器(递归求解)

//不能创建临时变量计数器
#include 
#include 
size_t my_strlen(const char* str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

2. 长度不受限制的字符串函数

长度不受限制的字符串函数和字符串长度没有关系，只关心 \0 。

2.1 strcpy

2.1.1 strcpy 函数介绍

• strcpy 的头文件是 #include
• 源字符串必须以 ‘\0’ 结束。
• strcpy 会将源字符串中的 ‘\0’ 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可变。注意：常量字符串不可以修改不可以放到目标空间里。

示例：

//strcpy 函数的使用
#include 
#include 
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello word";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

2.1.1 strcpy 函数模拟实现

//strcpy 函数的模拟实现
#include 
#include 
#include 
char* my_strcpy(char* dest, const char* str)//str加const确保str不被修改
{
	assert(dest);
	assert(str);
	char* ret = dest;
	while (*dest++ = *str++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "abc";
	char arr2[] = "hello word";
	printf("%s\n", my_strcpy(arr1, arr2));
	return 0;
}

2.2. strcat

2.2.1 strcat 函数介绍

• strcat 字符串追加函数，头文件是 #include ，把源字符串追加到目标字符串，在目标字符串的\0后处开始追加，遇到源字符串的\0停止追加。追加的时候会把源字符串的\0一起追加到目标字符串。
• 源字符串必须以 ‘\0’ 结束。
• 目标空间必须有足够的大，能容纳下源字符串的内容。
• 目标空间必须可修改。
• strcat 不可以自己追加自己，容易出现死循环。

示例：

//strcat  字符串追加函数
#include 
#include 
int main()
{
	char arr1[20] = "hello \0xxxxxxxx";
	char arr2[] = "word";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

2.2.2 strcat 函数模拟实现

#include 
#include 
char* my_strcat(char* dest, const char* str)
{
	//1.找目标空间中的\0
	char* cur = dest;
	while (*cur != '\0')
	{
		cur++;
	}
	//2.拷贝源头数据到\0之后的空间
	while (*cur++ = *str++)
	{
		;
	}
	return dest;
}
int main()
{
	char arr1[20] = "hello \0xxxxxxxx";
	char arr2[] = "word";
	printf("%s\n", my_strcat(arr1, arr2));
	return 0;
}

2.3strcmp

2.3.1 strcmp 函数介绍

1. strcmp 是比较字符串的库函数，头文件是 #include ，比较的是对应位置上字符的大小（ASCII码值的大小）而非长度
2. 标准规定

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

示例：

#include 
#include 
int main()
{
	/*char arr1[] = "abcdef";
	char arr2[] = "abc";*/
	
	/*char arr1[] = "abc";
	char arr2[] = "abcd";*/

	char arr1[] = "abc";
	char arr2[] = "abc";

	int ret = strcmp(arr1, arr2);
	if (ret > 0)
		printf("arr1>arr2\n");
	else if (ret < 0)
		printf("arr1);
	else
		printf("arr1==arr2\n");
	
	printf("%d\n", ret);
	return 0;
}

2.3.2 strcmp 函数模拟实现

#include 
#include 
#include 
//方法一
/*int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == s2)
	{
		if (*s1 == '\0')
		{
			return 0;
		}
		*s1++;
		*s2++;
	}
	if (*s1 > *s2)
		return 1;
	else
		return -1;
}*/

//方法二
int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	return *s1 - *s2;
 //返回两个字符ASCII相减的值
}

int main()
{
	/*char arr1[] = "abcdef";
	char arr2[] = "abc";*/

	char arr1[] = "abc";
	char arr2[] = "abcd";

	/*char arr1[] = "abc";
	char arr2[] = "abc";*/

	int ret = my_strcmp(arr1, arr2);
	if (ret > 0)
		printf("arr1>arr2\n");
	else if (ret < 0)
		printf("arr1);
	else
		printf("arr1==arr2\n");

	printf("%d\n", ret);
	return 0;
}

3. 长度受限制的字符串函数介绍

3.1 strncpy 函数介绍

• strncpy 的头文件是 #include
• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

示例：

#include 
#include 
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "xxxx";
	strncpy(arr1, arr2, 3);
	printf("%s\n", arr1);
	return 0;
}

3.2 strncat 函数介绍

• strncat 的头文件是 #include
• strncat 和 strncpy 的使用非常相似，strncat是追加num个字符从源字符串到目标空间。
• strncat 追加完成后会自己添加\0。
• strncat 可以自己追加自己

示例1

#include 
#include 
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "xyz";
	strncat(arr1, arr2, 2);
	printf("%s\n", arr1);
	return 0;
}

示例2

#include 
#include 
int main()
{
	char arr1[20] = "abc";
	strncat(arr1, arr1, 3);
	printf("%s\n", arr1);
	return 0;
}

3.3 strncmp 函数介绍

• strmcpy 的头文件是 #include
  strncmp 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

示例：

#include 
#include 
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "abd";
	int ret = strcmp(arr1, arr2, 3);
	printf("%d\n", ret);
	return 0;
}

4. 字符串查找

4.1 strstr

4.1.1 strstr 函数介绍

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

• strstr 字符串查找函数，头文件是 #include ，在一个字符串中查找另外一个字符串是否存在，如果存在，则返回子串第一次出现的位置；不存在，则返回NULL。
• 如果找到了该子串，会从找到的地方开始输出。

示例

#include 
#include 
int main()
{
	char arr1[] = "abcdefabcdef";
	char arr2[] = "def";
	char* p = strstr(arr1, arr2);
	if (p == NULL)
	{
		printf("不存在\n");
	}
	else
	{
		printf("%s\n", p);
	}
	return 0;
}

4.1.2 strstr 函数模拟实现

#include 
#include 
char* my_strstr(const char* str1, const char* str2)
{
	const char* s1 = str1;
	const char* s2 = str2;
	const char* p = str1;
	while (*p)
	{
		s1 = p;
		s2 = str2;
		while ((*s1 != '\0') && (*s2 != '\0') && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)p;//找到了
		}
		p++;
	}
	return NULL;//找不到子串
}
int main()
{
	char arr1[] = "abcdefabcdef";
	char arr2[] = "fab";
	char* p = my_strstr(arr1, arr2);
	if (p == NULL)
	{
		printf("不存在\n");
	}
	else
	{
		printf("%s\n", p);
	}
	return 0;
}

4.2 strtok 函数介绍

char * strtok ( char * str, const char * sep );

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

示例：

#include 
#include 
int main()
{
	char arr[] = "[email protected]";
	char buf[100] = { 0 };
	strcpy(buf, arr);//将数据拷贝一份，处理buf中arr数组的内容
	const char* sep = "@.";//sep定义了用作分隔符的字符集合
	char* str = NULL;
	for (str = strtok(buf, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s\n", str);
	}
	return 0;
}

5. 错误信息报告 strerror

strerror 函数介绍

char * strerror ( int errnum );

sterror 的头文件是 #include ，把错误码转换成错误信息

示例1：

#include 
#include 
int main()
{
	printf("%s\n", strerror(0));
	printf("%s\n", strerror(1));
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	printf("%s\n", strerror(4));
	return 0;
}

这边的0、1、2、3、4是C语言中库函数报错的时候的错误码。

示例2：

//errno 把错误码记录错误码的变量中
//errno C语言提供的全局的错误变量
#include 
#include 
#include //必须包含头文件
int main()
{
	FILE* pf = fopen("test.test", "r");
	if (pf == NULL)//文件读取失败
	{
		perror("fopen");//打印的依然是error 变量中错误码对应的信息
		//perror = printf + sterror
		printf("%s\n", strerror(errno));//打印出文件读取失败的原因
		return 1;
	}
	//读文件
	fclose(pf);
	pf = NULL;
	return 0;
}

6. 字符分类函数

7. 字符转换函数

int tolower ( int c );
int toupper ( int c );

• 转换函数把字母大写转换成字母小写；或者把字母小写转换成字母大写。
• tolower 函数返回其参数对应的小写形式
• toupper 函数返回其参数对应的大写形式
• 如果函数的参数并不是处于适当大小写状态的字符（即 toupper 的参数不是小写字母或者 tolower 的参数不是大写字母），函数将不修改参数直接返回。

8. 内存操作函数

8.1 memcpy

8.1.1 memcpy 函数介绍

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

• memcpy 是内存拷贝函数，头文件是 #include ；num的单位是字节。
• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到 ‘\0’ 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。
• memcpy 的参数类型是void*可以接收任意类型的数据。

示例：

#include 
#include 
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0};
	memcpy(arr2, arr1, 20);//把arr1的前20个字节的数拷贝到arr2里面去，一个int是4字节
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

8.1.2 memcpy 函数模拟实现

#include 
#include 
#include 
void* my_memcpy(void* dest, void* src, size_t num)
{
	void* ret = dest;
	assert(dest);
	assert(src);//断言，让dest和src不为空指针
	while (num--)
	{
		*(char*)dest = *(char*)src;//一个字节一个字节的处理
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0};
	my_memcpy(arr2, arr1, 20);//把arr1的前20个字节的数拷贝到arr2里面去
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

8.2 memmove

8.2.1 memmove 函数介

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

• memmove和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• memcpy 只需要实现不重叠的拷贝就可以了。
• memmove 是需要实现重叠内存的拷贝。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

示例：

#include 
#include 
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1+2, arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

8.2.2 memmove 函数模拟实现

#include 
#include 
#include 
void* my_memmove(void* dest, void* src, size_t num)
{
	void* ret = dest;
	assert(dest);
	assert(src);//断言，让dest和src不为空指针
	if (dest < src)//1 前->后
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;//一个字节一个字节的处理
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else //2 3 后->前
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1+2, arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

图解：

8.3 memcmp 函数介绍

memcmp 的头文件是 #include
memcmp 比较从ptr1和ptr2指针开始的num个字节。一个字节一个字节比较。

示例：

#include 
#include 
int main()
{
	int arr1[] = { 1,2,3,4,5 };//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00...
	int arr2[] = { 1,2,3,0,0 };//01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00...
	int ret = memcmp(arr1, arr2, 13);
	printf("%d\n", ret);
	return 0;
}

8.4 memset 函数介绍

• memset 内存设置函数，头文件 #include
• 将 ptr 设置为 value 值，num个字节。以字节为单位修改内存。

#include 
#include 
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	memset(arr, 0, 9);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

本章到这里就结束啦，如果有哪里写的不好的地方，请指正。
如果觉得不错并且对你有帮助的话请给个三连支持一下吧！
Fighting!!!✊