对字符串和内存函数的应用及模拟

已于 2022-01-24 14:09:21 修改
阅读量1.2k 收藏 6
点赞数 17
分类专栏： C语言和初阶数据结构笔记 文章标签： 蓝桥杯 c语言 散列表
于 2022-01-24 14:02:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53316121/article/details/122644981
版权

目录

1.strlen 求字符串长度

使用案例：

1.计数法

2.不创建临时变量计数器-递归

3.指针-指针的方式

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

1.strcpy

使用案例：

模拟实现： 

2.strcat

使用案例：

 模拟实现：

3.strcmp-比较字符串首字母的大小

使用案例：

模拟实现：

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

1.strncpy

使用案例：

2.strncat 

使用案例：

3.strncmp

使用案例：

4.strstr-找子串 

使用案例：

模拟实现：

5.strtok

用法：

改进：

6.strerror

展示：

使用方式：

7.memcpy-不重复内存拷贝

使用案例：

模拟实现： 

8.memmove-可处理重复内存拷贝

使用案例：

模拟实现： 

9.memcmp

10.memset

应用方式：

1.strlen 求字符串长度

size_t strlen ( const char * str );
//返回值是unsigned int类型

使用案例：

#include <stdio.h>
int main()
{
	char arr[] = { "abcde" };
	printf("%d\n",strlen(arr));
	return 0;
}

我们知道在arr数组里，最后一个字符'e'后，默认是'\0',而strlen遇到'\0'则会结束运行，且返回的是在字符串中 '\0' 前面出现的字符个数（不包 含 '\0' )。

我们可以根据这个来对strlen进行模拟实现:

1.计数法

#include <stdio.h>
#include <assert.h>
int my_strlen(const char* str)
{
	assert(str);
	int count = 0;    //计数
	while (*str)      //解引用判断元素是否为'\0'
	{
		count++;
		str++;      //地址++
	}
	return count;   //返回计数
}

int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);
	return 0;
}

2.不创建临时变量计数器-递归

#include <stdio.h>
#include <assert.h>
int my_strlen(const char * str)
{
	assert(str);
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}

int main()
{
	char arr[] = {"abcdef"};
	int ret = my_strlen(arr);
	printf("%d\n", ret);
	return 0;
}

3.指针-指针的方式

#include <stdio.h>
#include <assert.h>
int my_strlen(char *s)
{
	char *p = s;
	while (*p != '\0')
		p++;
	return p - s;     //指针相减是长度
}

int main()
{
	char arr[] = {"abcdef"};
	int ret = my_strlen(arr);
	printf("%d\n", ret);
	return 0;
}

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

1.strcpy

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

源字符串必须以 '\0' 结束。

会将源字符串中的 '\0' 拷贝到目标空间。

目标空间必须足够大，以确保能存放源字符串。

目标空间必须可变。

使用案例：

#include <stdio.h>
#include <assert.h>
int main()
{
	char arr1[] = {'a', 'b', 'c', 'd', 'e', 'f', '\0'};
	char arr2[20] = "xxxxxxxxxxxx";
	strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

模拟实现： 

#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	//保留起始地址
	assert(dest && src);
	while (*dest++ = *src++)  //这里不打印'\0'之后的
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[] = {'a', 'b', 'c', 'd', 'e', 'f', '\0'};
	char arr2[20] = "xxxxxxxxxxxx";
	my_strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

2.strcat

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

源字符串必须以 '\0' 结束。

目标空间必须有足够的大，能容纳下源字符串的内容。

目标空间必须可修改。

使用案例：

#include <stdio.h>
#include <assert.h>
int main()
{
	char arr1[30] = "hello";//注意初始化方式，必须要包含'\0'
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

 模拟实现：

#include <stdio.h>
#include <assert.h>
char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	//保留起始地址，方便找回打印
	assert(dest && src);
	//1. 找目标空间中的\0，打印的起点
	while (*dest)
	{
		dest++;
	}
	//2. 追加内容到目标空间
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[30] = "hello";//注意初始化方式，必须要包含'\0'
	char arr2[] = "world";
	printf("%s\n", my_strcat(arr1, arr2));
	return 0;
}

3.strcmp-比较字符串首字母的大小

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

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

使用案例：

#include <stdio.h>
#include <assert.h>
int main()
{
	char arr1[] = "degh";
	char arr2[] = "bcdefx";
	int ret = strcmp(arr1, arr2);
	if (ret<0)
	{
		printf("arr1<arr2");
	}
	else if (ret >0)
	{
		printf("arr1>arr2");
	}
	else
	{
		printf("arr1==arr2");
	}
	return 0;
}

 就是根据返回的值来判断两个字符串大小

模拟实现：

//模拟实现strcmp-比较对应位置字符串大小
//相同的话地址各向后加一继续比较
//注意strcmp返回的是大于等于或小于0的整型
#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* str1, const char*str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		//若相等，各向后+1继续比较
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

int main()
{
	char arr1[] = "degh";
	char arr2[] = "bcdefx";
	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;
}

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

1.strncpy

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

相较于strcpy，strncpy函数有了对字符长度的限制，更加的灵活

使用案例：

#include <stdio.h>
#include <assert.h>
int main()
{
	char arr1[] = {'a', 'b', 'c', 'd', 'e', 'f', '\0'};
	char arr2[20] = "xxxxxxxxxxxx";
	strncpy(arr2, arr1,4);
	printf("%s\n", arr2);
	return 0;
}

2.strncat 

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

使用案例：

#include <stdio.h>
#include <assert.h>
int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
	strncat(arr1, arr2,3);
	printf("%s\n", arr1);
	return 0;
}

