首页 > 系统相关 >字符串函数和内存函数

字符串函数和内存函数

时间：2024-03-15 19:29:34浏览次数：30  
标签：src return 函数 dest str2 str1 char 内存 字符串

简介：本文将介绍常使用的字符串函数和内存函数，以及对其进行模拟实现，以便能够更好的理解这些函数的使用

1、常见的字符串函数

常用的字符串函数有strcpy,strcat,strcmp,strncpy,strncat,strncmp,strstr等。这些函数是针对字符串进行操作的，这些函数都需要包含头文件string.h，下面逐步介绍这些函数并尝试模拟实现。

①strcpy函数

strcpy函数是库函数，需要包含头文件string.h，功能是将源地址空间的字符串拷贝到目标空间，要求目标空间要足够大（能够容下源地址空间的字符串），要求原地址空间必须包含'\0'，这是由于strcpy将源地址空间拷贝到目标空间，源地址到的'\0'（包括'\0'）都要拷贝到目标空间。strcpy库函数的参数如下所示，返回类型是char*，拷贝完成返回目标空间的起始地址，该函数第一个参数是目标空间的起始地址，类型是char*，第二个参数是源空间的起始地址类型也是char*。

strcpy模拟实现代码如下：

char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);//保证dest和src不是NULL
	char* ret = dest;
	while (*dest++ = *src++)//将src指向的内容拷贝到dest指向的内容,最后一个'\0'也会拷贝过去，这时循环也会结束
	{
		;
	}
	return ret;//返回目标空间的起始地址
}

测试代码如下：

#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);//保证dest和src不是NULL
	char* ret = dest;
	while (*dest++ = *src++)//将src指向的内容拷贝到dest指向的内容,最后一个'\0'也会拷贝过去，这时循环也会结束
	{
		;
	}
	return ret;//返回目标空间的起始地址
}
int main()
{
	char arr1[] = "asdfasdfasd";
	char arr2[] = "heheawe";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);
}

strcpy测试结果如下：

② strcat函数

strcat也是库函数，需要包含头文件string.h，功能是在目标空间的'\0'处追加源地址的字符串，要求目标空间必须存在'\0'，源地址空间也需要有'\0'。因为strcat库函数需要找到目标空间的'\0'在这个位置上追加源地址空间的内容，所以源地址空间也需要'\0'，不然没法知道什么时候结束。strcat函数参数如下所示，返回类型也是char*，返回的目标空间的起始地址，第一个参数表示目标空间的地址，第二个参数是源空间的地址。

strcat模拟实现如下：

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	//找到dest的'\0'
	while (*dest)
		dest++;
	//将src中的内容拷贝到src中
	while (*dest++ = *src++)
		;
	return ret;//返回目标空间的起始地址
}

strcat测试代码如下：

#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	//找到dest的'\0'
	while (*dest)
		dest++;
	//将src中的内容拷贝到src中
	while (*dest++ = *src++)
		;
	return ret;//返回目标空间的起始地址
}
int main()
{
	char arr1[30] = "www";
	char arr2[] = "asdfxs";
	char* ret = my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	printf("%s\n", ret);
	return 0;
}

strcat测试结果如下：

③strcmp函数

strcmp也是库函数，需要包含头文件string.h，是比较两个字符串的大小，其参数如下图所示，返回值是整形，当第一个字符串大于第二个字符串就返回大于0的数，小于就返回小于0的数，等于就返回0。

strcmp模拟实现的代码如下：（模拟实现采用的是当第一个字符串大于第二个字符串就返回1的数，小于就返回-1，等于就返回0）

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

strcmp测试代码如下：

#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == *str2&&*str1=='\0')
			return 0;
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;
	else
		return -1;
}
int main()
{
	char arr1[] = "asdf";
	char arr2[] = "asd";
	int ret1 = my_strcmp(arr1, arr2);
	printf("%d\n", ret1);
	char arr3[] = "asdf";
	char arr4[] = "asdf";
	int ret2 = my_strcmp(arr3, arr4);
	printf("%d\n", ret2);
	char arr5[] = "asd";
	char arr6[] = "asdf";
	int ret3 = my_strcmp(arr5, arr6);
	printf("%d\n", ret3);
	return 0;
}

strcmp测试结果如下： 

④strncpy函数

strncpy是库函数，是长度受限的，功能与strcpy是一样的，只是多了一个长度，其参数形式如下图所示，返回的是目标空间的起始地址,第一个参数是目标空间的地址，第二个参数是源空间地址，第三个参数表示要拷贝的字节数（要从源空间拷贝多少个字节到目标空间），当num小于源地址空间的字符个数就拷贝num个字符，当num大于源地址空间的字符个数就将源地址空间的字符全拷贝过来不够的就用'\0'来补。

