库函数的介绍、使用、模拟实现

最新推荐文章于 2024-05-05 20:37:09 发布
最新推荐文章于 2024-05-05 20:37:09 发布
阅读量1.1k 收藏 18
点赞数 42
文章标签： 算法 开发语言 c# c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54029068/article/details/137044845
版权

目录

字符串库函数；

1.strlen；

简要介绍：

使用：

模拟实现：

2.strcpy;

简要介绍：

使用：

模拟实现：

3.strcat；

简要介绍：

使用：

模拟实现：

4.strcmp；

简要介绍：

使用：

​编辑模拟实现：

5.strstr;

简要介绍：

使用：

模拟实现：

6.strtok；

简要介绍：

使用：

内存库函数；

1.memcpy

简要介绍：

使用：

模拟实现：

2.memmove

简要介绍：

模拟实现：

3.memcmp;

简要介绍：

使用：

字符串库函数；

1.strlen；

简要介绍：

size_t strlen ( const char * str )。

字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。

参数指向的字符串必须要以 '\0' 结束。

注意函数的返回值为size_t，是无符号的。

使用：

在strlen后面输入字符串地址或者字符串；

代码举例：

#include<string.h>
#include<stdio.h>
int main()
{
	char arr[] = "abcde";
	int sz = sizeof(arr) / sizeof(arr[0]);
	size_t ret = strlen(arr);
	printf("%u\n", ret);
	return 0;
}

运行结果：

模拟实现：

代码1（指针-指针）：

size_t mystrlen(const char* x,const char* y)
{
	
	return y-x;
}
int main()
{
	char arr[] = "abcde";
	int sz = sizeof(arr) / sizeof(arr[0]);
	size_t ret = mystrlen(arr,arr+sz-1);
	printf("%u\n", ret);
	return 0;
}

代码1分析：

这里主要使用了指针-指针=两指针之间的元素个数；因为arr是字符串，所以里面的元素包含\0，函数传参的时候正好传首元素的地址和最后一个元素后面的地址，两地址相减就得到整个字符串的元素个数；

运行结果：

代码2：

size_t mystrlen(const char* x)
{
	int count = 0;
	while (*x != '\0')
	{
		count++;
		x++;
	}
	return count;
}
int main()
{
	char arr[] = "abcde";
	int sz = sizeof(arr) / sizeof(arr[0]);
	size_t ret = mystrlen(arr, arr + sz - 1);
	printf("%u\n", ret);
	return 0;
}

代码2分析（计数器）：

把首元素地址传过去，解引用看是不是\0，一直到\0,每次不是\0就加1，最后返回计数器；

运行结果：

代码3（递归）：

size_t mystrlen(const char* x)
{
	if (*x != '\0')
	{
		x++;
		return 1+mystrlen(x);
	}
	{
		return 0;
	}
	
}
int main()
{
	char arr[] = "abcde";
	int sz = sizeof(arr) / sizeof(arr[0]);
	size_t ret = mystrlen(arr);
	printf("%u\n", ret);
	return 0;
}

代码3分析：

这里的思想是只要解引用不是\0，就把地址加1，返回1+函数（新地址），最后找到\0，返回最终的长度；

运行结果:

2.strcpy;

简要介绍：

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

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

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

目标空间必须可变。

使用：