若给的数字超过了arr2的长度，如：

	strncat(arr1, arr2,7);

则

 只会追加到arr2元素中的'\0'结束。

3.strncmp

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

使用案例：

#include <stdio.h>
#include <assert.h>
int main()
{
	char arr1[] = "degh";
	char arr2[] = "bcdefx";
	int ret = strncmp(arr1, arr2,3);
	if (ret<0)
	{
		printf("arr1<arr2");
	}
	else if (ret >0)
	{
		printf("arr1>arr2");
	}
	else
	{
		printf("arr1==arr2");
	}
	return 0;
}

这里的数字3表明比较的是前3个 字符串的大小。

4.strstr-找子串 

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

在字符串里找子串，返回找到子串的起始地址

找不到则返回空指针

使用案例：

#include <stdio.h>
int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbcq";

	char* ret = strstr(arr1, arr2);  //因为返回的是地址，要用指针接收

	if (NULL == ret)
		printf("没找到\n");
	else
		printf("%s\n", ret);
	return 0;
}

模拟实现：

#include <stdio.h>
#include <assert.h>
char* my_strstr(const char* str, const char* substr)
{
	const char* s1 = str;
	const char* s2 = substr;
	const char* cur = str;   //记录字符串起始位置，在改变

	assert(str && substr);
	if (*substr == '\0')
	{
		return (char*)str;
	}
	while (*cur)   //如果*cur为'\0'，则找不到，返回空指针
	{
		s1 = cur;
		s2 = substr;
		while (*s1 &&  *s2 && *s1 == *s2) //*s1 *s2不为'\0'
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')    //找到了
			return (char*)cur;   //返回起始位置
		cur++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbcq";

	char* ret = my_strstr(arr1, arr2);

	if (NULL == ret)
		printf("没找到\n");
	else
		printf("%s\n", ret);
	return 0;
}

 

5.strtok

应用：将字符串里面除了分隔符外的其他内容提出来

char * strtok ( char * str, const char * sep );

第一个参数指定一个字符串，包含了字符串和分隔符

sep参数是个字符串，定义了用作分隔符的字符集合

例如：

	const char* p = "*.-";
	char arr[] = "sukabulie*wula.wushi-baga";

sep=p       str=arr

注：strtok会改变第一个字符串里的内容（将分隔符改为\0），因此不能直接将源字符串传过去，可以临时拷贝一份

	char buf[50] = { 0 };
	strcpy(buf,arr);

那么接下来要传参时第一个参数用buf就好。

注：strtok函数的第一个参数不为空指针 ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

strtok函数的第一个参数为空指针 ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

如果字符串中不存在更多的标记，则返回空指针。

用法：

	char* str = strtok(buf, p);//sukabulie
	printf("%s\n", str);
	str = strtok(NULL, p);//wula
	printf("%s\n", str);
	str = strtok(NULL, p);//wushi
	printf("%s\n", str);
	str = strtok(NULL, p);//baga
	printf("%s\n", str);

打印效果：

 

我们发现这样的写法很笨，当我们不知道一个字符串它有多少分段时就很麻烦，我们可以用for循环来解决这个问题。

改进：

#include <stdio.h>
#include <string.h>
int main()
{
	const char* p = "*.-";
	char arr[] = "sukabulie*wula.wushi-baga";
	char buf[50] = { 0 };
	strcpy(buf, arr);
	for (char* str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
	{
		printf("%s\n",str);
	}
	return 0;
}

6.strerror

返回错误码所对应的错误信息

C语言中规定了一些错误码及它所对应的意思（错误信息）

char * strerror ( int errnum );

int errnum 是错误码         函数返回的是错误信息的起始地址

展示：

#include <stdio.h>
int main() 
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%s\n", strerror(i));
	}
	return 0;
}