strcpy模拟实现代码如下：

char* my_strncpy(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* ret = dest;
	while (count--)
	{
		*dest = *src;
		if (*src)//防止越界，并且当count大于源空间字符数就会用'\0'来给目标空间赋值
			src++;
		dest++;
	}
	return ret;
}

strncpy测试代码如下：

#include<stdio.h>
#include<string.h>
#include<assert.h>
//strncpy--源字符串不够就用'\0'来补，如果够，将源中的count个拷贝到目的地里
char* my_strncpy(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* ret = dest;
	while (count--)
	{
		*dest = *src;
		if (*src)
			src++;
		dest++;
	}
	return ret;
}
int main()
{
	char arr1[20] = "xxxxxxxxxxxxx";
	char arr2[] = "cvztvv";
	my_strncpy(arr1, arr2, 8);
	return 0;
}

strncpy测试结果如下：

⑤strncat函数

strncat是库函数，是长度受限的，功能与strcat是一样的，只是多了一个长度，其参数形式如下图所示，返回的是目标空间的起始地址,第一个参数是目标空间的地址，第二个参数是源空间地址，第三个参数表示要追加的字节数（要从源空间追加多少个字节到目标空间里），也是从'目标空间中的\0'处开始追加,如果num小于源空间中的字符数追加num个字符后还会在最后追加一个'\0'，如果num大于源空间中的字符数就会将源空间都追加到目标空间，再在目标后面加一个'\0'

strncat模拟实现代码如下：

char* my_strncat(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest)//找到目标空间的'\0'
		dest++;
	while (count--)
	{
		if (*src != '\0')
		{
			*dest = *src;
			dest++;
			src++;
		}
		else
		{
			*dest = *src;
			return ret;
		}
	}
	*dest = '\0';
	return ret;
}

strncat测试代码如下：

#include<stdio.h>
#include<string.h>
#include<assert.h>
//在dest的'\0'这个位置开始追加，追加count个，并在后面补'\0'，如果count个数大于src字符串的个数将src中的字符加完就结束了
char* my_strncat(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest) // 找到目标空间的'\0'
		dest++;
	while (count--)
	{
		if (*src != '\0')
		{
			*dest = *src;
			dest++;
			src++;
		}
		else
		{
			*dest = *src;
			return ret;
		}
	}
	*dest = '\0';
	return ret;
}
int main()
{
	char arr1[20] = "xxxxxxx\0xxxxxxxxxxxx";
	char arr2[] = "cvztvv";
	my_strncat(arr1, arr2, 8);
	return 0;
}

strncat测试结果如下：

 ⑥strncmp函数

strncmp是库函数，是长度受限的，功能与strcmp是一样的，只是多了一个长度，其参数形式如下图所示，返回的是目标空间的起始地址,第一个参数是目标空间的地址，第二个参数是源空间地址，第三个参数表示要比较的字节数，如果num大于这个str1或者str2，就相当于strcmp，num小于str1或str2的话就依次比较num个字符，相等就返回0，不相等就返回大于0的数或小于0的数（第一个字符串对应的这个字符大于第二个字符串对应的这个字符就返回大于0的数，第一个字符串对应的这个字符小于第二个字符串对应的这个字符就返回小于0的数）。

strncmp模拟实现代码如下： 

int my_strncmp(const char* str1, const char* str2, size_t count)
{
	assert(str1 && str2);
	while (count--)
	{
		if (*str1 != *str2)//不相等就直接返回两者的差
		{
			return *str1 - *str2;
		}
		if (*str1 != 0)
		{
			str1++;
		}
		if (*str2 != 0)
		{
			str2++;
		}
	}
	return 0;
}

strncmp测试代码如下：

#include<stdio.h>
#include<assert.h>
#include<string.h>
//模拟实现strncmp函数
int my_strncmp(const char* str1, const char* str2, size_t count)
{
	assert(str1 && str2);
	while (count--)
	{
		if (*str1 != *str2)//不相等就直接返回两者的差
		{
			return *str1 - *str2;
		}
		if (*str1 != 0)
		{
			str1++;
		}
		if (*str2 != 0)
		{
			str2++;
		}
	}
	return 0;
}
int main()
{
	char str1[] = "asd6";
	char str2[] = "asd6aef";
	int ret = my_strncmp(str1, str2, 6);
	ret= strncmp(str1, str2, 6);
	printf("%d\n", ret);
	return 0;
}

strncmp测试结果如下：

⑦strstr函数

