c语言字符串函数和内存函数（图文详解）

我爱吃福鼎肉片

已于 2024-03-24 17:09:18 修改

阅读量962

点赞数 46

文章标签： c语言开发语言

于 2024-03-24 17:04:58 首次发布

本文链接：https://blog.csdn.net/super_coders/article/details/136853872

版权

本文详细介绍了C语言中一系列字符串处理函数，包括strlen、strcpy、strcat、strcmp、strncpy、strncat、strncmp、strstr、strtok、strerror、memcpy、memmove、memset和memcmp，以及它们的功能、注意事项和示例。

摘要由CSDN通过智能技术生成

前言：

在编程的过程中，我们经常要处理字符和字符串，为了⽅便操作字符和字符串，C语⾔标准库中提供了⼀系列库函数，在介绍字符串函数之前，我先来给这些个字符串函数分一下类：
在这里插入图片描述

一、求字符串长度：

1. strlen

size_t strlen ( const char * str );

功能：
获取的字符串长度，不包括’\0’。返回字符串的长度。

库函数strlen函数声明：

size_t strlen ( const char * str );

注意：
字符串以 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前⾯出现的字符个数（不包含 ‘\0’ )。
参数指向的字符串必须要以 ‘\0’ 结束。注意函数的返回值为size_t，是⽆符号的（易错）.
strlen的使⽤需要包含头⽂件<string.h>

实例：

#include <stdio.h>
#include <string.h>
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;
}

模拟实现：

#include <stdio.h>
#include <string.h>
#include <assert.h>
int my_strlen(const char* str)
{
	int count = 0;
	assert(str);
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

二、长度不受限的字符串函数：

1.strcpy

功能：将源指向的字符串复制到目标指向的数组中，包括’\0’，并返回目标数组起始地址。

库函数strcpy函数声明：
char strcpy(char * destination, const char * source );*

注意：
源字符串必须以 ‘\0’ 结束。
会将源字符串中的 ‘\0’ 拷⻉到⽬标空间。
⽬标空间必须⾜够⼤，以确保能存放源字符串。
⽬标空间必须可修改。

模拟实现：

#include <assert.h>
#include <stdio.h>
char* my_strcpy(char* p1, const char* p2)
{
	char* ret = p1;
	assert(p1);
	assert(p2);

	while ((*p1++ = *p2++))
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[] = { "abcdefg" };
	char arr2[] = { "hijklmn" };
	my_strcpy(arr1,arr2);
	return 0;
}

2. strcat

功能：将源字符串的副本追加到目标字符串尾部。目标字符串中的’\0’被源字符串的第一个字符覆盖，并且在目标字符串中由这两个字符串联而成的新字符串的末尾添加’\0’

库函数strcat函数声明：
char * strcat ( char * destination, const char * source );

注意：
源字符串必须以 ‘\0’ 结束。
⽬标字符串中也得有 \0 ，否则没办法知道追加从哪⾥开始。
⽬标空间必须有⾜够的⼤，能容纳下源字符串的内容。
⽬标空间必须可修改。

模拟实现：

char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest != NULL);
    assert(src != NULL);
 while(*dest)
 {
 dest++;
 }
 while((*dest++ = *src++))
 {
 ;
 }
 return ret;
}
int main()
{
	char arr1[50] = { "abcdefg" };
	char arr2[] = { "hijklmn" };
	my_strcat(arr1,arr2);
	return 0;
}

3. strcmp

功能：对两个字符串的每一个对应字符逐一比较，直到发现不相等为止。标准规定：第一个字符串大于第二个字符串，则返回大于0的数字。第一个字符串等于第二个字符串，则返回0。第一个字符串小于第二个字符串，则返回小于0的数字。

库函数strcmp声明：
int strcmp ( const char * str1, const char * str2 );

注意：
第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字
第⼀个字符串等于第⼆个字符串，则返回0
第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字

模拟实现;

#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 != null);
	assert(str2 != null);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

三、长度受限制的字符串函数：

1. strncpy

功能：将源字符串len个字符复制到目标字符串。如果strlen(source)小于len，destination用额外的’\0’填充到len长度。如果strlen(source)大于等于len，那么只有len个字符复制到destination中

库函数strncpy声明：
char * strncpy ( char * destination, const char * source, size_t num )；

注意：
拷⻉num个字符从源字符串到⽬标空间。
如果源字符串的⻓度⼩于num，则拷⻉完源字符串之后，在⽬标的后边追加0，直到num个。

模拟实现：

char* my_strncpy(char* destination, const char* source, size_t num)
{
	assert(destination && source);
	char* des = destination;
	while (num) 
	{
		num--;
		if ((*destination++ = *source++) != '\0') 
			;
		else
			break;
	}
	while (num) 
	{
		num--;
		*destination++ = '\0';
	}
	return des;
}

2. strncat

功能：从字符串source的开头拷贝n 个字符到destination字符串尾部，并追加’\0’字符。destination要有足够的空间来容纳要拷贝的字符串。如果n大于字符串source的长度，那么仅将src指向的字符串内容追加到dest的尾部。字符追加完成后，再追加’\0’。

库函数strncat声明：
char * strncat ( char * destination, const char * source, size_t num );

注意：
将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加⼀个 \0 字
符
如果source 指向的字符串的⻓度⼩于num的时候，只会将字符串中到\0 的内容追加到destination指向的字符串末尾

