【C】字符串和内存操作函数的使用及模拟实现

已于 2023-08-28 19:47:03 修改
阅读量370 收藏
点赞数 1
文章标签： c语言 开发语言
于 2023-08-28 15:28:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaobai_wwx/article/details/132528653
版权

目录

🎈字符串函数

strlen

strcpy

strncpy

strcat

strncat

strcmp

strncmp

strstr

strtok

strerror

perror

字符分类函数

字符转换函数

tolower  

toupper

🎈内存操作函数

memcpy

memmove

memcmp

memset

本文和大家分享一些C语言中常用的字符串和内存处理函数的使用，以及如何去模拟实现

🎈字符串函数

使用字符串函数需要引用头文件  #include<string.h>

strlen

size_t  strlen(const  char*  str);     求字符串长度

· 字符串以'\0'作为结束标志，strlen返回的是'\0'前面的字符个数（不包括'\0'）

· 返回值是无符号整数

使用：

#include<stdio.h>
#include<string.h>

int main()
{
    char arr[] = "hello world";
    int ret = strlen(arr); //传入首元素地址
    printf("%d\n", ret);   //打印11
    return 0;
}

模拟实现：

#include<stdio.h>

unsigned_int my_strlen(char* str)
{
    int count = 0;
    while (*str++ != '\0')
    {  
        count++;
    }
    return count;
}

int main()
{
    char arr[] = "hello world";
    int ret = my_strlen(arr); //传入首元素地址
    printf("%d\n", ret);   //打印11
    return 0;
}
strcpy

char* strcpy(char* destination, const char* source);      字符串拷贝函数

· 源字符串必须以'\0'结尾，会将'\0'拷贝到目标空间里

· 目标空间必须足够大

· 目标空间必须可变

使用：

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[10] = "xxxxxxxxxx";
	char arr2[] = "wwx";
    char* ret = strcpy(arr1, arr2);
    //返回目标空间的首元素地址
	printf("%s", ret);
	return 0;
}

模拟实现：

#include<stdio.h>
#include<assert.h>

char*  my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest++ = *src++)
	{//dest为'\0'时，退出循环
		;
	}
	return ret;//返回目标空间的起始地址
}          

int main()
{
	char arr1[10] = "xxxxxxxxxx";
	char arr2[] = "wwx";
	printf("%s", my_strcpy(arr1, arr2));
	return 0;
}
strncpy

char* strcpy(char* destination, const char* source, unsigned int count); 

与strcpy用法相同，是可以控制长度的字符串拷贝函数

#include<stdio.h>
#include<string.h>

int main()
{
	char str1[] = "To be or not to be";
	char str2[40];
	char str3[40];
	strncpy(str2, str1, sizeof(str2));
	strncpy(str3, str2, 5);
	str3[5] = '\0'; //复制了前五个后添加终止符号
	puts(str1);//To be or not to be
	puts(str2);//To be or not to be
	puts(str3);//To be
	return 0;
}
strcat

char *strcat( char *Destination, const char *Source );      字符串追加函数

使用：

#include<stdio.h>
#include<string.h>

int main()
{
    char a[10] = "ABCDE";//要注意开辟足够的空间
	strcat(a, "FGH");    //从最后一个地址开始，源字符串必须要有\0
	printf("%s", a);     //输出ABCDEFGH    最好不要自己追加自己
	return 0; 
}

模拟实现：

#include<stdio.h>
#include<assert.h>

char* my_strcat(char* dest, const char* source)
{
	assert(dest && source);
	char* ret = dest;//储存目标空间的起始地址
	while (*dest != '\0')
	{//使目标指针指向\0
		dest++;
	}
	while (*dest++ = *source++)
	{//从\0开始追加,循环跳出说明源字符串'\0'追加完成
		;
	}
	return ret;//返回目标空间的起始地址
}
int main()
{
	char arr1[20] = "hello ";
	char arr2[6] = "world";
	char* ret = my_strcat(arr1, arr2);
	printf("%s", ret);
	return 0;
}
strncat

char *strncat( char *Dest, const char *Source, size_t count );   可控长度的追加函数

#include<stdio.h>
#include<string.h>

int main()
{
    char a[10] = "ABCDE";//要注意开辟足够的空间
	strncat(a, "FGHJKL", 3);    //追加三个字符
	printf("%s", a);     //输出ABCDEFGH    
	return 0; 
}
strcmp

