（字符串+内存）函数的介绍

KGoDY

已于 2022-08-01 17:54:34 修改

阅读量213

点赞数 1

分类专栏： C语言文章标签： c#

于 2022-07-21 09:42:43 首次发布

本文链接：https://blog.csdn.net/m0_63710200/article/details/125780218

版权

C语言专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、前言

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中
字符串常量适用于那些对它不做修改的字符串函数
今天我们重点介绍处理字符和字符串的库函数的使用和注意事项

二、字符（串）函数

1.求字符串长度

1.strlen

size_t strlen ( const char * str );

字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )
参数指向的字符串必须要以 '\0' 结束
注意函数的返回值为size_t，是无符号的（易错）
学会strlen函数的模拟实现

🎈函数使用

int main()
{
	const char* str1 = "abcdef";
	const char* str2 = "bbb";
	if (strlen(str2) - strlen(str1) > 0)
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("srt1>str2\n");
	}
	return 0;
}

输出结果：

✏️ 模拟实现

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

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

1.strcpy

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

将源字符串复制到目标指向的数组中，包括终止的空字符（并在该点停止）。
源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。
学会模拟实现。

✏️模拟实现

char* my_strcpy(char* dest, char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest++ = *src++)
		;
	return ret;
}
int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = {0};
	my_strcpy(arr2, arr1);
	printf("%s", arr2);
}

2.strcat

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

将源字符串添加到目标字符串的尾部，目标字符串的终止字符将被源字符串的第一个字符覆盖。
源字符串必须以 '\0' 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
字符串自己给自己追加，如何？

✏️模拟实现

char* my_strcat(char* dest, char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++)
		;
	return ret;
}
int main()
{
	char arr1[20] = "Hello ";
	my_strcat(arr1, "my girfriend");
	printf("%s", arr1);
}

3.strcmp

int strcmp ( const char * str1, const char * str2 );

此函数开始比较两个字符串的每一个字符。如果它们彼此相等，则继续比较下一对字符，直到字符不同或达到终止空字符。
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

🎈函数使用

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdefg";
	int ret = strcmp(arr1, arr2);
	if (ret > 0)
		printf(">\n");
	else if (ret == 0)
		printf("==\n");
	else
	{
		printf("<\n");
	}
}

✏️模拟实现

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2 && *str1 && *str2)
	{
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;
	else if (*str1 < *str2)
		return -1;
	else
		return 0;

}
int main()
{
	char arr1[] = "abcde";
	char arr2[] = "abcdef";
	int ret = my_strcmp(arr1, arr2);
	if (ret == 1)
		printf(">\n");
	if (ret == -1)
		printf("<\n");
	if (ret == 0)
		printf("==\n");
}

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

1.strncpy

char * strncpy ( char * destination, const char * source, size_t num );

拷贝num个字符从源字符串到目标空间
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个

🎈函数使用

int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = { 0 };
	strncpy(arr2, arr1, 3);
	printf("%s", arr2);
}

2.strncat

char * strncat ( char * destination, const char * source, size_t num );

将源字符串的前num个字符追加到目标字符串，再加上终止的null字符
如果源中C字符串的长度小于num，则只复制直到终止空字符的内容

3.strncmp

int strncmp ( const char * str1, const char * str2, size_t num );

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

4.字符串查找

1.strstr

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

返回指向str1中第一个出现的str2的指针，如果str2不是str1的一部分，则返回空指针

🎈函数使用

int main ()
{
  char str[] ="This is a simple string";
  char * pch;
  pch = strstr (str,"simple");
  strncpy (pch,"sample",6);
  puts (str);
  return 0;
}

输出结果

✏️模拟实现

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && 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 p;
		p++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "aacccde";
	char arr2[] = "cde";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
		printf("子串不存在\n");
	else
	{
		printf("%s", ret);
	}
}

5.内存操作函数

1.memcpy

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

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置
这个函数在遇到 '\0' 的时候并不会停下来
如果source和destination有任何的重叠，复制的结果都是未定义的

✏️模拟实现

void* my_memcpy(void* dest, const void* src, size_t num)
{
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = {0};
	my_memcpy(arr2, arr1, 20);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d", arr2[i]);
	}
}

3.memmove

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

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的
如果源空间和目标空间出现重叠，就得使用memmove函数处理

🎈函数使用

int main ()
{
  char str[] = "memmove can be very useful......";
  memmove (str+20,str+15,11);
  puts (str);
  return 0; }

输出结果

✏️模拟实现

void* my_memmove(void* dest, void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	if (dest > src)
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	else
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7 };
	my_memmove(arr1, arr1+2, 16);
	int i = 0;
	for (i = 0; i < 7; i++)
		printf("%d ", arr1[i]);
}