使用方式：

当我们运行一个程序遇到错误，跑不过去时，可以在他执行错误代码段的下一行用

printf("%s\n",strerror(errno));

//注意要引用头文件
#include <errno.h>

errno是c语言提供的一个全局变量，可直接使用，当程序发生错误时，他会改变为相对应的错误码，我们就可以用strerror函数得到相对应的错误信息。

7.memcpy-不重复内存拷贝

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

将source里的元素通过字节数来拷贝到destination中

使用案例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int arr2[5] = { 0 };
	memcpy(arr2,arr1,5*sizeof(arr2[0]));
	int i = 0;
	for (i=0;i<5;i++)
	{
		printf("%d\n",arr2[i]);
	}
	return 0;
}

模拟实现： 

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

void* my_memcpy(void* dest, const void*src, size_t num)
{
	void* ret = dest;   //保留要返回的起始地址
	assert(dest&&src);
	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, 8, 9 };
	int arr2[5] = { 0 };
	my_memcpy(arr2, arr1, 5 * sizeof(arr2[0]));
	int i = 0;
	for (i = 0; i<5; i++)
	{
		printf("%d\n", arr2[i]);
	}
	return 0;
}

 注意：c语言中要求memcpy只要可以拷贝没有重复的内存就可以了，但是在vs下memcpy也可以处理重复的内存。

若按我们写的来举例，我们的memcpy是不支持重复内存的处理：

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

如若是这样拷贝，那么我们想的打印出来的应该是1 2 1 2 3 4 5 8 9

实际上是：1 2 1 2 1 2 1 8 9

 用memcpy来实现：

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int arr2[5] = { 0 };
	memcpy(arr1+2, arr1, 5 * sizeof(arr1[0]));
	int i = 0;
	for (i = 0; i<9; i++)
	{
		printf("%d\n", arr1[i]);
	}
	return 0;
}

 在vs下库函数memcpy功能更加强大，可处理重复内存，c语言只要求它能处理不重复的内存即可，处理重复内存时用库函数memmove，因此我们模拟的memcpy正确。

8.memmove-可处理重复内存拷贝

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

类型与memcpy相同

使用案例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int arr2[5] = { 0 };
	memmove(arr1 + 2, arr1, 5 * sizeof(arr1[0]));
	int i = 0;
	for (i = 0; i<9; i++)
	{
		printf("%d\n", arr1[i]);
	}
	return 0;
}

模拟实现： 

分析：

#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memmove(void* dest,const void* src,size_t num)
{
	void* ret = dest;
	assert(dest&&src);
	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); //   //根据图来分析
		}
	}

}
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int arr2[5] = { 0 };
	my_memmove(arr1 + 2, arr1, 5 * sizeof(arr1[0]));
	int i = 0;
	for (i = 0; i<9; i++)
	{
		printf("%d\n", arr1[i]);
	}
	return 0;
}

9.memcmp

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

比较字节中数的大小

返回的是大于等于或小于0的无符号整型

使用方式与strncmp相似，但是比较的类型不局限于字符串，更加广泛

案例：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1,2,7,4,5 };
	int arr2[] = { 1,2,3,4,5 };
	int ret = memcmp(arr1, arr2, 9);  //比较arr1和arr2前九个字节中数的大小

	printf("%d\n", ret);
	return 0;
}

10.memset

void* memset(void* dest,int c,size_t count)

第一个参数是目标地址，第二个参数是要被设置的内容，第三个参数是个数

以字节为单位修改

应用方式：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[20] = { 0 };
	memset(arr, 'x', 10);
	return 0;
}