int strcmp( const char *str1, const char *str2 );     字符串比较函数

· 比较的是相对应字符的ASCII码值

· str1大于str2，返回大于0的值，反之返回小于0的值，相等返回0

使用：

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcf";
	char arr2[] = "abcde";
	int ret = strcmp(arr1, arr2);
	if (ret == 0)
	{
		printf("arr1==arr2");
	}
	else if (ret > 0)
	{//输出
		printf("arr1 > arr2");
	}
	else
	{
		printf("arr1 < arr2");
	}
	return 0;
}

模拟实现：

#include<stdio.h>
#include<assert.h>

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 != '\0')
	{//遍历其中一个字符串
		int ret = *str1 - *str2;
        //对应的每一个字符相减
		if (ret != 0)
		{//不为零时直接返回
			return ret;
		}
		str1++;
		str2++;
	}
	return *str1 - *str2;
}
int main()
{
	char arr1[] = "abcf";
	char arr2[] = "abcde";
	int ret = my_strcmp(arr1, arr2);
	if (ret == 0)
	{
		printf("arr1==arr2");
	}
	else if (ret > 0)
	{
		printf("arr1 > arr2");
	}
	else
	{
		printf("arr1 < arr2");
	}
	return 0;
}
strncmp

int strncmp( const char *str1, const char *str2, size_t count );    可控长度的比较

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcf";
	char arr2[] = "abcde";
	int ret = strncmp(arr1, arr2, 2);
    //比较前两个字符
	if (ret == 0)
	{
		printf("arr1==arr2");
	}
	else if (ret > 0)
	{
		printf("arr1 > arr2");
	}
	else
	{
		printf("arr1 < arr2");
	}
	return 0;
}
strstr

char *strstr( const char *str, const char *strson );       在str中寻找子字符串

使用：

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "acdbcdefgh";
	char arr2[] = "defgh";
	char* ret = strstr(arr1, arr2);
    //在arr1中是否能找到arr2
	if (ret == NULL)
	{//找不到返回NULL
		printf("找不到！\n");
	}
	else
	{//找到则返回母串与子串对应的首字符地址
		printf("找到了！%s\n", ret);
	}
	return 0;
}

模拟实现：

#include<stdio.h>

char* my_strstr(const char* str1, const char* str2)
{//模拟实现
	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* cp = str1;
	if (*str2 == '\0')
	{//str2为空时
		return str1;
	}
	while (cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 && *s2 && *s1 == *s2)
		{//同为\0时，不加以上条件，可能导致越界访问
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{//说明\0之前的字符相同
			return cp;
		}
		cp++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "acdbcdefgh";
	char arr2[] = "defgh";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{//找不到返回NULL
		printf("找不到！\n");
	}
	else
	{//找到则返回母串与子串对应的首字符地址
		printf("找到了！%s\n", ret);
	}
	return 0;
}
strtok

char *strtok( char *str, const char *strDelimit );    字符串切割函数

· 将str以 strDelimit中的分隔符切割开来

使用：

#include<stdio.h>

int main()
{
	char arr1[] = "18870251842@163.com";
	char p[] = "@.";
    //将字符串内得到分隔符放在p内
	char arr2[30] = { 0 };
	strcpy(arr2, arr1);          
	//一般会拷贝一个字符串用来切割
	char* ret = NULL;
	for (ret = strtok(arr2, p); ret != NULL; ret = strtok(NULL, p))
	{//使用循环，减少代码冗余
		printf("%s\n", ret);
	}
	//ret = strtok(arr2, p); //18870251842
	//会找到第一个分隔符，将其替换为\0，记录位置，返回首字符地址
	
	//ret = strtok(NULL, p); //163
	//找到下一个分隔符，将其替换，并记录位置，返回记录位置的下一个位置地址，
	
	//ret = strtok(NULL, p); //com
	//同样，遇到\0函数结束，不可以使用\0作为分割字符，返回记录位置的下一个位置地址
	return 0;
}
strerror

char *strerror( int errno);       翻译错误信息

使用：

//库函数使用错误时，都会设置错误码
//只要调用库函数发生错误，就会将错误码放到 全局变量 errno 中
#include<stdio.h>
#include<errno.h>
int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{//文件打开失败，设置错误码
		printf("%s", strerror(errno)); //打印翻译的错误信息
		return 1;
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

部分错误信息表

perror

void perror( const char *string );            翻译并打印错误信息

字符分类函数

引用头文件  #include<ctype.h>

	char a = '1';
	int ret = islower(a);
	printf("%d\n", ret); //0
字符转换函数
tolower  

int tolower( int c );           转化为小写字符

toupper

int toupper( int c );           转化为大写字符

	char arr[20] = { 0 };
	scanf("%s", arr);
	int i = 0;
	while (arr[i] != '\0')
	{
		if (isupper(arr[i]) == 1)
		{//是大写就转换为小写字符
			arr[i] = tolower(arr[i]);
		}
		printf("%c ", arr[i]); 
		i++;
	}

🎈内存操作函数

需要引用头文件 #include<string.h>

memcpy

void *memcpy( void *dest, const void *src, size_t count );    内存拷贝函数

· 用来进行不重叠内存的拷贝

使用：

#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	memcpy(arr2, arr1, 40);
    //传入目标地址和源地址，拷贝的单位是字节
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

内存重叠时不要使用memcpy函数

#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	memcpy(arr1 + 2, arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]); //1 2 1 2 1 2 1 8 9 10 
        //不能保证所有的编译器都可以
	}
	return 0;
}

