字符串函数和内存函数

无证明

已于 2024-12-08 11:26:41 修改

阅读量1.4k

点赞数 27

分类专栏： c语言学习文章标签： c语言算法

于 2024-12-04 20:32:34 首次发布

本文链接：https://blog.csdn.net/weixin_65994469/article/details/144231150

版权

c语言学习专栏收录该内容

23 篇文章 0 订阅

订阅专栏

字符串函数

1、strlcpy 【字符串拷贝】

（将原字符串中的字符拷贝到目标字符数组中，包括终止符号\0，并在这里停止；为了避免越界，目标字符串数组应该足够大去接收）👆

（返回值是 destination，是个地址，目标字符数组的首地址）

// strcpy  字符串拷贝
//模拟实现
char* my_strcpy(char* des, const char* sour)
{
	assert(sour&&des);

	char* ret = des;

	/*while (*sour)
	{
		*des++ = *sour++;
	}
	*des = *sour;*/

	while (*des++ = *sour++)
		;

	return ret;
}

int main()
{
	char arr[20] = { 0 };
	char sour[] = "i lovw you";

	my_strcpy(arr, sour);

	zhangsan
	//strcpy(arr, "zhangsan");
	//printf("%s\n", arr);
	//strcpy(arr, "zhang\0san");
	printf("%s\n", arr);
	拷贝遇到\0停下
	return 0;
}

2、strcat 【字符串追加】

（在目标地址\0处开始，将source指的字符串加到后面，包括source指向字符串的\0也加上去）

返回值是destination指向字符数组的首元素地址

// strcat   字符串追加
//模拟实现
char* my_strcat(char* des, const char* sour)
{
	char* ret = des;
	int len = strlen(des);
	des = des + len;
	while (*des++ = *sour++)
		;
	return ret;
}

int main()
{
	char arr[20] = "hello";
	char brr[] = ",lpp!";

	printf("%s\n",arr);
	my_strcat(arr, brr);
	printf("%s\n", arr);

	return 0;
}

3、strcmp 【字符串比较】

如何比较呢？ 是一一对应的比较

a b c e o 字符串n

a b c p w 字符串m

= = = × ——> m>n

(从俩字符串的第一个字符开始比较，如果相同，继续比较，直到不相等或者\0）

返回值由比较结果决定，前者大于后者，返回>0 ；相等返回 0 ；前小于后，返回 <0

// strcmp 【比较字符串】
//模拟实现
int my_strcmp(const char* str1, const char* str2)
{
	while (*str1++ == *str2++ && *str1 != '\0')
		;
	return *str1 - *str2;

}

int main()
{
	char arr[] = "abwdef";
	char brr[] = "abwdefp";

	int n=my_strcmp(arr, brr);

	printf("%d\n", n);
}

strcmp 、strcpy 、strcat 是长度不受限制的字符串函数↑，由一定风险，发生越界

strncmp、strncpy、strncat 是长度受限制的字符串函数 ↓ （多一个个数的限制）

4、strncpy 【字符串拷贝，限定版】

（跟strcpy用法基本一样，只不过多了一层限定，限定了拷贝字符的个数，

假如限定拷贝5个，source指向的字符串不止5个，就只拷贝 5个

source指向的字符串没有5个，依旧拷贝5个，没有的补 \0 ）

int main()
{
	char arr1[20] = "ancd yiw********* ";
	char arr2[] = "hello";
	strncpy(arr1, arr2, 10);

	printf("%s\n", arr1);

	return 0;
}

没有拷贝之前 arr1 里面的字符如下：

拷贝之后 arr1 内字符如下 ↓ （可见，不足要求个数的时候补 \0）

5、strncat 【字符串追加限定版】

同strcat用法差不多，也是多个限定追加字符的个数

但是当追加个数（num）大于sourse指向的字符串里的字符个数时，不会强制全补 \0,

追加完sourse 指向字符串，就不再追加

int main()
{
	char arr1[20] = "hello \0********";
	char arr2[] = "baby";
	strncat(arr1, arr2, 7);

	printf("%s\n", arr1);

// hello baby

}

追加前 arr1 内情况👇

追加后，arr1 内情况 👇

6、strncmp 【字符串比较限定版】

（比较停止条件 1、比出不同 2、比到 \0 3、比到超出要求数字（num））

int main()
{
	char arr1[] = "abcde";
	char arr2[] = "abcoi";

	int n=strncmp(arr1, arr2, 3);

	printf("%d ", n);


// 0

	return 0;
}

如上：当num为3 的时候返回值是0，只比到了第三个字符

当num大于3时，返回值<0,因为第4对的 o 大于 d

如上，是长度受限制的字符串函数 👆

7、strstr 【查找子串】

返回的是查找到的那个字符串的首地址，如果没有查找到，返回空指针。

int main()
{
	char arr[] = "hello my baby nice to meet you.";
	char* ptr;
	ptr=strstr(arr, "baby");

	if (ptr != NULL)
		strncpy(ptr, "lpp,", 4);

	printf("%s\n", arr);

//hello my lpp, nice to meet you.

	return 0;
}

模拟strstr函数，实现它的功能：

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

		if (*s2 == '\0')
			return (char*)p;

		p++;

	}

	return NULL;
}

8、strtok 【切割字符串】

>strtok函数找到str中的下一个标记，并将其用\0结尾,返回指向这个标记的指针。(注:
strtok函数会改变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容
并且可修改。)
>strtok函数的第一个参数不为 NULL,函数将找到str中第一个标记,strtok函数将保存它在字符串
中的位置。
>strtok函数的第一个参数为NULL,函数将在同一个字符串中被保存的位置开始,查找下一个标
记。
>如果字符串中不存在更多的标记,则返回NULL指针。

