【c语言进阶】字符函数和字符串函数知识总结

最新推荐文章于 2024-09-28 20:31:26 发布
最新推荐文章于 2024-09-28 20:31:26 发布
阅读量928 收藏 89
点赞数 105
文章标签： c语言 开发语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74808907/article/details/131845203
版权

字符函数和字符串函数


铁汁们，今天给大家分享一篇字符函数和字符串函数全面知识总结，来吧，开造⛳️

前期背景

在C语言具有许多数据类型，但不具有字符串类型，字符串通常放在字符指针或字符数组中，因为在C语言中对字符和字符串的处理很频繁，从而延伸出许许多多有关字符串的函数。

求字符串长度函数

strlen函数

功能：求字符串中元素的个数，不包括末尾的 ’ \0 '。 头文件为#include<string.h>。

在这里插入图片描述
字符串是以 ’ \0 '作为结束标志，strlen函数返回的是在字符串中 ’ \0 '前面的总元素个数（不包括 ’ \0 ') 。

注意：
1.strlen函数的返回值为 size_t ,无符号整形（unsigned int）。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	const char* str1 = "abcdef";  //元素个数为6个
	const char* str2 = "bbb";    //元素个数为3个
	if (strlen(str2) - strlen(str1) > 0) //两个无符号进行运算，则结果也为无符号
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("srt1>str2\n");
	}
	return 0;
}

在这里插入图片描述
图解：
在这里插入图片描述

2.参数指向的字符串必须要以 ‘\0’ 为结束标志，否则，strlen会越界一直找’ \0 ',直到遇到 ’ \0 ’ 停止，结果为随机值。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	char arr1[8] = "abcde";
	char arr2[5] = {'a','b','c','d','e'};
	printf("%d\n",strlen(arr1));
	printf("%d\n",strlen(arr2));
	return 0;
}

在这里插入图片描述

strlen函数三种模拟实现

1.计数器

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
int my_strlen(const char* arr)  //计数器模拟实现strlen
{
    assert(arr);  //断言，检查指针的有效性，防止对空指针进行解引用、加减整数操作
	int count = 0;
	while (*arr)
	{
		count++;
		arr++;
	}
	return count;
}

int main()
{
	char arr[10] = "hello bit";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

2.指针-指针（计算的是两指针之间的元素个数）

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
int my_strlen(const char* arr)  //指针-指针模拟实现strlen
{
    assert(arr);  //断言，检查指针的有效性，防止对空指针进行解引用、加减整数操作
	char* start = arr;
	char* end = arr;
	while (*end)
	  end++;
	return end - start;
}

int main()
{
	char arr[10] = "hello bit";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

3.递归

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
int my_strlen(const char* arr)  //递归模拟实现strlen
{
    assert(arr);  //断言，检查指针的有效性，防止对空指针进行解引用、加减整数操作
	if (*arr != '\0')
		return my_strlen(arr + 1) + 1;
	else
		return 0;
}

int main()
{
	char arr[10] = "hello bit";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

在这里插入图片描述

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

strcpy函数

功能：将源头字符串的内容拷贝到目标字符串，包括末尾的 ‘\0’（相当于从前往后进行覆盖）。 头文件为#include<string.h>。
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	char dest[20] = "abcdefg";
	char source[6] = "hello";
	strcpy(dest, source + 2); //可以从源字符串的任意位置处开始拷贝
	printf("%s", dest);
	return 0;
}

在这里插入图片描述

=注意：
1.会将源头字符串的 '\0’拷贝进去。

2.目标空间要足够大，足以存放源头字符串。

3.目标空间必须是可变的（不能被const修饰）。

4.源头字符串必须以 ‘\0’ 为结束标志（因为strcpy拷贝完\0’后就立即停止拷贝）。

strcpy函数模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* source)
{
    assert(dest&&source); //断言，检查指针的有效性，防止对空指针进行解引用、加减整数操作
	char* ret = dest;
	while (*dest++ = *source++)
	{
		;
	}
	return ret;
}

int main()
{
	char dest[20] = "abcdefg";
	char source[6] = "hello";
	char* ret = my_strcpy(dest, source);
	printf("%s", ret);
	return 0;
}

strcpy在内存中的拷贝过程:
在这里插入图片描述
在这里插入图片描述

strcat函数

功能：将源头字符串的内容追加到目标字符串的后面（从目标串的’\0’位置开始向后追加）。 头文件为#include<string.h>。
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	char dest[30] = "heihei";
	char source[] = " hello";
	strcat(dest, source);
	printf("%s", dest);
	return 0;
}