模拟实现：

#include<stdio.h>
#include<string.h>

void* my_memcpy(void* dest, const void* sou, int num)
{
	void* ret = (char*)dest;
	while (num--)
	{
		 *((char*)dest)++ = *((char*)src)++;
	}
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	my_memcpy(arr2, arr1, 40);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}
memmove

void *memmove( void *dest, const void *src, size_t count );    内存拷贝函数

· 功能与memcpy一样

· 可以处理内存重叠的情况

使用：

#include<stdio.h>
$include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1 + 2, arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]); // 1 2 1 2 3 4 5 8 9 10
	}
	return 0;
}

模拟实现：

#include<stdio.h>

void* my_memmove(void* dest, const void* sou, size_t num)
{
	void* ret = (char*)dest;
	if (dest < sou)
	{
		while (num--)
		{
            *((char*)dest)++ = *((char*)src)++;
		}
    	return ret;
	}
	else
	{
		while (num--)
		{//开始进入循环为20 再--  进入循环最小值为1，再--
			*((char*)dest + num) = *((char*)sou + num);
            //使用时num最小为0，最大为19
		}
     	return ret; 
	}
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1, arr1 + 2, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]); // 1 2 1 2 3 4 5 8 9 10
	}
	return 0;
}
memcmp

int memcmp( const void *buf1, const void *buf2, size_t count );   内存比较函数

使用：

#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6 };
	int arr2[] = { 1,2,3,260,5 };
	int ret = memcmp(arr1, arr2, 14); //比较的单位是字节
	printf("%d\n", ret);  //arr1>arr2,返回1，反之返回-1，相等返回0
	return 0;
}

模拟实现：

#include<stdio.h>

int my_memcmp(const void* p1, const void* p2, unsigned int num)
{
	while (num--)
	{
		int ret = *((char*)p1)++ - *((char*)p2)++;
		if (ret != 0)
		{
			return ret;
		}
	}
	return 0;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6 };
	int arr2[] = { 1,2,3,260,5 };
	int ret = my_memcmp(arr1, arr2, 20);
	printf("%d\n", ret); 
	return 0;
}
memset

void *memset( void *dest, int c, size_t count );         内存设置函数

· 将从目标地址开始的count个字节设置为c

使用：

#include<stdio.h>
#include<string.h>

int main()
{
	char arr[] = "XXXXXXXXXXXXXXX";
	char* ret = memset(arr, 'a', 5);
	printf("%s\n", ret);
	return 0;
}

模拟实现：

#include<stdio.h>

void* my_memset(void* dest, int c, unsigned int num)
{
	void* ret = dest;
	while (num--)
	{
		*((char*)dest)++ = c;
	}
	return ret;
}

int main()
{
	char arr[] = "XXXXXXXXXXXXXXX";
	char* ret = my_memset(arr, 'a', 5);
	printf("%s\n", ret);
	return 0;
}