模拟实现：

char* my_strncat(char* destination, const char* source, size_t num)
{

	assert(destination && source);
	char* des = destination;
	while (*destination != '\0') 
	{
		destination++;
	}
	while (num) 
	{
		num--;
		if ((*destination = *source) != '\0')
		{
			destination++;
			source++;
		}
		else
		{
			break;
		}
	}
	*destination = '\0';
	return des;
}

3. strncmp

功能：比较两个字符串，但最多比较len个字节。如果两个字符串前len个字符相等返回0，str1大于str2返回大于0值，str1小于str2返回小于0的值

库函数strncmp声明：
int strncmp ( const char * str1, const char * str2, size_t num );

模拟实现：

int my_strncmp(const char* str1, const char* str2, size_t num)
{
	assert(str1 && str2);
	while (num--) 
	{
		if (*str1 == *str2) 
		{
			str1++;
			str2++;
		}
		else
		{
			return *str1 - *str2; 
		}
	}
	return 0; 
}

四、字符串查找函数：

1. strstr

功能：在str1查找整个str2第一次出现位置，并返回一个指向该位置的指针。如果str2没有完整地出现在str1的任何地方，函数返回NULL指针。如果str2是一个空字符串，函数返回str1指针

库函数声明：const char * strstr ( const char * str1, const char * str2 );

注意：
函数返回字符串str2在字符串str1中第⼀次出现的位置
字符串的⽐较匹配不包含 \0 字符，以 \0 作为结束标志

模拟实现：

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

}

2. strtok

功能：字符串切割，给定字符集，对源字符串的内容进行切割。

库函数strtok声明：
char * strtok ( char * str, const char * sep);

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

实例：

int main()
{
	char arr[] = "hello#world*first";
	char sep[] = "#*";
	char buf[20];
	char* str = NULL;
	strcpy(buf, arr);

	for (str = strtok(buf, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s\n", str);
	}
	return 0;
}

五、错误信息报告：

1.strerror

功能：返回错误码所对应的错误信息。

库函数strerror声明：
char * strerror ( int errnum );

注意：
使用此函数包含头文件#include <errno.h>
引入全局变量errno(错误码)

实例：

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
	FILE* pFile;
	pFile = fopen("unexist.ent", "r");
	if (pFile == NULL)
		printf("Error opening file unexist.ent: %s\n", strerror(errno));
	return 0;
}

六、字符分类函数：

在这里插入图片描述

七、内存函数：

1. memcpy

功能：函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。

注意：
这个函数在遇到 ‘\0’ 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

库函数memcpy声明：
void * memcpy ( void * destination, const void * source, size_t num );

模拟实现：

void* my_memcpy(void* dest,const void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return (ret);

}

2. memmove

功能：和memcpy的功能相似，但是memmove函数处理的源内存块和⽬标内存块是可以重叠的。

库函数memmove声明：
void * memmove ( void * destination, const void * source, size_t num );

注意：如果源空间和⽬标空间出现重叠，就得使⽤memmove函数处理。

模拟实现：

void* my_memmove(char* dest, char* src, size_t num)
{
	assert(dest && src);
	char* ret = dest;
	if (dest < src)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}  
	return ret;
}

3. memset

功能：将ptr中的num个字节设置成value。

库函数memset声明：
void * memset ( void * ptr, int value, size_t num );

模拟实现：

void* my_memset(void* ptr, int value, size_t num) {
	assert(ptr);
	void* ret = ptr;
	while (num--) {
		*(char*)ptr = value;  
		ptr = (char*)ptr + 1; 
	}
	return ret;
}

4.memcmp

功能：⽐较从ptr1和ptr2指针指向的位置开始，向后的num个字节。

库函数memcmp声明：
int memcmp ( const void * ptr1, const void * ptr2, size_t num );

模拟实现：

int my_memcmp(const void* ptr1, const void* ptr2, int num)
{
	const char* tmp_ptr1 = (const char*)ptr1;
	const char* tmp_ptr2 = (const char*)ptr2;
	for (int i = 0; i < num; i++)
	{
		if (*(tmp_ptr1 + i) > *(tmp_ptr2 + i))
			return 1;
		else if (*(tmp_ptr1 + i) < *(tmp_ptr2 + i))
			return -1;
	}
	return 0;
}

如果大家觉得这篇博客对你有帮助的话，请多多支持
本篇哪里有错误的话也希望大家能帮我指出！！！
在这里插入图片描述

我爱吃福鼎肉片

关注

46
点赞
踩
29

收藏

觉得还不错? 一键收藏
1
评论
c语言字符串函数和内存函数（图文详解）

在编程的过程中，我们经常要处理字符和字符串，为了⽅便操作字符和字符串，C语⾔标准库中提供了⼀系列库函数，在介绍字符串函数之前，我先来给这些个字符串函数分一下类：功能：获取的字符串长度，不包括’\0’。返回字符串的长度。实例：模拟实现：二、长度不受限的字符串函数：1.strcpy功能：将源指向的字符串复制到目标指向的数组中，包括’\0’，并返回目标数组起始地址。模拟实现：2. strcat功能：将源字符串的副本追加到目标字符串尾部。目标字符串中的’\0’被源字符串的第一个字符覆盖，并且在目标
复制链接

扫一扫