在这里插入图片描述

注意：
1.目标字符串必须可修改。
2.源字符串必须含有 '\0’为结束标志。
3.目标空间要足够大，足以容纳源头字符串的内容。

问题：字符串是否可以自己给自己追加？
答：字符串不可以自己给自己追加，因为源头字符串的’\0’会被覆盖，造成源头字符串会一直向后死循环追加。strcat遇到源头字符串的 ‘\0’就停止追加，并且源头字符串末尾的’\0’也会被追加过去。

在这里插入图片描述

strcat函数模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
char* my_strcat(char* dest,const char* source)
{
    assert(dest&&source); //断言，检查指针的有效性，防止对空指针进行解引用、加减整数操作
	char* ret = dest;
	while (*dest)  //找目标字符串中的'\0'
	{
		dest++;
	}
	while (*dest++ = *source++)
	{
		;
	}
	return ret;
}

int main()
{
	char dest[30] = "abcde";
	char source[] = "hello bit";
	char* ret = my_strcat(dest, source);
	printf("%s", ret);
	return 0;
}

在这里插入图片描述

strcmp函数

功能：用来比较两字符串的大小，两字符串不能直接用==进行比较。 头文件为#include<string.h>。

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	char s1[] = "abcdefg";
	char s2[] = "abcde";
	int ret=strcmp(s1, s2);
	printf("%d\n", ret);
	return 0;
}

在这里插入图片描述

问题：strcmp如何判断两字符串大小？

答:两个字符串从前向后依次比较两个字符，判断是否相等，相等，则继续比较下一个字符，直到有一个串遇到’\0’，并比较完’\0’，就停止。若不相等，比较两字符的ASCII值，ASCII值大的串，字符串大。《—等价于—》ASCII值的比较

在这里插入图片描述
strcmp返回值三种情况：

a.字符串1（前面的参数）大于 字符串2（后面的参数），则返回大于0的数。

b.字符串1（前面的参数）小于 字符串2（后面的参数），则返回小于0的数。

c.字符串1（前面的参数）等于 字符串2（后面的参数），则返回等于0的数。

strcmp函数模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
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;
}

int main()
{
	char s1[] = "abcde";
	char s2[] = "abcdef";
	int ret = my_strcmp(s1, s2);
	printf("%d", ret);
	return 0;
}

在这里插入图片描述

长度受限制的字符串函数

strncpy函数

功能： 头文件为#include<string.h>。

情况1：源字符串的长度>num,将源字符串的前num个字符拷贝到目标字符串中；

情况2：源字符串的长度<num将源字符串全部拷贝到目标字符串中，包括源字符串末尾的’\0’，源字符串拷贝完后，在目标字符串的后面一直追加 ‘\0’,直到num停止。

在这里插入图片描述
情况1代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	int num = 5; //源字符串的长度>num
	char dest[30] = "heheabcd";
	char source[] = "lala hello";
	strncpy(dest, source, num);
	printf("%s", dest);
	return 0;
}

在这里插入图片描述
情况2代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	int num = 20; //源字符串的长度<num
	char dest[30] = "heheabcdefghi";
	char source[] = "lala hello";
	strncpy(dest, source, num);
	printf("%s", dest);
	return 0;
}

在这里插入图片描述
内存图：
在这里插入图片描述