char * strcpy ( char * destination, const char * source );
#include<string.h>
int main()
{
	char arr1[20] = "xxxxxxxxxxxxxxxxxx";//目标空间必须可变，不能是常量字符串；char* arr="xxxxxxxxxxxxxxxxxxxxxxx";
	char arr2[20] = "abiuwdfakf";//源字符串必须以 '\0' 结束。否则会出现错误；
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

分析：

将arr2中的内容全部拷贝到arr1中，最后再打印出arr1；

运行结果：

模拟实现：

代码：

#include<stdio.h>
#include<assert.h>
char* mystrcpy(const char* arr2, char* arr1)
{
	assert(arr1!=NULL);
	assert(arr2!= NULL);
	char* ret = arr1;
	while (*arr2 != '\0')
	{
		*arr1 = *arr2;
		arr1++;
		arr2++;
	}
	*arr1 = *arr2;
	return ret;
}
int main()
{
	char arr1[] = "hello guys";
	char arr2[] = "xxxxx";
	
	/*printf("%s\n", mystrlen(arr2, arr1));*///利用函数返回值实现链式访问；
	mystrcpy(arr2, arr1);
	printf("%s\n",arr1);
	return 0;
}

代码分析：

传过去两个字符串的地址，开始解引用，只要不是\0，就赋给新的字符串，两个地址同时++，直到\0，跳出循环，将\0赋给新的字符串；返回一开始存储的地址；

运行结果：

3.strcat；

简要介绍：

追加字符串，在字符串\0位置开始追加新的字符串；

使用：

代码：

#include<string.h>
int main()
{
	char arr[20] = "hello";
	char arr1[] = "world";
	strcat(arr, arr1);
	printf("%s\n", arr);
	return 0;
}

代码分析：

在arr的\0位置开始追加字符串arr1，最后的结果是helloworld；

运行结果：

模拟实现：

代码：

#include<assert.h>
#include<stdio.h>
char* mystrcat(char* arr, const char* arr1)
{
	assert(arr);
	assert(arr1);
	char* ret = arr;
	while (*arr)
	{
		arr++;
	}
	while (*arr++ = *arr1++);//当自己给自己追加，会把\0的位置给赋值成h，会把\0覆盖，永远找不到\0；
	return ret;
}
int main()
{
	char arr[20] = "hello";
	char arr1[] = "world";
	printf("%s\n", mystrcat(arr, arr1));
	return 0;
}

代码分析：

把两个字符串的地址传给函数，先存下第一个字符串的源地址；开始对字符串1的内容解引用，不是\0就+1，一直找到\0，从这个位置开始把字符串2的值赋给字符串1,每赋完一个就+1，一直到字符串2的\0，最后返回字符串1的源地址；

运行结果：

4.strcmp；

简要介绍：

第一个字符串大于第二个字符串，则返回大于 0 的数字；
第一个字符串等于第二个字符串，则返回 0；
第一个字符串小于第二个字符串，则返回小于 0 的数字；
比较对应字符的大小，当比到\0==\0时停止；

使用：

代码：

#include<string.h>
int main()
{
	char arr1[] = "adc";
	char arr2[] = "acd";
	
	printf("%d\n", strcmp(arr1, arr2));
	return 0;
}

代码分析：

因为d在c后面，所以返回>0;

运行结果：


模拟实现：

代码：

#include<stdio.h>
#include<string.h>
int mystrcmp(const char* arr1, const char* arr2)
{
	while (*arr1 == *arr2)
	{
		if (*arr1=='\0')
		{
			return 0;
		}
		arr1++;
		arr2++;
	}
	if (*arr1 > *arr2)
	{
		return 1;
	}
	else if (*arr1 < *arr2)
	{
		return -1;
	}
}

int main()
{
	char arr1[] = "adc";
	char arr2[] = "acd";
	
	printf("%d\n", mystrcmp(arr1, arr2));
	return 0;
}

代码分析：

传过去两个字符串地址，开始逐对比较，如果第一个就不相等，判断大小，返回值；如果第一个相等，地址++，一直到找到不相等的，如果到最后\0的位置还相等，那就返回0；

运行结果：

5.strstr;

简要介绍：

在一个字符串里找另外一个字符串，即看另外一个字符串是不是大字符串的子串，如果有，返回该位置的地址；

使用：

代码：

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "uihfaposfrf";
	char arr2[] = "pos";
	char*ret=strstr(arr, arr2);//在arr中找arr2，返回arr2在arr中出现的地址；
 if(ret!=NULL)
 {
	printf("%s\n", ret);
 }
	return 0;
}

代码分析：

在arr里找arr2，最后返回地址，打印出arr中arr2及他后面的内容；

运行结果：

模拟实现：

代码：

#include<stdio.h>
char* mystrstr(const char* arr, const char* arr2)
{
	char* x1 = arr;
	char* s1 = x1;
	char* s2 = arr2;
	while (*x1)
	{
		char* s1 = x1;
		char* s2 = arr2;
		while (*s1&&* s2&&* s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return x1;
		}
		else {
			x1++;
		}
	}
	return NULL;
}
int main()
{
	char arr[] = "appos";
	char arr2[] = "pos";
	char* ret = mystrstr(arr, arr2);//在arr中找arr2，返回arr2在arr中出现的地址；
	printf("%s\n", ret);
	return 0;
}

代码分析：

传过去两个字符串地址，先存储下来，把字符串2的内容与字符串1比较，如果相等，则字符串1的地址++，一直到有相等的出现，出现以后再从相等的位置开始往后比较每一位，如果当中又出现不相等，且不是\0的位置，字符串1地址++；如果那个不相等的地址指向\0，则返回字符串1的地址；

运行结果：

6.strtok；

简要介绍：

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

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

第一个参数指定一个字符串，它包含了 0 个或者多个由 sep 字符串中一个或者多个分隔符分割的标记。

strtok 函数找到 str 中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：
strtok 函数会改变被操作的字符串，所以在使用 strtok 函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok 函数的第一个参数不为 NULL ，函数将找到 str 中第一个标记， strtok 函数将保存它在字符串中的位置。
strtok 函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标 记。
如果字符串中不存在更多的标记，则返回NULL；