strstr函数是库函数，其功能是找str2是否是str1的子串，如果是子串就返回str1这个字符中第一次出现这个子串的地址，如果不是子串就返回NULL。其参数如下图所示，由于不需要对其进行修改所以都加了const进行修饰。

//对于str1这个字符串每次匹配都要一个指针（进行站岗），另一个指针是用来移动匹配的，str2也是如此，如果这个站岗指针走完还没匹配成功返回NULL，找到就返回这个str1第一次出现str2这个子串的地址其实就是这个站岗指针
const char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* tmp1 = str1;
	const char* tmp2 = str2;
	while (*str1!='\0')//从str1字符串中的头开始匹配
	{
		while (*tmp1 == *tmp2)
		{
			if (*tmp2 == '\0')
				return str1;
			tmp1++;
			tmp2++;
		}
		if (*tmp2 == '\0')
		{
			return str1;
		}
		else
		{
			str1++;
			tmp1 = str1;
			tmp2 = str2;
		}
	}
	//循环完了还没返回那就表示找不到返回NULL
	return NULL;
}

 strstr测试代码如下：

#include<stdio.h>
#include<assert.h>
//对于str1这个字符串每次匹配都要一个指针（进行站岗），另一个指针是用来移动匹配的，str2也是如此，如果这个站岗指针走完还没匹配成功返回NULL，找到就返回这个str1第一次出现str2这个子串的地址其实就是这个站岗指针
const char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* tmp1 = str1;
	const char* tmp2 = str2;
	while (*str1!='\0')//从str1字符串中的头开始匹配
	{
		while (*tmp1 == *tmp2)
		{
			if (*tmp2 == '\0')
				return str1;
			tmp1++;
			tmp2++;
		}
		if (*tmp2 == '\0')
		{
			return str1;
		}
		else
		{
			str1++;
			tmp1 = str1;
			tmp2 = str2;
		}
	}
	//循环完了还没返回那就表示找不到返回NULL
	return NULL;
}

int main()
{
	char arr1[] = "affj";
	char arr2[] = "affj";
	const char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("arr2不是arr1的子串\n");
	}
	else
	{
		printf("arr2是arr1的子串\n");
		printf("%s\n", ret);
	}
	return 0;
}

 strstr测试结果如下:

2、常见的内存函数

常见的内存函数有memcpy，memmove,memset等，这些内存函数也需要包含头文件string.h，下面将逐步介绍这些内存函数的功能和模拟实现。

①memcpy函数

memcpy是库函数，这个函数的功能是进行拷贝，将源地址的字符拷贝到目标地址（这两块空间要求不重叠），其功能与strcpy类似，strcpy是针对字符串的，而memcpy函数不论是字符串还是整形，结构体等数据类型都能进行拷贝。memcpy函数的参数如下图所示，可以看到返回类型是void*，第一个参数也是void*，第二个参数也是void*,第三个参数是num（指的是从源拷贝到目标的字节个数）

memcpy函数模拟实现代码如下：

void* my_memcpy(void* dest, void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	while (count--)//一个一个字节的进行拷贝，拷贝count次
	{
		*(char*) dest= *(char*)src;
		dest = (char*)dest+1;
		src = (char*)src+1;
	}
	return ret;
}

memcpy函数测试代码如下：