strncpy函数模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
char* my_strncpy(char* dest,const char* source, int num)
{
	assert(dest && source);
	char* ret = dest;
	while (num--)
	{
		if (*source != '\0')  //情况1,源字符串的长度>num
			*dest++ = *source++;
		else      //情况2，源字符串的长度<num,源字符串拷贝完后，在目标字符串后一直追加'\0'
			*dest++ = '\0';
	}
	return ret;
}

int main()
{
	int num = 5;
	char dest[30] = "heheabcdefghi";
	char source[] = "lala hello";
	char* ret = my_strncpy(dest, source, num);
	printf("%s\n", dest);
	return 0;
}

在这里插入图片描述

strncat函数

功能： 头文件为#include<string.h>。

在这里插入图片描述
情况1：源字符串的长度>num,将源字符串的前num个字符追加到目标字符串后面，最后在目标字符串后面自动补上 ‘\0’；

情况2：源字符串的长度<num将源字符串全部追加到目标字符串后面，包括源字符串末尾的’\0’，则就停止追加。

情况1代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
#include<string.h>
int main()
{
	int num = 5; //情况1，源字符串的长度>num
	char dest[30] = "abcde\0lalalalalala";
	char source[] = "hello world";
	strncat(dest, source, num);   
	printf("%s\n", dest);
	return 0;
}