这里介绍一些常用的函数，如果想要深入了解可以在C/CPP官方网站查看，感谢支持❤️❤️❤️

异码平穿
关注
【C语言】字符串和内存函数介绍及模拟实现
杨同学的博客
07-07 3341
本文内容：strlen，strcpy，strncpy，strcat，strncat，strcmp，strncmp，strstr，strtok，strerror，memcpy，memmove，memcmp
C语言-字符串操作函数和内存操作函数介绍及模拟实现
qq_43570634的博客
04-05 706
strlenstrlen介绍strlen的模拟实现strcpystrcpy介绍strcpy的模拟实现strncpystrncpy介绍strncpy的模拟实现strcatstrcat介绍strcat的模拟实现strncatstrncat介绍strncat的模拟实现strcmpstrcmp介绍strcmp的模拟实现strncmpstrncmp介绍strncmp的模拟实现strstrstrstr介绍strstr的模拟实现memcpymemcpy介绍memcpy的模拟实现memmovememmove介绍。
【C语言进阶】常见的字符串函数和内存函数详解及模拟实现
大猩猩！的博客
03-24 4019
总结了常见的字符串函数和内存函数，图文结合，通俗易懂，非常值得收藏学习。
【C语言】字符串函数及内存函数的模拟实现和原理
weixin_60371270的博客
09-17 734
本文简要介绍了C语言主要字符串函数和内存函数的功能和模拟实现。
C语言: 详解常用的字符串函数（使用+模拟实现）
须知少日拏云志，曾许人间第一流。
05-01 3578
前言: C语言中,字符串函数和字符函数的使用是很频繁的,如果我们能够熟练使用,能够帮助我们解决很多的字符问题。
【C语言】字符串函数和内存函数及其模拟实现
炸掉地球的博客
04-08 1302
本篇整理了C语言中针对字符串或者字符数组的各种操作的库函数以及内存操作函数，包括其用法和模拟实现的过程。包括strcpy、strcar、strcmp、strstr、strtok、strerror、memcpy、memmove、memcmp；isalpha、isdigit、tolower、toupper等函数。
【C语言】字符串函数和内存函数的使用及其模拟实现
学了就忘是正常现象
07-11 1334
C语言string.h中的库函数解析（字符串函数和内存函数）
C语言中常见字符串函数和内存操作函数
blue_jun_的博客
03-23 1718
目录 1.长度不受限制的字符串函数 1.1 strcpy 1.1.1 功能 1.1.2 实现条件 1.1.3 模拟实现 1.1.4 效果 1.2 strcat 1.2.1 功能 1.2.2 实现条件 1.2.3 模拟实现 1.2.4 效果 1.3 strcmp 1.3.1 功能 1.3.2 关于返回值 1.3.3 字符串比较依据 1.3.4 模拟实现 1.3.5 效果 2.长度受限制的字符串函数介绍 2.1 strncpy 2.1.1 功能 2.1.2 ...
字符串函数、字符函数、内存函数的使用及其模拟实现
在平淡的日子里寻找存在的价值
07-11 630
函数功能字符串长度，求一个字符串中字符的个数(不包含’\0’)。函数参数 函数使用 模拟实现(初阶) 模拟实现(进阶) 注意事项函数功能字符串拷贝，把一个字符串里面的内容拷贝到另一个字符串中去（包括’\0’）。函数参数 函数使用 模拟实现（初阶） 模拟实现（进阶） 注意事项函数功能字符串追加，在一个字符串的末尾追加另外一个字符串（包括’\0’）。函数参数 函数使用 模拟实现（初阶） 模拟实现（进阶） 注意事项函数功能字符串比较，以字节为单位比较两个字符串的大小函数参数 函数返回值 函数使用 模拟实现 注意事
【c语言：常用字符串函数与内存函数的使用与实现】
weixin_69380220的博客
11-29 1341
strlen、strcmp、strncmp、strcpy、strncpy、strcat、strncat、strstr、memcpy、memmove、memcmp函数的使用与实现
C语言中字符串的内存地址操作的相关函数简介
09-03
在C语言中，处理字符串和内存地址的操作是非常常见的任务，特别是在系统编程和底层开发中。本文主要介绍三个非标准但常在某些环境中使用的函数：bcopy()、bzero()和bcmp()，它们分别用于内存复制、清零和比较。 1. ...
C语言--字符串操作函数、内存操作函数介绍及模拟实现
羟基与苯的博客
03-29 1536
文章目录前言一、函数介绍1.1 strlen1.2 strcpy1.3 strcat1.4 strcmp1.5 长度受限制的字符串函数strncpy、strncat、strncmp1.5.1 strncpy1.5.2 strncat1.5.3 strncmp1.6 strstr1.7 strtok1.8 strerror1.9 perror1.10 字符分类函数1.11 memcpy1.12 memmove1.13 memcmp1.14 memset二、库函数模拟实现2.1 模拟实现strlen2.2 模拟
c语言字符函数和字符串函数介绍
weixin_59371851的博客
06-13 1246
目录前言一、strlen函数1.简介2、模拟实现2.1计数器方式2.2递归方式2.3指针的方式二、strcpy函数1.简介2.模拟实现三、strcat函数1.简介2、模拟实现四、strcamp函数1、简介2、模拟实现五、strncpy函数六、strncat函数七、strncmp函数八、strstr函数1、简介2.模拟实现9、strtok函数 1、简介2、举例10、strerror函数11、memcpy函数1、简介2、模拟实现12、memmove函数1、简介2、模拟实现 13、memcmp函数c语言中对字符和
【C语言系统编程】【第二部分：并发编程】2.1 进程与线程
10-04 1271
在多线程编程中，有时我们希望为每个线程存储特定的数据，线程局部存储（TLS）就是为每个线程单独维护这样的数据空间的机制。一个进程可以包含多个线程，这些线程共享进程的资源，如内存空间、打开的文件等，但每个线程有自己的栈空间和寄存器。这种机制在开发需要线程安全且使用线程局部变量的应用时非常有用，例如线程池中处理不同的工作任务，需要为每个线程储存其独立的状态或数据时。线程的属性可以在创建线程时进行设置，以满足特定场景的需求。通过以上步骤，线程特定数据可以为每个线程提供独立的数据存储，避免了线程间数据干扰的问题。
C 语言预处理详解：从宏替换到条件编译
w3192285717的博客
10-03 999
在 C 语言编程中，预处理是一个非常重要的阶段，它发生在编译器实际编译代码之前。预处理器的任务是处理源代码中的预处理指令，这些指令以开头。预处理阶段的主要任务包括头文件展开、去注释、宏替换和条件编译。本文将详细介绍这些预处理步骤，帮助你更好地理解 C 语言的预处理机制。预处理（Preprocessing）是 C 语言编译过程中的第一个阶段。在这个阶段，预处理器会处理源代码中的预处理指令，如#include#define#ifdef等。
C语言 | Leetcode C语言题解之第459题重复的子字符串
m0_59237910的博客
10-06 347
C语言 | Leetcode C语言题解之第459题重复的子字符串
C语言——宏定义相关
phosphophylite的博客
09-30 362
宏定义函数的参数无数据类型，可实现模板函数的功能?有一个技巧：利用\ } else {\ } else {do\ } else {\ } else {if\ } else {\ } else {==\ } else {\ } else {\ } else {\ } else {<<\ } else {<<\ } else {\ } else {;
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 2145
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
深入剖析Oracle与MySQL在事务处理上的差异
最新发布
10-06
在数据库管理系统中，事务处理是确保数据一致性和完整性的关键机制。Oracle和MySQL作为两大主流的数据库系统，在事务处理方面有着各自的特点和差异。本文将从事务的基本概念、隔离级别、锁机制以及事务控制语句等方面，详细探讨Oracle与MySQL在事务处理上的差异，并提供代码示例。 Oracle和MySQL在事务处理上有着各自的特点。Oracle提供了强大的并发控制和隔离级别管理，适合处理复杂的企业级事务。MySQL则以其简单性和灵活性，在Web应用和中小型项目中广泛使用。了解这些差异对于开发者选择合适的数据库系统以及优化事务处理至关重要。通过本文的分析和代码示例，读者应该能够更深入地理解Oracle与MySQL在事务处理上的差异，并在实际应用中做出更合适的选择。
c语言字符串替换函数模拟实现
07-25
C语言字符串替换函数模拟实现的方法有很多，以下是一种可能的实现方式： ```c #include #include void str_replace(char *str, const char *find, const char *replace) { int find_len = strlen(find); int ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值