#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	while (count--)//一个一个字节的进行拷贝，拷贝count次
	{
		*(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,8,9,10 };
	int arr2[15] = { 0 };
	my_memcpy(arr2, arr1, sizeof(arr1));
	int i = 0;
	for (i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

memcpy函数测试结果如下：

 ②memmove函数

memmove是库函数，这个函数的功能是进行拷贝，将源地址的字符拷贝到目标地址（这两块空间可以重叠也可以不重叠），memmove函数不论是字符串还是整形，结构体等数据类型都能进行拷贝。memmove函数的参数如下图所示，可以看到返回类型是void*，第一个参数也是void*，第二个参数也是void*,第三个参数是num（指的是从源拷贝到目标的字节个数）

 memmove函数模拟实现代码如下：

void* my_memmove(void* dest, void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	if (dest > src)//从后往前拷贝
	{
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	else//从前往后拷贝
	{
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	return ret;
}

memmove函数测试代码如下：

#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	if (dest > src)//从后往前拷贝
	{
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	else//从前往后拷贝
	{
		while (count--)
		{
			*(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,8,9,10 };
	my_memmove(arr1, arr1 + 3, 5*sizeof(int));
	for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	int arr2[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr2+3, arr2, 5 * sizeof(int));
	for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

 memmove函数测试结果如下：

③memset函数

memset函数是库函数，功能是将ptr指向的内存块的前num个字节设置为value，其函数参数形式如下

 memset函数模拟实现代码如下：

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

memset测试代码如下：

void* my_memset(void* ptr, int value, size_t num)
{
	assert(ptr);
	while (num--)
	{
		*((char*)ptr + num) = value;
	}
	return ptr;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memset(arr1, 0, sizeof(arr1));
	for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

memset测试结果如下：

总结：本篇文章介绍了常用的字符串函数和内存函数的参数，功能以及模拟实现,还对这些实现的函数进行了一些简单的测试，基本上与库函数的功能一致，以便更好地在未来编程中理解和使用这些库函数。感谢大家的观看，如有错误不足之处欢迎大家批评指正！！！ 

标签：src,return,函数,dest,str2,str1,char,内存,字符串
From： https://blog.csdn.net/weixin_56898048/article/details/136741391

相关文章

  • OpenMP - runtime库函数
    常用函数。#include<iostream>#include<omp.h>#defineNUM_THREADS16usingnamespacestd;intmain(intargc,char*argv[]){omp_set_num_threads(NUM_THREADS);#pragmaompparallel{cout<<"threadnum:"<&......
  • TRIM()：从字符串中删除不必要的前导和后缀字符
    TRIM()、LTRIM()、RTRIM()1、TRIM()：从字符串中删除前导和后缀字符TRIM()：从字符串中删除不必要的前导和后缀字符语法：TRIM([{BOTH|LEADING|TRAILING}[removed_str]]FROMstr);--BOTH:删除前缀和后缀，默认是BOTH--LEADING：删除前缀--TRAILING：删除后缀--removed_str：删除......
  • 1768. 交替合并字符串c
    char*mergeAlternately(char*word1,char*word2){intn1=strlen(word1),n2=strlen(word2);char*temp=(char*)malloc(sizeof(char)*(n1+n2+1));intindex1=0,index2=0,index=0,tag=0;while(index1<n1&&index2<n2){if(tag=......
  • grep sed 大批量替换字符串
    sed-is/"str1"/"str2"/g`grep"str1"-rl--include="*.[ch]"./`将当前目录下的所有.c、.h文件中的str1字符串替换为str2字符串。参数解释:sed:-i表示操作的是文件，``括起来的grep命令，表示将grep命令的的结果作为操作文件s/"str1"/"str2"/表示查找str1并替换为str2，后面......
  • Python 函数的不定长参数介绍 -- argc/*argcs/**kargcs
    目录一.前言二.Python不定长参数argc/*kargcs简介1.函数不定长参数*args使用2.函数不定长参数**kwargs使用3.函数不定长参数*args和**kwargs只能放在形参的末尾，顺序不能错.三.Python不定长参数argc/*kargcs实战四.Python不定长参数argc/*kargcs总结五......
  • 全新芒果YOLOv8改进专栏 | 专栏目录：目前已有100+篇内容，内含各种Head检测头、标签分配
    内含各种Head检测头、标签分配策略、损失函数Loss、Backbone、Neck、写作|指标、NMS等全方位创新点改进全新芒果YOLOv8改进专栏来袭： 专栏地址......
  • C语言中抽象函数与具体实现的命名与组织
    C语言中抽象函数与具体实现的命名与组织在C语言的项目开发中，尤其是嵌入式系统和开源软件项目里，合理地命名和组织抽象函数及其具体实现对于提高代码的可读性、可维护性和可扩展性至关重要。以下是关于如何在这些项目中有效地处理抽象和实现的一些建议：抽象函数与具体实现的区分A......
  • Qt opengl和qlabel的update同时更新，内存泄漏问题
    工作要做一个类似播放器的软件，但是需要自己解码，然后可能多张图像合成再显示，所以不能直接用QT播放视频的模块，就用了QOpenGLWidget来渲染。后面发现内存一直在涨，一直以为是自己的原因，因为解码分配的内存挺多的，折腾了快一个月了，后面发现是update频繁更新导致；如下代码，XVideoWidget继......
  • 代码随想录算法训练营第七天｜LeetCode 344.反转字符串、541.反转字符串II、卡码网54.替
    344.反转字符串题目描述：​编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组s的形式给出。不要给另外的数组分配额外的空间，你必须**原地修改输入数组**、使用O(1)的额外空间解决这一问题。示例一:输入：s=["h","e","l","l","o"]输出：["o","l","l......
  • VLOOKUP函数用法
    1、常规用法，对比人员部门调整后，而且两组数据值错乱（如表AB列和DE列数据），但使用vlookup函数就可以快速知道哪些人员部门调整过，哪些人员部门未动，方便管理员快速的进行区分统计数据=VLOOKUP(A3,$D$2:$E$12,2,FALSE)vlookupvlookup函数A3为需要查找......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99