使用：

代码：

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "cuofiaiw&noiwd+jooqd%opw@niovnse owo?wdc";
	char arr2[50] = {0};
	strcpy(arr2, arr);
	char sep[] = "&%+@ ?";
	char* ret;
	for (ret = strtok(arr2, sep);ret != NULL;ret = strtok(NULL, sep))//找到里面的字符，改为\0，返回地址；除了第一次使用arr2，其他可以使用NULL，因为strtok有记录功能；
	{
		printf("%s\n", ret);
	}
	return 0;
}

代码分析：

每次找到相应符号，转为\0，打印，再使用，从\0后面的地址开始找，如此循环，找出各个符号之间的字符串内容；

运行结果：

内存库函数；

1.memcpy

简要介绍：

void* memcpy ( void* destination , const void* source , size_t num );
函数 memcpy 从 source 的位置开始向后复制 num 个字节的数据到 destination 的内存位置。
如果 source 和 destination 有任何的重叠，复制的结果都是未定义的。
遇到\0也不会停下；

使用：

代码：

#include<stdio.h>
#include<string.h>
int main()
{
	int arr[] = { 1,2,4,5,6,7,8 };
	int arr1[20] = { 0 };
	memcpy(arr1, arr, 20);//20 表示要拷贝的字节；
	int i = 0;
	while (i<20)
	{
		printf("%d ", arr1[i]);
		i++;
	}
	return 0;
}

代码分析：

拷贝20个字节，即五个整形，所以是arr1的前五个元素；

运行结果：

模拟实现：

代码：

#include<assert.h>
#include<stdio.h>
void* my_memcpy(void* arr1, void* arr, size_t num)
{
	void* ret = arr1;
	assert(arr1 && arr);
	while (num--)
	{
		*(char*)arr1 = *(char*)arr;
		arr1 = (char*)arr1 + 1;
		arr = (char*)arr + 1;
		
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,4,5,6,7,8 };
	          // 01 00 00 00 02 00 00 00 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 08 00 00 00
	int arr1[20] = { 0 };
	my_memcpy(arr1, arr, 21);//22 表示要拷贝的字节；
	int i = 0;
	while (i < 20)
	{
		printf("%d ", arr1[i]);
		i++;
	}
	return 0;
}

代码分析：

因为是一个字节一个字节拷贝，所以都转为char*类型的指针，这样可以一个字节一个字节的跳动；

运行结果：

2.memmove

简要介绍：

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

模拟实现：

代码：