（返回值：第一次传非空指针，发现字符串，返回发现字符首字母地址，

然后strtok记忆这个字符地址，下次NLULL进来，继续从这个位置开始，

读取完整个字符，返回NULL）

int main()
{
	char arr[] = "i.study.every.day_365*day.";
	char a[100] = { 0 };
	strcpy(a, arr);

	char* ret;
	for (ret = strtok(a, "._*"); ret != NULL;ret=strtok(NULL,"._*"))
	{
		printf("%s ", ret);

	}


	return 0;
}

9、字符分类函数 <ctype.h>

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

用法相似，举个列子，isupper 函数

因为字符在内存中都是以·ASCII值储存的

int main()
{
	char a = 'a';
	char b = 'A';

	printf("%d %d", isupper(a), isupper(b));

	// 0 1
	return 0;
}

假，返回 0，真，返回>0的值（1）

10、字符转换函数 tolower toupper

tolower 将大写字母变成小写字母

toupper将小写字母变成大写字母

其他不符合条件的字符不会改变

int main()
{
	char a = 'A';
	char b;
	b = tolower(a);
	printf("%c\n", b);
	//a
	b = tolower(b);
	printf("%c\n", b);
	//a
	b = toupper(b);
	printf("%c\n", b);
	//A
	b = toupper('@');
	printf("%c\n", b);
	//@
	return 0;
}

11、strerror 【将错误码转换成错误信息】

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

（给它一个错误信息码，它会找到对应的错误字符串，并且将首地址返回给你）

errno 是c语言设置的一个全局的错误码存放的变量头文件<errno.h>

int main()
{
	//printf("%s\n", strerror(0));//No error
	//printf("%s\n", strerror(1));//Operation not permitted
	//printf("%s\n", strerror(2));//No such file or directory
	//printf("%s\n", strerror(3));//No such process
//fopen 是打开文件的函数， 里面放的是文件路径，和打开方式 r是 读
//如果打开失败 返回值是NULL
	FILE* pf = fopen("C:\\Users\\嗷~里~个~嗷\\Desktop", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));

	}

	else
	{
		;
	}
		//Permission denied
	return 0;
}

内存函数

12、memcpy 【内存拷贝】

与strncpy不同的是，memcpy是适用于所有类型，第三个参数，是字节个数

其返回值是 destination 所指向的首地址

memcpuy 负责拷贝两块独立空间的数据，

不适用于重叠内存之间的数据拷贝

// 模拟实现
void* my_memcpy(const void* dis, const void* sou, size_t num)
{
//因为要保证整个函数具体范性，所以一个字节一个字节进行
//char* ，一次访问一个字节
	char* ret =(char*) dis;
	while (num--)
	{
		*(char*)dis = *(char*)sou;
		dis = (char*)dis + 1;
		sou = (char*)sou + 1;

	}

	return ret;
}


int main()
{
	int i = 0;
	int arr1[] = { 1,2,3,4,5,6,7,8 };
	int arr2[4] = { 11,22,33,44 };
	my_memcpy(arr1, arr2, sizeof(arr2));
	for (i = 0; i < (sizeof(arr1) / sizeof(arr1[0]));i++)
		printf("%d ",arr1[i]);

		putchar('\n');

	double brr1[] = { 1.1,2.2,3.3,4.4 };
	double brr2[] = { 11.11,22.22,33.33,44.44 };
	my_memcpy(brr1, brr2, sizeof(brr2));
		for (i = 0; i < (sizeof(brr1) / sizeof(brr1[0])); i++)
			printf("%.2lf ", brr1[i]);

	return 0;

}

13、memmove 【内存拷贝，加强版】

与memcpy相比，它可以实现，重叠内存数据的拷贝，其他用法一样。

void test_cpy()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	memcpy(arr + 2, arr, 20);

	int i = 0;
	for (i = 0; i < 10; i++)
		printf("%d ", arr[i]);
	putchar('\n');

}

void test_move()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	memmove(arr + 2, arr, 20);

	int i = 0;
	for (i = 0; i < 10; i++)
		printf("%d ", arr[i]);
	putchar('\n');
}

int main()
{
	test_cpy();
	test_move();

	return 0;
}

模拟实现 👇

void* my_memmove(const void* des, const void* sour, size_t num)
{
	assert(des && sour);
	void* ret = des;
	if (des < sour)
	{
		//从前往后拷贝
		while (num--)
		{
			*(char*)des = *(char*)sour;
			des = (char*)des + 1;
			sour = (char*)sour + 1;
		}
		
	}
	else
	{
		// 从后往前拷贝
		while (num--)
		{
			*((char*)des + num) = *((char*)sour + num);

		}

	}

}

图解如下所示：

14、memcmp 【内存比较】

strncmp 函数相比，它是适用所有类型，其他基本一样

int main()
{
	int arr[] = { 1,2,3,4,5 };
	int brr[] = { 1,2,3,8,5 };
	int x = memcmp(arr, brr, 12);
	int y = memcmp(arr, brr, 16);

	printf("%d %d", x, y);

	// 0 -1 
}

15、memset 【内存设置】

ptr 是指向我们要改变的位置，

value 是我们要变成的对象，

num是要改变字节的个数

int main()
{
	char arr[] = "hello baby.";
	memset(arr, '*', 5);
	printf("%s\n", arr);
	//***** baby.

	int brr[5] = { 1,2,3,4,5 };
	int i = 0;
	memset(brr+1, 0, 8);
	for (i = 0; i < 5; i++)
		printf("%d ", brr[i]);
	// 1 0 0 4 5
	//一个字节一个字节来

	return 0;
}

👏👏👏👏👏👏👏👏👏👏👏