在这里插入图片描述
在这里插入图片描述
情况2代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
#include<string.h>
int main()
{
	int num = 20; //情况2，源字符串的长度<num
	char dest[30] = "abcde\0lalalalalalalalalalala";
	char source[] = "hello world";
	strncat(dest, source, num);
	printf("%s\n", dest);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

strncat函数模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
char* my_strncat(char* dest, const char* source,int num)
{
	assert(dest && source);
	char* ret = dest;
	while (*dest)
		dest++;
	while (num--)
	{
		*dest = *source;
		if (*source == '\0')  //清款2
			break;
		dest++;
		source++;
	}
	if (*source != '\0')  //情况1
		*dest = '\0';
	return ret;
}

int main()
{
	int num =5;
	char dest[30] = "abcde\0lalalalalalalalalalala";
	char source[] = "hello world";
	char* ret=my_strncat(dest, source, num);
	printf("%s\n", ret);
	return 0;
}

在这里插入图片描述

strncmp函数

功能：比较前num个字符的大小， 头文件为#include<string.h>。

比较到在num范围内有一个串结束、两串中有一个字符不相等，前num个字符全部比完，就停止比较了。

在这里插入图片描述
返回值三种情况：同strcmp函数返回值情况相同。
在这里插入图片描述

strncmp函数模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
int my_strncmp(const char* s1,const char* s2, int num)
{
    assert(s1&&s2);
	while (num--)
	{
		while (*s1 == *s2)
		{
			if(*s1 == '\0')
				return 0;
			s1++;
			s2++;
		}
		return *s1-*s2;
	}
}

int main()
{
	int num = 3;
	char arr1[] = "abcdef";
	char arr2[] = "abed";
	int len = my_strncmp(arr1, arr2,num);
	printf("%d\n", len);
	return 0;
}

在这里插入图片描述

字符串查找

strstr函数

功能：在string指向的字符串中查找strCharSet指向的字符串是否出现，出现，则返回strCharSet指向的字符串在tring指向的字符串第一次出现的起始位置，若未出现，则返回NULL。 头文件为#include<string.h>。
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
#include<string.h>
int main()
{
	char arr[] = "abcdefbcdef";
	char src[] = "bcdef";
	char* ret=strstr(arr, src);
	printf("%s\n", ret);
	return 0;
}

在这里插入图片描述

strstr函数模拟实现

版本1：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
char* my_strstr(char* dest, char* src)
{
	assert(dest && src);
	char* cur = dest;
	char* s1;
	char* s2;
	while (*cur)
	{
		s1 = cur;
		s2 = src;
		while (*s2&&*s1)
		{
			if (*s1 != *s2)
				break;
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return cur;
			cur++;
	}
}

int main()
{
	char arr[] = "abbbcdefbcdef";
	char src[] = "bcdef";
	char* ret=my_strstr(arr, src);
	printf("%s\n", ret);
	return 0;
}

在这里插入图片描述

在这里插入图片描述
版本2：枚举法（效率更高）

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>
#include<assert.h>
#include<string.h>
char* my_strstr(char* dest, char* src)
{
	assert(dest && src);
	char* ret = dest;
	int len1 = strlen(dest);
	int len2 = strlen(src);
	int i=0;
	for ( ; i + len2 <= len1; i++)
	{
		int j = 0;
		for (; j < len2; j++)
		{
			if (dest[i+j] != src[j])
				break;
		}
		if (j == len2)
			return (ret + i);
	}
	return NULL;
}

int main()
{
	char arr[] = "abbbcdefbcdef";
	char src[] = "bcdef";
	char* ret=my_strstr(arr, src);
	printf("%s\n", ret);
	return 0;
}

在这里插入图片描述

在这里插入图片描述

strtok函数

功能：用于处理带标记的字符串。头文件为#include<string.h>。
在这里插入图片描述
注意：

1.参数2strDelimit指向的字符串定义了用作分隔符的集合,注意参数2必须是字符串，而’\0‘代表的是字符串结束符，通常用于标记字符串的末尾，并不作为分隔符。

2.strToken指向的字符串，它包含了0个或者多个strDelimit指向字符串的分隔符标记。

3.strtok函数找到strDelimit指向字符串中的下一个分隔符的标记，并会自动保存这个标记符在字符串的位置，返回一个指向这个标记的指针。

4.当第一个参数不为NULL，找到第一个分割符标记，该函数内部会自动保存这个标记符在字符串的位置，进行第二次使用strtok函数时，函数的第一个参数为NULL,该函数会从上次strtok函数保存的上个分割标记符后一个位置处查询下一个分割标记符并保存下一个分割标记符所在字符串中的位置，直到不存在分隔符停止查找。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "naifu,naiyou.fsq#zzx";
	const char* arr2= ",.#";
	for (char* ret = strtok(arr1, arr2); ret != NULL; ret=strtok(NULL, arr2))
	{
		printf("%s\n", ret);
	}return 0;
}

在这里插入图片描述

错误信息报告

strerror函数

功能：返回错误码所对应的错误信息。头文件为#include<string.h>。
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>  //strerror库函数的头文件
#include<errno.h>   //必须包含的头文件
int main()
{
	FILE* p = fopen("lala.txt", "r");
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));  //errno存放错误码
		return 1;
	}
	fclose(p);
	p = NULL;
	return 0;
}

在这里插入图片描述
strerror函数可以用于确定库函数在执行时发生的错误的原因。当库函数遇到错误时，它会设置一个全局变量errno，C语言会将错误码存放在errno这个全局变量中，strerror函数使用errno确定特定错误码对应的错误消息。

perror函数

功能：返回错误码所对应的错误信息。头文件为#include<stdio.h>。
在这里插入图片描述
与strerror作用效果相同，只是perror会输出string指向的字符串内容在加个冒号（：），在输出错误码所对应的错误信息，在文件操作中，确定错误信息是什么，常用perror函数。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	FILE* p = fopen("lala.txt", "r");
	if (p == NULL)
	{
		perror("fopen");
		return 1;
	}
	fclose(p);
	p = NULL;
	return 0;

在这里插入图片描述

字符分类函数

头文件为#include<ctype.h>。
在这里插入图片描述

大小写转化函数

头文件为#include<ctype.h>
在这里插入图片描述

内存操作函数

memcpy函数

功能：从src位置向后拷贝count个字节的内容到dest指向的字符串中（遇到\0不会停下来）。若拷贝的字节数大于源头字符串的总字节数，超过的字节数拷贝的内容为随机值。 头文件为#include<string.h>。