#include<stdio.h>
#include<string.h>
#include<assert.h>
void* mymemmove(void* dest, void* source, size_t num)
{
	void* ret = dest;
	assert(dest && source);
	while (num--)
	{
		if (dest < source)
		{
			*(char*)dest = *(char*)source;
			dest = (char*)dest + 1;
			source = (char*)source + 1;
		}
		else
		{
			*((char*)dest + num) = *((char*)source + num);//加到第19个字节；
		}
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9 ,0 };
	/*memmove(arr, arr + 2, 20);*/
	/*memmove(arr+2, arr, 20);*/
	mymemmove(arr, arr+2, 20);
	int i = 10;
	for (i = 0; i < 10;i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

代码分析：

memmove的特点是重叠的部分也可以使用，所以重叠这里分为目标地址和源地址的位置关系，如果目标地址在源地址左边，那么从目标地址的首地址开始赋值；如果在右边，那么从目标地址往后的最后一个元素开始赋值；

运行结果：

3.memcmp;

简要介绍：

int memcmp ( const void * ptr1, const void * ptr2, size_t num );比较ptr1和ptr2前num个字节；

使用：

代码：

#include<stdio.h>
#include<string.h>
int main()
{
	int arr[] = { 1,2,1,4,5,6 };
	int arr1[] = { 1,2,257 };
	int ret=memcmp(arr, arr1, 9);
	printf("%d\n", ret);
	return 0;
}

代码分析：

比较arr和arr1前9个字节，因为257和1的第一个字节内容相同，所以应该返回1；

运行结果：

唐僧洗头飘柔
关注
  • 42
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言模拟实现Linux文件系统
09-12
C语言模拟实现Linux文件系统 1、在内存中开辟一块空间来模拟文件系统的运行，不读写硬盘。 2、面向单用户、单任务，不考虑并发，不考虑文件属主、组等概念。 3、程序开始后，初始化并接收用户输入。若输入”enter”...
库函数strcmp的模拟实现
m0_48857897的博客
09-12 203
前面字符串大于后面的字符串返回大于0的数字，相等返回0，前面的字符串小于后面的，返回小于0的数字。strcmp是字符串之间的比较，看官方说明。strcmp的模拟实现。
库函数讲解及模拟实现库函数
编程SHARE的博客
03-30 2406
库函数及其模拟库函数
库函数qsort 以及模拟实现
gemgod的博客
07-10 154
库函数qsort 以及模拟实现 1.库函数qsort介绍 代码样例:
库函数qsort使用及其模拟实现
qq_53822523的博客
07-08 144
C语言中存在着许多排序函数，如我们熟悉的冒泡函数，还有堆排序、归并排序等等，这些排序函数的功能给我们带来了许多便捷，本文通过对qsort函数的介绍，也就是所谓的快排，来了解并加深排序函数的使用及实现。......
库函数strcat的模拟实现
m0_53120156的博客
03-30 190
库函数strcat的模拟实现 因为我们字符串连接之后，连接目标的地址并没有发生变化，这里只要注意函数的返回值是我们连接的目标首地址就好了，因此我们一开始要保存连接目标的地址，以防后续计算地址发生变化而无法对应输出。 #include<stdio.h> #include<string.h> #include<assert.h> char* my_strcat(char* dest, const char* src) { assert(dest && s
STM8S003 IAR环境库函数模拟串口
02-06
在IAR环境中，用库函数实现STM8S003单片机的模拟串口功能，用普通IO口作为串口，可以通过中断方式接收数据，也可以通过查询方式接收数据。9600波特率测试。
基于stm32库函数MAX31865实现.rar
07-06
基于stm32库函数MAX31865实现.rar
fackAchieve:手写ES6高级函数，手写Promise，模拟数据结构 ,手写常用工具库函数及框架源码模拟实现
05-14
手写 es6 函数，Promise 特性，lodash 库的函数实现,模拟 vue,React 等前端框架的实现和原理的理解。 functions 文件夹 手动实现各种函数，包括不限于 ES6 等函数的方法 内容对应表 Array 方法名称(name) 位置...
STM32 自定义HID 设备， 通过快传输接收上位机发来的数据。上位机使用Libusb库函数实现，接口简单
09-12
STM32 自定义HID 设备， 通过快传输接收上位机发来的...上位机使用Libusb库函数实现，接口简单。程序中添加了上位机接收数据的接口，USB 设备端的IN 接口也做好了，用户只要将需要发送给HOST的数据添加进去就可以了.zip
leetcode16-3Sum Closest
我的程序人生
04-29 386
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
c++容器与算法概述
北风
05-01 522
简单讲述输入输出运算符重载 以及容器的简单使用及接口哦苦
【算法】高精度乘法
m0_73209194的博客
05-02 438
高精度乘法
c入门基础题（3）
梦昼初
04-26 1057
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
【算法刷题 | 贪心算法08】4.29（划分字母区间、合并区间）
踢桃的成长之路
04-29 806
4.29（划分字母区间、合并区间）
【算法】滑动窗口——长度最小的子数组
最新发布
2302_79031646的博客
05-05 369
本篇文章是用一个实例来介绍常用算法之一“滑动窗口”的相关概念，有需要借鉴即可。
学习选择排序的可视化实现（一）
weixin_40539956的博客
05-03 410
开始：从数组的第一个元素开始，假设最小（或最大）元素就是第一个元素。比较：遍历未排序的部分，找到实际的最小（或最大）元素。交换：将找到的最小（或最大）元素与未排序部分的第一个元素交换位置。重复：移动到下一个元素，重复步骤2和3，直到数组完全排序。
【算法】【贪心算法】【leetcode】870. 优势洗牌
zhaoliubao1的博客
04-30 1760
给定两个长度相等的数组 nums1 和 nums2，nums1 相对于 nums2 的优势可以用满足 nums1[i] > nums2[i]孙膑就教他用自己的下等马对齐王的上等马，再用自己的上等马对齐王的中等马，最后用自己的中等马对齐王的下等马，结果三局两胜，田忌赢了。把nums1当成是田忌的马，nums2当成是齐威王的马。输入：nums1 = [12,24,8,32], nums2 = [13,25,32,11]输入：nums1 = [2,7,11,15], nums2 = [1,10,4,11]
【数据结构】算法的效率（时间复杂度和空间复杂度）
HEBRE的博客
04-29 1075
一.算法的效率算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源。因此衡量一个算法的好坏，一般是从和空间两个维度来衡量的，即时间复杂度和空间复杂度。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计 算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。二.时间复杂度。
模拟实现库函数strcpy
07-27
你可以使用以下代码模拟实现库函数strcpy： ```c #include char* strcpy(char* dest, const char* src) { char* p = dest; while (*src) { *dest++ = *src++; } *dest = '\0'; return p; } int main() { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值