• 【C语言】字符函数、字符串函数与内存函数

    简单不先于复杂，而是在复杂之后。

    89efcc89ac61428db4d5b6639b2bd948.jpeg

    目录

    0. 前言 

    1. 函数介绍 

    1.1 strlen 

    1.1.1 介绍

    1.1.2 strlen 函数模拟实现

    1.1.2.1 计数器方法 

    1.1.2.2 递归方法 

    1.1.2.3 指针 - 指针方法 

    1.2 strcpy 

    1.2.1 介绍

    1.2.2 strcpy 函数模拟实现

    1.3 strcat

    1.3.1 介绍

    1.3.2 strcat 函数模拟实现

     1.4 strcmp

    1.4.1 介绍 

    1.4.2 strcmp 函数模拟实现   

    1.5 strncpy

     1.5.1 函数介绍

    1.6 strncat 

    1.6.1 函数介绍 

     1.7 strncmp

     1.7.1 函数介绍 

    1.8 strstr 

    1.8.1 函数介绍 

    1.8.2  strstr 函数模拟实现

    1.9 strtok 

    1.9.1 函数介绍 

    1.10  sterror

    1.10.1  函数介绍

    1.11  memcpy

    1.11.1 函数介绍 

    1.11.2 memcpy 函数模拟实现

    1.12 memmove 

    1.12.1 函数介绍 

     1.12.2 memmove 函数模拟实现

    1.13 memcmp

    1.13.1 函数介绍 

    1.14 memset 

     

    0. 前言 

    C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。

    字符串常量适用于那些对它不做修改的字符串函数。 

    1. 函数介绍 

    1.1 strlen 

    1.1.1 介绍

     

    计算字符串长度。 

    •  字符串以 '\0' 为结束标志， strlen 函数返回的是在字符串中 '\0' 前面的字符个数（不包含 \0）。
    • 参数指向的字符串必须要以 \0 结束。
    • 注意函数的返回类型是 size_t 是无符号的。
    • 学会 strlen 的模拟实现

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	//char arr[] = "abcdef";
    8. 	//a b c d e f \0
    9.  
    10. 	char arr[] = { 'w','o','w' };
    11. 	//[][][][][][][][][w][o][w][][][][][][][][]
    12.  
    13. 	int len = strlen(arr);//随机值
    14.  
    15. 	printf("%d\n", len); 
    16.  
    17. 	return 0;
    18. }

     

     

    1.1.2 strlen 函数模拟实现

    1.1.2.1 计数器方法 

     

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. size_t my_strlen(const char* str)
    6. {
    7. 	assert(*str);
    8. 	size_t count = 0;
    9. 	while (*str != '\0')
    10. 	{
    11. 		str++;
    12. 		count++;
    13. 	}
    14.  
    15. 	return count;
    16. }
    17.  
    18. int main()
    19. {
    20. 	char arr[] = "abcdef";
    21. 	size_t n = my_strlen(arr);
    22. 	printf("%d\n", n);
    23.  
    24. 	return 0;
    25. }
    1.1.2.2 递归方法 

     

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3.  
    4. size_t my_strlen(const char* str)
    5. {
    6.  
    7. 	if (*str == '\0')
    8. 	{
    9. 		return 0;
    10. 	}
    11. 	else
    12. 	{
    13. 		return 1 + my_strlen(str + 1);
    14. 	}
    15. }
    16.  
    17. int main()
    18. {
    19. 	char arr[] = "abcdef";
    20. 	size_t n = my_strlen(arr);
    21. 	printf("%d\n", n);
    22.  
    23. 	return 0;
    24. }
    1.1.2.3 指针 - 指针方法 

     

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. size_t my_strlen(const char* str)
    6. {
    7. 	assert(*str);
    8. 	char* start = str;
    9. 	while (*str != '\0')
    10. 	{
    11. 		str++;
    12. 	}
    13. 	return str - start;
    14. }
    15.  
    16. int main()
    17. {
    18. 	char arr[] = "abcdef";
    19. 	size_t n = my_strlen(arr);
    20. 	printf("%d\n", n);
    21.  
    22. 	return 0;
    23. }

    1.2 strcpy 

    1.2.1 介绍

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

    字符串拷贝。 

    •  Copies the C string pointed by source into the array pointed by destination, including the terminating null character (and stopping at that point).
    • 源字符串必须以 '\0' 结束
    • 会将源字符串中的 '\0' 拷贝到目标空间
    • 目标空间必须足够大，以确保能存放源字符串
    • 目标空间必须可变
    • 学会模拟实现

     

     

    以上为正确写法。

     因为目标地址指向一个常量字符串，这个区域不可修改，所以会引发异常，故要求目标空间必须可变。

    1.2.2 strcpy 函数模拟实现

     

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. #include
    5.  
    6. //strcpy 返回目标空间的起始地址
    7. char* my_strcpy(char* dest, const char *src)
    8. {
    9. 	//实现字符串拷贝只有需要解引用操作才能找到字符串内容
    10. 	//故两个指针不可为空指针，要对其断言
    11. 	assert(dest);
    12. 	assert(src);
    13.  
    14. 	char* ret = dest;
    15.  
    16. 	while (*src)
    17. 	{
    18. 		*dest++ = *src++;
    19. 	}
    20. 	*dest = *src;
    21.  
    22. 	return ret;
    23. }
    24.  
    25. int main()
    26. {
    27. 	char arr1[] = { "abcdef" };
    28. 	char arr2[20] = { 0 };
    29. 	my_strcpy(arr2, arr1);
    30. 	printf("%s\n", arr2);
    31.  
    32. 	return 0;
    33. }

    以上代码不够简练，可以优化：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. #include
    5.  
    6. //strcpy 返回目标空间的起始地址
    7. char* my_strcpy(char* dest, const char* src)
    8. {
    9. 	//实现字符串拷贝只有需要解引用操作才能找到字符串内容
    10. 	//故两个指针不可为空指针，要对其断言
    11. 	assert(dest && src);
    12.  
    13. 	char* ret = dest;
    14.  
    15. 	while (*dest++ = *src++)
    16. 	{
    17. 		;
    18. 	}
    19.  
    20. 	return ret;
    21. }
    22.  
    23. int main()
    24. {
    25. 	char arr1[] = { "abcdef" };
    26. 	char arr2[20] = { 0 };
    27. 	my_strcpy(arr2, arr1);
    28. 	printf("%s\n", arr2);
    29.  
    30. 	return 0;
    31. }

    这样的话 *dest++ = *src++ 这个语句就做到了既赋值又判断。

    1.3 strcat

    1.3.1 介绍

     

     字符串追加。

    • Appends a copy of the source string to the destination string. The terminating null character in destination is overwritten by the first character of source, and a null-character is included at the end of the new string formed by the concatenation of both in destination.
    • 源字符串必须以’\0‘结束。
    • 目标空间必须足够大，能容纳下源字符串的内容.
    • 目标空间必须可修改。
    • 字符串自己给自己追加，如何？

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. //字符串追加
    5. int main()
    6. {
    7. 	char arr1[20] = "hello";
    8. 	strcat(arr1, "world");
    9. 	printf("%s\n", arr1);
    10.  
    11. 	return 0;
    12. }

    1.3.2 strcat 函数模拟实现

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. //字符串追加
    6. char* my_strcat(char* dest, const char* src)
    7. { 
    8. 	assert(dest && src);
    9. 	char* ret = *dest;
    10. 	while (*dest != '\0')
    11. 	{
    12. 		dest++;
    13. 	}
    14. 	while (*dest++ = *src++)
    15. 	{
    16. 		;
    17. 	}
    18.  
    19. 	return ret;
    20. }
    21.  
    22. int main()
    23. {
    24. 	char arr1[20] = "hello ";
    25. 	my_strcat(arr1, "world");
    26. 	printf("%s\n", arr1);
    27.  
    28. 	return 0;
    29. }

    如果自己给自己追加，程序会崩溃。

    因为当把源字符串的字符逐个拷贝到目标字符串后面的时候，直到该拷贝‘\0’的时候，源字符串的‘\0‘被第一个拷贝过来的字符覆盖掉了，会陷入死循环。

    所以我们要尽量避免字符串自己给自己追加。 

     1.4 strcmp

    1.4.1 介绍 

     

    • 比较两个字符串是否相等。
    •  This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.
    • 标准规定：

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

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

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

    这种写法是在比较两个数组首元素的地址。 

     两个字符串比较是否相等，应该使用 strcmp

    一对字符在比较的时候比较的是 ASCII 码值。

    1.4.2 strcmp 函数模拟实现   

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. #include
    5.  
    6. int my_strcmp(const char* str1,const char* str2)
    7. {
    8. 	assert(str1 && str2);
    9. 	while (*str1 == *str2)
    10. 	{
    11. 		if (*str1 == '\0')
    12. 			return 0;
    13. 		str1++;
    14. 		str2++;
    15. 	}
    16. 	if (*str1 > *str2)
    17. 		return 1;
    18. 	else
    19. 		return -1;
    20. }
    21.  
    22. int main()
    23. {
    24. 	char arr1[20] = "abc";
    25. 	char arr2[20] = "abc";
    26. 	//比较一下两个字符串是否相等
    27.  
    28. 	int ret = my_strcmp(arr1, arr2);
    29.  
    30. 	if (ret < 0)
    31. 		printf("<\0");
    32. 	else if (ret == 0)
    33. 		printf("==\0");
    34. 	else
    35. 		printf(">\0");
    36.  
    37. 	//arr1 和 arr2 是数组名，是数组首元素的地址，必然不相等
    38. 	//if (arr1 == arr2)
    39. 	//{
    40. 	//	printf("==\0");
    41. 	//}
    42. 	//else
    43. 	//{
    44. 	//	printf("!=\0");
    45. 	//}
    46.  
    47. 	return 0;
    48. }

    函数还可以简化：

    1. int my_strcmp(const char* str1,const char* str2)
    2. {
    3. 	assert(str1 && str2);
    4. 	while (*str1 == *str2)
    5. 	{
    6. 		if (*str1 == '\0')
    7. 			return 0;
    8. 		str1++;
    9. 		str2++;
    10. 	}
    11. 	return (*str1 > *str2);
    12. }

    当目标空间不够时，会产生越界访问导致程序崩溃，但是函数仍然可以将大小超出目标空间的字符串拷贝。 

    这是潜在的安全隐患。

    1.5 strncpy

     1.5.1 函数介绍

     

    •  Copies the first num characters of source to destination. If the end of the source C string(which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.
    • 拷贝num个字符从源字符串到目标空间。
    • 如果源字符串小于num，在拷贝完源字符串时，在目标后面追加0，直到num个。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	char arr1[] = "abcdef";
    8. 	char arr2[] = "hello world";
    9.  
    10. 	strncpy(arr1, arr2, 5);
    11.  
    12. 	printf("%s\n", arr1);
    13.  
    14. 	return 0;
    15. }

     

    因为在源字符串后面追加了0，也就是\0, 所以在源字符串小于num时，数组里存放的虽然追加两个0，后面有字符‘f’，但是打印字符串时到第一个‘\0’ 就已经终止了，只能打印源字符串的内容。

    1.6 strncat 

    1.6.1 函数介绍 

    char * strncat ( char * destination, const char * source, size_t num );
    • Appends the first num characters of source to destination, plus a terminating null-character.
    • If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	char arr1[20] = "hello\0xxxxxxxx ";
    8. 	char arr2[] = "world";
    9.  
    10. 	strncat(arr1, arr2, 3);
    11.  
    12.  
    13. 	return 0;
    14. }

    如果 num 大于源字符串，也不会像 strncpy 一样多追加几个 \0 。

     1.7 strncmp

     1.7.1 函数介绍 

    int strncmp ( const char * str1, const char * str2, size_t num );
    • 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

     

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	char arr1[] = "abcdef";
    8. 	char arr2[] = "abc";
    9.  
    10. 	int ret = strncmp(arr1, arr2, 3);
    11. 	if (ret == 0)
    12. 		printf("==");
    13. 	else if (ret < 0)
    14. 		printf("<");
    15. 	else
    16. 		printf(">");
    17.  
    18. 	return 0;
    19. }

    我们以后在使用字符串函数的时候尽量使用带n的版本，更严谨一些。

    1.8 strstr 

    1.8.1 函数介绍 

    char * strstr ( const char *str1, const char * str2);
    • Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.
    • 查找子串（str2 是子串）

     

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	char email[] = "lxz@code.com";
    8. 	char substr[] = "code";
    9. 	char* ret = strstr(email, substr);
    10. 	if (ret == NULL)
    11. 	{
    12. 		printf("子串不存在");
    13. 	}
    14. 	else
    15. 	{
    16. 		printf("%s\n", ret);
    17. 	}
    18.  
    19.  
    20. 	return 0;
    21. }

    1.8.2  strstr 函数模拟实现

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. #include
    5.  
    6. char* my_strstr(const char* str1, const char* str2)
    7. {
    8. 	assert(str1 && str2);
    9. 	const char* s1 = str1;
    10. 	const char* s2 = str2;
    11. 	const char* p = str1;
    12.  
    13. 	while (*p)
    14. 	{
    15. 		s1 = p;
    16. 		s2 = str2;
    17. 		while (*s1 != '\0' && s2 != '\0' && *s1 == *s2)
    18. 		{
    19. 			s1++;
    20. 			s2++;
    21. 		}
    22. 		if (*s2 == '\0')
    23. 		{
    24. 			return (char*)p;
    25. 		}
    26. 		p++;
    27. 	}
    28. 	return NULL;
    29. }
    30.  
    31. int main()
    32. {
    33. 	char email[] = "lxz@code.com";
    34. 	char substr[] = "code";
    35. 	char* ret = my_strstr(email, substr);
    36. 	if (ret == NULL)
    37. 	{
    38. 		printf("子串不存在");
    39. 	}
    40. 	else
    41. 	{
    42. 		printf("%s\n", ret);
    43. 	}
    44.  
    45.  
    46. 	return 0;
    47. }

    这样找子串是不够高效的，有一个 KMP 算法，用来实现在一个字符串中查找子字符串，效率高但是实现难度大。 

    这里不做赘述。

    1.9 strtok 

    1.9.1 函数介绍 

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

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	const char* sep = "@.";
    8. 	char email[] = "lxz@code.com";
    9. 	char cp[30] = { 0 };
    10. 	strcpy(cp, email);
    11. 	char* ret = strtok(cp, sep);
    12. 	printf("%s\n", ret);
    13. 	ret = strtok(NULL, sep);
    14. 	printf("%s\n", ret);
    15. 	ret = strtok(NULL, sep);
    16. 	printf("%s\n", ret);
    17.  
    18. 	return 0;
    19. }

    因为我们不知道字符串中有几个字段，所以不知道应该调用几次 strtok 函数，所以换一种写法。 

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	const char* sep = "@.";
    8. 	char email[] = "lxz@code.com";
    9. 	char cp[30] = { 0 };
    10. 	strcpy(cp, email);
    11.  
    12. 	char* ret = NULL;
    13. 	for (ret = strtok(cp, sep);
    14. 		ret != NULL; 
    15. 		ret = strtok(NULL, sep))
    16. 	{
    17. 		printf("%s\n", ret);
    18. 	}
    19.  
    20. 	//char* ret = strtok(cp, sep);
    21. 	//printf("%s\n", ret);
    22.  
    23. 	//ret = strtok(NULL, sep);
    24. 	//printf("%s\n", ret);
    25.  
    26. 	//ret = strtok(NULL, sep);
    27. 	//printf("%s\n", ret);
    28.  
    29. 	return 0;
    30. }

     这样写利用 for 循环可以适应任意数量字段的字符串。

    1.10  sterror

    1.10.1  函数介绍

    char * strerror ( int errnum );
    •  返回错误码，所对应的错误信息

    C语言的库函数，在执行失败的时候，都会设置错误码。

     

     

    字符分类函数： 

    函数如果他的参数符合下列条件就返回真
    iscntrl任何控制字符
    isspace空白字符：空格‘ ’，换页‘\f’，换行'\n'，回车‘\r’，制表符'\t'或者垂直制表符'\v'
    isdigit十进制数字 0~9
    isxdigit十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F
    islower小写字母a~z
    isupper大写字母A~Z
    isalpha字母a~z或A~Z
    isalnum字母或者数字，a~z,A~Z,0~9
    ispunct标点符号，任何不属于数字或者字母的图形字符（可打印）
    isgraph任何图形字符
    isprint任何可打印字符，包括图形字符和空白字符

    这些函数用法都很简单，不做赘述。 

    字符转换： 

    1. int tolower ( int c );//转小写
    2. int toupper ( int c );//转大写
    3.

    1.11  memcpy

    1.11.1 函数介绍 

    void * memcpy ( void * destination, const void * source, size_t num );
    • 函数 memcpy 从 source 的位置开始向后复制 num 个字节的数据到 destination 的内存位置。
    • 这个函数在遇到 ‘\0’ 的时候并不会停下来。
    • 如果 source 和 destination 有任何的重叠，复制的结果都是未定义的。

    memcpy 函数可以用于复制任何类型的数据，无论是字符、整数、浮点数还是自定义数据结构。它不关心数据的具体类型，只是按照指定的字节数进行复制。

    由于 memcpy 的参数是 void* 类型，可以轻松地将不同数据类型的数据复制到目标内存中，而不需要进行类型转换。这使得代码更加灵活和可维护。

    1.11.2 memcpy 函数模拟实现

     C 语言中 void* 类型的指针不能直接解引用的原因是因为 void* 是一种通用的指针类型，它可以用来存储任何数据类型的地址，但它本身并不知道指向的是什么类型的数据。因此，直接解引用 void* 指针是不允许的，因为编译器无法确定要访问多少字节的内存以及如何解释这些字节。

    为了解引用 void* 指针，需要将其转换为一个特定的数据类型的指针，这通常涉及到类型转换。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. #include
    5.  
    6. void* my_memcpy(void* dest, const void* src, size_t num)
    7. {
    8. 	assert(dest && src);
    9. 	void* ret = dest;
    10. 	while (num--)
    11. 	{
    12. 		*(char*)dest = *(char*)src;
    13. 		dest = (char*)dest + 1;
    14. 		src = (char*)src + 1;	
    15. 	}
    16.  
    17. 	return ret;
    18. }
    19.  
    20.  
    21. int main()
    22. {
    23. 	int arr1[] = { 1,2,3,4,5,6,7 };
    24. 	int arr2[10] = { 0 };
    25. 	my_memcpy(arr2, arr1, 28);
    26.  
    27. 	return 0;
    28. }

    memcpy 负责拷贝两块独立空间中的数据，对于重叠的空间，比如将自身空间中的数据拷贝到自身空间中，是不支持的。

    重叠空间的拷贝，要用到 memmove 

    1.12 memmove 

    1.12.1 函数介绍 

     

    void * memmove ( void * destination, const void * source, size_t num );
    • 和 memcpy 的差别就是 memmove 函数处理的源内存块和目标内存块是可以重叠的。
    • 如果源空间和目标空间出现重叠， 就得使用 memmove 函数处理。

       

     1.12.2 memmove 函数模拟实现

             

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. #include
    5.  
    6. void* my_memmove(void* dest, const void* src, size_t num)
    7. {
    8. 	assert(dest && src);
    9. 	void* ret = dest;
    10. 	if (dest < src)
    11. 	{
    12. 		//前->后
    13. 		while (num--)
    14. 		{
    15. 			*(char*)dest = *(char*)src;
    16. 			dest = (char*)dest + 1;
    17. 			src = (char*)src + 1;
    18. 		}
    19. 	}
    20. 	else
    21. 	{
    22. 		//后->前
    23. 		while (num--)
    24. 		{
    25. 			*((char*)dest + num) = *((char*)src + num);
    26. 		}
    27. 	}
    28.  
    29. 	return ret;
    30. }
    31.  
    32. void test()
    33. {
    34. 	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    35. 	
    36. 	my_memmove(arr1 + 2, arr1, 20);
    37.  
    38. 	int i = 0;
    39. 	for (i = 0; i < 10; i++)
    40. 	{
    41. 		printf("%d ", arr1[i]);
    42. 	}
    43. }
    44.  
    45. int main()
    46. {
    47. 	test();
    48.  
    49. 	return 0;
    50. }

    1.13 memcmp

    1.13.1 函数介绍 

    1. int memcmp ( const void * ptr1,
    2. const void * ptr2,
    3. size_t num );
    • 比较从ptr1和ptr2指针开始的num个字节
    • 返回值如下：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	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
    8. 	int arr2[] = { 1,3,2 };    //01 00 00 00 03 00 00 00 02 00 00 00
    9. 	int ret = memcmp(arr1, arr2, 12);
    10. 	printf("%d\n", ret);
    11.  
    12. 	return 0;
    13. }

    strcmp 只能比较字符串

    memcmp 可以比较任意类型的数据 

    1.14 memset 

    • 内存设置 

    这个函数以字节为单位初始化内容，会把每个字节改变为要改的值。 

    1. int main()
    2. {
    3. 	int arr[10] = { 0 };
    4. 	memset(arr, 1, 40);
    5. 	int i = 0;
    6. 	for (i = 0; i < 10; i++)
    7. 	{
    8. 		printf("%d\n", arr[i]);
    9. 	}
    10.  
    11. 	return 0;
    12. }

     

  • 相关阅读:
    牛客网开源1240页字节算法实录，无意中掀起GitHub刷题热潮
    科普系列：AUTOSAR与OSEK网络管理比较（下）
    编程语言为什么有null？
    你了解过＜string.h＞里的函数吗，今天带你模拟实现代表性函数
    WxJava使用lettuce的redis实现access_token的共享
    LeetCode 周赛 340，质数 / 前缀和 / 极大化最小值 / 最短路 / 平衡二叉树
    linux排查木马后门之定时任务计划
    Docker启动失败报错Failed to start Docker Application Container Engine解决方案
    在宇宙的眼眸下，如何正确地关心东数西算？
    RS笔记：深度推荐模型之多任务学习PLE模型 [RecSys 2020 最佳论文 腾讯]
  • 原文地址：https://blog.csdn.net/Lixinze__/article/details/131551186