注意：memecpy适用于不重叠数据或者无关联的数据拷贝。

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	int count = 4;
	int arr[10] = { 1,2,3,4,5,6 };
	int src[6] = { 7,8,9,10,11,12 };
	memcpy(arr, src, sizeof(arr[0])*count);
	for (int i = 0; i <10; i++)
		printf("%d ", arr[i]);
	return 0;
}

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<string.h>
int main()
{
	int count = 3;
	int arr[10] = { 1,2,3,4,5,6 };
	int src[3] = { 7,8,9};
	memcpy(arr, src, sizeof(arr[0])*count);
	for (int i = 0; i <10; i++)
		printf("%d ", arr[i]);
	return 0;
}

在这里插入图片描述

memcpy函数模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
#include<string.h>
void* my_memcpy(void* dest, void* src, int count)  //适用于任意类型
{
	assert(dest && src);
	while (count--)
	{
		*(char*)dest = *(char*)src; //对空指针进行解引用操作，具有临时性，有效时长仅在其所在的语句中
		(char*)dest = (char*)dest + 1; //（char*)dest++，因优先级：++>(),dest（NULL)先与++结合，不能对空指针进行加减、解引用操作
		(char*)src = (char*)src + 1;
	}
	return ;
}

int main()
{
	int count = 4;
	int arr[10] = { 1,2,3,4,5,6,7,8 };
	int src[6] = { 9,10,11,12 };
	int len = sizeof(arr) / sizeof(arr[0]);
	my_memcpy(arr, src, sizeof(arr[0] )* count);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

在这里插入图片描述
问题：memcpy可以拷贝重叠数据吗？
答：memcpy不可以拷贝重叠数据，会造成数据被覆盖。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
#include<string.h>
void* my_memcpy(void* dest, void* src, int count)  //适用于任意类型
{
	assert(dest && src);
	while (count--)
	{
		*(char*)dest = *(char*)src; //对空指针进行解引用操作，具有临时性，有效时长仅在其所在的语句中
		(char*)dest = (char*)dest + 1; //（char*)dest++，因优先级：++>(),dest（NULL)先与++结合，不能对空指针进行加减、解引用操作
		(char*)src = (char*)src + 1;
	}
	return ;
}

int main()
{
	int count = 5;
	int arr[10] = { 1,2,3,4,5,6,7,8 };
	int src[6] = { 9,10,11,12 };
	int len = sizeof(arr) / sizeof(arr[0]);
	my_memcpy(arr+2, arr, sizeof(arr[0] )* count); //memcpy拷贝重叠数据
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

在这里插入图片描述
在这里插入图片描述

memmove函数

功能：从src位置向后拷贝count个字节的内容到dest指向的字符串中（遇到\0不会停下来）。若拷贝的字节数大于源头字符串的总字节数，超过的字节数拷贝的内容为随机值。 头文件为#include<string.h>。

注意：memmove既适用于重叠数据或者有关联的数据拷贝，又适用于不重叠数据或者无关联的数据拷贝。

在这里插入图片描述

重叠数据或者有关联的数据拷贝：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
int main()
{
	int count = 5;
	int arr[10] = { 1,2,3,4,5,6,7,8 };
	int len = sizeof(arr) / sizeof(arr[0]);
	memmove(arr+2, arr, sizeof(arr[0] )* count);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

在这里插入图片描述
不重叠数据或者无关联的数据拷贝：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
int main()
{
	int count = 5;
	int arr[10] = { 1,2,3,4,5,6,7,8 };
	int src[5] = { 9,10,11,12,13 };
	int len = sizeof(arr) / sizeof(arr[0]);
	memmove(arr,src, sizeof(arr[0] )* count);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

在这里插入图片描述

memmove函数模拟实现

memmove模拟实现图：
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, int count)
{
	void* ret = dest;
	if (dest < src)  //从前往后拷贝
	{
		while (count--)
		{
			*((char*)dest) = *((char*)src);
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else   //从后往前拷贝
	{
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return ret;
}

int main()
{
	int count = 5;
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr+2, arr, sizeof(int) * count);   //重叠数据
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

在这里插入图片描述
在这里插入图片描述
问题：memmove与memcp有何区别？

答：memmove既可以处理重叠数据，又可处理不重叠数据（100%）。 memcpy被规定来只能用来处理不重叠或者无关联的数据（60%），但在有些编译器上，memcpy也可用来处理重叠数据，所以一般处理重叠数据的拷贝选择memmove,处理不重叠的数据选择memcpy。

memset函数

功能：将dest指向的内存空间的前count字节的内容全部设置为c。 头文件为#include<string.h>。

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int count = 5;
	memset(arr, 0, sizeof(int) * count);
	for (int i = 0; i < 10; i++)
		printf("%d ", arr[i]);
	return 0;
}

在这里插入图片描述
应用场景：常适用于初始化一块连续的内存空间，eg：静态版通讯录实现。

memcmp函数

功能：将dest指向的内存空间前count字节的内容与src指向的内存空间前count字节的内容相比较，比较到在count字节范围内有一个空间结束、两空间中有一个字节不相等，前num个字节全部比完，就停止比较了，返回值与strncmp相同。
在这里插入图片描述

铁铁们，字符函数和字符串函数知识总结就到此结束啦，若博主有不好的地方，请指正，欢迎铁铁们留言，请动动你们的手给作者点个👍鼓励吧，你们的鼓励就是我的动力✨

奶芙c
关注
字符串函数详解（C语言模拟实现字符串函数）
qq_62888595的博客
01-12 208
字符串函数详解（C语言模拟实现字符串函数）求字符串长度 strlen 长度不受限制的字符串函数 strcpy strcat strcmp 长度受限制的字符串函数 strncpy strncat strncmp 字符串查找 strstr strtok 错误信息报告 strerror 字符操作 内存操作函数 memcpy memmove memset memcmp
C语言进阶（六）：指针数组字符串函数
Exp.Joker
03-26 3680
指针的本质分析 1、*号的意义 （1）指针的声明和使用 （2）实践：指针使用示例 2、传值调用与传址调用 （1）什么是传值调用，传址调用？ （2）实践：利用指针交换变量 3、常量与指针 （1）const与指针 （2）实践：const与指针 4、小结 二、数组的本质分析 1、数组的概念 2、数组的大小 （1）数组大小的获取（内存、元素数量） （2）实践：数组的初始化 3、数组地址与数组名 （1）数组地址与数组名 （2）实践：数组名和数组地址 4、数组名的盲点
C语言之字符函数和字符串函数
weixin_45476980的博客
02-19 167
关于 字符串函数 以及以字节处理的函数 的整理
【29】C语言 | 字符串函数
强哥的微博
01-29 366
本文主要简单整理了C语言中处理字符、字符串的库函数。
c语言字符串函数汇总
weixin_73373302的博客
01-02 219
指向的就是you这个字符串的地址。查找str2是否是str1的子串，用下面的例子说话，str2的第一个字符是d，那么如果是子串，返回str1里面第一个d的地址（str1里面可能有好几个def子串，但是只返回第一个d的地址。当比较到第3个字符的时候，c的字典序小于f的字典序，则返回小于零的数。比如一个字符串"I.love.you@yan"，是由.和@分割的，而p字符串是".@"那么用下面的for循环，就可以打印出。（2）str是要被分割的字符串，delim是分隔符组成的字符串，可以是一个分隔符，可以是多个。
进阶C语言：字符函数和字符串函数
Yikefore的博客
03-30 682
字符串函数、内存函数、字符分类函数、字符转换函数的详细介绍以及模拟实现
C语言进阶——字符串&&内存函数
北 海的博客
09-16 2074
我们从字符串类型操作开始，延伸到全数据类型的操作，中间还介绍了几个字符分类函数，这些库函数就像一件件实用的工具，是前人智慧的结晶，所以我们不仅要会用，还要用好，并将它们运用到代码中。知其然，并知其所以然，对这些库函数的模拟实现能让我们更为全面的了解实现原理，并避免犯错。
【C语言进阶】带你轻松玩转字符、字符串函数
小王学代码
01-11 945
C语言进阶部分，字符串函数strlen、strcat、strstr、strcat、strcmp、strncmp等，内存操作函数memcmp、memmove等一系列函数的使用和讲解
C语言进阶--处理字符和字符串的库函数的使用和注意事项
Perservere的博客
08-26 438
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 第一篇博客。 一、处理字符和字符串的库函数的使用和注意事项 求字符串长度 strlen 查找 \0 之前有多少个字符，返回类型为 size_t = unsigned int strcpy：字符串拷贝 源字符串必须以 '\0' 结束 会将源字符串中的
C语言进阶剖析教程的PPT与配套源码.rar
09-05
2. **指针**：理解指针的本质，如何声明、赋值和操作指针，以及指针在数组、字符串和函数参数中的应用。 3. **内存管理**：动态内存分配（如malloc和free）和内存泄漏的概念，以及如何有效地管理程序内存。 4. **...
C语言进阶 作者 Wrestle.Wu
06-20
 指针与地址、数组、字符串、函数之间的关系，以及指针与指针之间的关系；  枚举类型的使用及注意事项，结构体变量和共用体变量的初始化方法及引用；  传统链表的实现方法和注意事项，以及对传统链表实现...
C/C++语言基础--C++面向对象、类、对象概念讲解
weixin_74085818的博客
09-18 1589
世界上所有人都有一个相似的东西，那就我们都是人类，简称人，:happy:，所以人也可以抽象成一个类；对于长方形、圆、正方形……来说，他们都抽象成平面几何，他们都有共同的特性，就是有面积…………以上两点看起来很**”无语“**，但是这就是面向对象的思想案例，就像是我们说的一切复杂的东西本质都是简单的。一个具体东西，是一个对象的实例，就像人是一个对象，但是我是一个类，你也是一个类，他也是抽象是将类对象的共同特征总结、提取出来构造类的过程，只关注对象的哪些属性和行为，并不关注这此行为的细节是什么。
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 1385
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
【数据结构】排序算法系列——归并排序（附源码+图解）
Skrrapper的博客
09-24 1087
它的特点在于并不是一开始就将整个数组进行归类和调整，而是以一定的间隔数分成多次小的排序，最后再逐渐将小的排序的范围变大，最后变大到整个数组时，已经完全有序。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。界定比较的数据个数：一般按照2的倍数增长：两个互相比较、四个互相比较、八个互相比较…总的来说，分治法也可以被称作一种算法，它是一种基于递归的、“分而治之”的算法思想。3.合并这些子问题的解成原问题的解。
动态顺序表的增删改查（数据结构）
最新发布
m0_62048999的博客
09-28 780
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
数据结构：树、森林
pranaa的博客
09-24 923
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
数据结构：串 及串的模式匹配（KMP）
pranaa的博客
09-23 1126
串（String）是由零个或多个字符组成的有限序列，又名叫字符串。在计算机科学中，串是一种重要的数据结构，用于表示文本数据。串中的元素称为字符，字符可以是字母、数字或其他符号，这些字符可以是任意字符集中的成员。串是许多编程语言中的基本数据类型，用于处理文本数据。
C语言指针进阶：通过函数参数交换变量值
指针变量可以进行基本的算术运算，如加减操作，这在遍历数组或字符串时尤其有用。此外，指针作为函数参数可以实现函数调用返回多个值的功能，例如，一个函数可以通过返回一个指针来让调用者访问多个结果。在动态内存...
评论 88
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值