〖Python零基础入门篇⑪〗- Python中的字符串类型及应用
易编橙 · 终身成长社群，相遇已是上上签！
02-23 4万+
前文我们有介绍过，当我们赋值了一个变量之后，内存就会给该变量安排一个内存空间。有人就会产生疑问，之前我们说过变量的值是可以改变的啊，为什么说 字符串 是不可改变的呢？
memcpy(从参数2复制参数3个字符到参数1中)
pamxy啲Coding窝...
02-28 1958
memcpy #include   void *memcpy( void *to, const void *from, size_t count ); 功能：函数从from中复制count 个字符到to中，并返回to指针。 如果to 和from 重叠，则函数行为不确定。
C函数之memcpy()函数用法
zou_albert的博客
03-06 1万+
目录1 基本介绍1.1 函数原型1.2 功能1.3头文件1.4 返回值2 说明3 使用例子3.1 作用：将s中的字符串复制到字符数组d中。3.2 作用：将s中第14个字符开始的4个连续字符复制到d中。(从0开始)3.3 作用：复制后覆盖原有部分数据 1 基本介绍 1.1 函数原型 void *memcpy(void*dest, const void *src, size_t n); 函数原型 void *memcpy(void *dest, const void *src, int count) {
memcpy函数
rngnblplnb的博客
06-02 155
函数声明：void * memcpy ( void * destination, const void * source, size_t num );第一个参数：指向目标数组的指针。从源数组提取数据放到目标数组。第二个参数：指向源数组的指针。第三个参数：要复制的字节数。
【C库函数】memcpy函数详解
热门推荐
威威的博客
04-03 4万+
memcpy函数，拷贝内容到目标空间。 比strncpy更加强大的函数
memcpy()函数参数的使用注意事项
qq_22543355的博客
07-07 515
https://www.cnblogs.com/xia-weiwen/p/11255927.html
C语言中字符串的内存地址操作的相关函数简介
09-03
在C语言中，处理字符串和内存地址的操作是非常常见的任务，特别是在系统编程和底层开发中。本文主要介绍三个非标准但常在某些环境中使用的函数：bcopy()、bzero()和bcmp()，它们分别用于内存复制、清零和比较。 1. ...
5152单片机proteus仿真和源码字符串函数string.h应用举例
最新发布
05-02
下面将以5152单片机为例，详细介绍几个常用的字符串函数及其应用实例。 1. **strlen()**：用于获取字符串长度。 ```c #include char str[] = "Hello World!"; int len = strlen(str); // len 的值为 12 ``` ...
C++字符串常用操作函数讲解.rar
04-06
在C++编程语言中，字符串处理是至关重要的一个部分，特别是在编写各种应用程序时。本教程将深入探讨C++中字符串的常用操作函数，以帮助你更好地理解和运用它们。标题中的"C++字符串常用操作函数讲解"暗示我们将关注...
C语言字符串函数
TONGtongTONG000的博客
07-30 610
C语言中定义字符串的一个问题 C语言中一般定义字符串有两种形式，一种是char str[]这种方式只开辟了一个数组空间。另一种char *str这种方式开辟了两个空间，一个指针空间和一个常量区的空间，所以这种方式定义的字符串是一个常量，多在不对其做修改的情况下使用。用相同常量初始化不同数组时会开辟不用空间。例如str1[]={"HELLO"}; str2[]={"HELLO"}; str1 != str2. strlen函数 size_t strlen(const char *str); strlen函数
冰冰学习笔记：内存操作函数
bingbing_bang的博客
03-23 2038
内存空间处理函数，memcpy怎么实现？ memmove和memcpy有什么区别？ 这里都有！！！超详细的哦
【c语言】memcpy使用防止地址越界
zou_albert的博客
05-30 2930
memcpy函数原型：void * memcpy (void * dest, const void * src, size_t n); 功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中 请看下面的一个例子： void check_data(int *buffer)//buffer 的长度是128 { int temp[200]; memcpy(temp,buffer,sizeof(temp)); } 此函数出现的问题，buffer的大小是128，但是te
关于memcpy
王同学Leo的专栏
09-22 1149
memcpy是C/C++内存拷贝函数，函数原型void *memcpy(void *dest, const void *src, size_t n);功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。 【memcpy与strcpy比较】 strcpy和memcpy主要有以下3方面的区别。 1、复制的内容不同。strcpy只能复制
memcpy的用法
lianghui0811
07-31 426
函数原型：void *memcpy(void *dest, const void *src, size_t n); 功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中 例如1：作用：将s中的字符串复制到字符数组d中 #include #include int main() {     char* s="GoldenGlobalView
使用memcpy函数时要注意拷贝数据的长度
weixin_30470643的博客
07-27 6389
memcpy函数简介 memcpy函数是C/C++语言中的一个用于内存复制的函数，声明在 string.h 中（C++是 cstring）。其原型是： void *memcpy(void *destin, void *source, unsigned n); 作用是：以source指向的地址为起点，将连续的n个字节数据，复制到以destin指向的地址为起点的内存中。 函数有三个参数，第一个是目标地...
c语言strcpy、strncpy、memcpy内存拷贝比较
白水冰泉的博客
04-22 1846
c语言strcpy、strncpy、memcpy内存拷贝比较 /********************************************************* 参考： https://blog.csdn.net/zhanghuan_wangkai/article/details/51674935 * *************************************...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今年依旧去年春

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值