模拟实现库函数&内存函数

已于 2022-04-17 16:51:46 修改
阅读量875 收藏 1
点赞数
分类专栏： C语言 文章标签： c语言
于 2022-04-05 20:06:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63601133/article/details/123946249
版权
C 语言中对字符和字符串的处理很是频繁，但是 C 语言本身是没有字符串类型的，字符串通常放在
常量字符串 中或者 字符数组 中。
字符串常量 适用于那些对它不做修改的字符串函数 .

字符操作函数

strlen  求字符串长度

size_t strlen ( const char * str );

strlen注意事项

字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包 含 '\0' )。
参数指向的字符串必须要以 '\0' 结束。
若没有 ‘ \0 ’ 则strlen在内存中会直到找到 \0 再停下来。所以会生成一个随机值。 
注意函数的返回值为size_t，是无符号的（ 易错 ）
#include <stdio.h>
int main()
{
const char*str1 = "abcdef";
const char*str2 = "bbb";
if(strlen(str2)-strlen(str1)>0)    // 得出结果为-3，当把-3看作无符号数是个很大的正数
{
printf("str2>str1\n");
}
else
{
printf("srt1>str2\n");            // 所以输出 >
}
return 0;
}

模拟实现strlen（三种） 

// 计数器方式
int my_strlen(const char * str)
{
int count = 0;
while(*str)
{
count++;
str++;
}
return count;
}
int main()
{
    char arr[] = "abcdef";
    int len = my_strlen(arr);
    printf("%d\n", len);
    return 0;
}
 
//迭代
int my_strlen(const char * str)
{
if(*str == '\0')
return 0;
else
return 1+my_strlen(str+1);
//指针-指针的方式
int my_strlen(char *s)
{
      char *p = s;
      while(*p != ‘\0’ )
             p++;
      return p-s;
}

strcpy   字符串拷贝

char* strcpy(char * destination, const char * source）

strcpy注意事项

源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。//会拷贝成功，但程序出错
目标空间必须可变                      //若是常量字符串，无法修改

strcpy模拟实现

char *my_strcpy(char *dest, const char*src)
{
char *ret = dest;               //先保存dest的地址，为了保存起始地址
assert(dest != NULL);
assert(src != NULL);
while((*dest++ = *src++))
{
           ;
}
return ret;
}
int main()
        {
            char arr1[20] = { 0 };
            char* arr2 = "hello bit";
        
        printf("%s\n", my_strcpy(arr1, arr2)); //将函数的返回值作为参数输出，实现链式访问
            return 0;
        }
strcpy返回的是目标空间的起始地址
strcpy函数的返回类型的设置是为了实现链式访问

strcat    字符串追加

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

strcat注意事项

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

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

目标空间必须可修改。

strcat模拟实现 

char* my_strcpy(char* dest, const char* src)
{
    assert(dest != NULL);    //断言为了防止dest 和 src 是空指针
    assert(src != NULL);
       char* ret = dest;
    while(*dest)                               //先找源字符串中的/0，再拷贝
    {
       dest++ ;
    }

while（*dest++ = *src++）

{

    ；
}
    return ret;
}

int main()
{
    char arr1[20] = { 0 };
    char* arr2 = "hello bit";

    printf("%s\n", my_strcpy(arr1, arr2));
    return 0;
}

将字符串2的 \0 也拷贝了进去

若用stract函数让字符串自己给自己追加可能会覆盖掉本身的/0，从而陷入死循环

strcmp  字符串的比较大小

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

strcmp的注意事项

strcmp比较的不是两个字符串的长度，而是比较对应位置字符的大小（ASCII值），如果相同，比较下一对，直到不同或都遇到 \0 

标准规定：

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

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

第一个字符串小于第二个字符串，则返回小于0的数字    //不一定返回1 -1 （环境不同）

strcmp模拟实现 

因为只负责比较s1和s2字符串的内容，所以加上const安全保护。以下模拟环境在vs环境下。所以当大于0的时候返回1，小于0的时候返回-1

int my_strcmp(const char* s1, const char* s2)
{
    assert(s1 && s2);
    while (*s1 == *s2)
    {
        if (*s1 == '\0')
        {
            return 0;              //相等的情况
        }

        s1++;
        s2++;
    }
    //不相等
    if (*s1 > *s2)
        return 1;
    else
        return -1;
}

int main()
{
    char arr1[] = "abcd";
    char arr2[] = "abdc";

    int ret = my_strcmp(arr1, arr2);

    if (ret >0)
    {
        printf(">\n");
    }
    else if (ret == 0)
    {
        printf("== \n");
    }
    else
    {
        printf("<\n");
    }

    printf("%d\n", ret);

以上几种函数是长度不受限制的字符串函数 ，一旦字符串没有足够的空间，函数仍然敢进行操作，这时候就已经造成了非法访问，使程序崩溃，但依然会运行出结果。下面引进长度受限制的三种函数

strncpy    有长度限制的字符拷贝

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

拷贝num个字符从源字符串到目标空间。

如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加 \0，直到num个。

strncpy（arr1，arr2，6）  拷贝6个字符

strncat   有限制的字符串追加

 追加5个，最后加上 \0 ，若字符串不够5个，则把字符串全部追加上后，加上\0就结束。这里与strncpy不同

strncmp  有限制的字符比较 

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

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

strstr  找字符串的子集

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

如果str2是str1的子集，则返回str2第一次出现在str1的位置（返回的是地址），如果不是，则返回空指针

int main()
{
    char arr1[] = "abbbcdef";
    char arr2[] = "bbc";
    char* ret = strstr(arr1, arr2);
    if (NULL == ret)
    {
        printf("找不到子串\n");
    }
    else
    {
        printf("%s\n", ret);
    }
    return 0;
} 

strstr模拟实现 

int main()
{
    char arr1[] = "abbbcdef";
    char arr2[] = "bbc";
    char* ret = my_strstr(arr1, arr2);
    if (NULL == ret)
    {
        printf("找不到子串\n");
    }
    else
    {
        printf("%s\n", ret);
    }
    return 0;
}
char* my_strstr(const char* str1, const char* str2)
{
    assert(str1 && str2);

    const char* s1 = str1;
    const char* s2 = str2;

    const char* cur = str1;    // cur记录可能匹配成功的位置
    while (*cur)
    {
        s1 = cur;
        s2 = str2;

        while (*s1 && *s2 && (*s1 == *s2))
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')
        {
            return (char*)cur;
        }
        cur++;
    }

    return NULL;//找不到
}

strtok 分隔

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

 #include <stdio.h>
int main()
{
    char* p = "zhangpengwei@bitedu.tech";
    const char* sep = ".@";                   //定义分隔符
    char arr[30];
    char* str = NULL;
    strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
    for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
    {                                                    
        printf("%s\n", str);             //将分隔符@改为\0 ，返回z的地址，若遇到\0依然会停下来
    } 
}

可以认为strtok里存储了一个静态指针变量来记录字符串的某些位置

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

char * strerror ( int errnum );
全局变量：erron （错误码）
将错误码所对应的错误信息的字符串的起始地址返回
每一个错误码对应着一个错误信息。

#include <limits.h>
#include <errno.h>
#include <stdlib.h>

int main()
{
    int* p = (int*)malloc(INT_MAX);//想堆区申请内存的
    if (p == NULL)
    {
   //printf("%s\n", strerror(errno));      //如果只是拿到错误信息（错误的字符串），可以不打印
        perror("Malloc");                                      //打印错误信息
        return 1;
    }
    return 0;
}

Not  enough space

字符分类函数 如果他的参数符合下列条件就返回真

字符转换 

int tolower ( int c ); 大写转小写
int toupper ( int c）小写转大写

内存操作函数

memcpy     将arr1 拷贝 到 arr2

void * memcpy ( void * destination, const void * source, size_t num );
作者实现函数的时候，不知道拷贝什么类型的数据，所以写void*
memcpy用来实现内容不重叠的拷贝

memcpy模拟实现 

void* my_memcpy(void* dest, const void* src, size_t count)
{
    assert(dest && src);
    void* ret = dest;
    while (count--)
    {
        *(char*)dest = *(char*)src;  //拿到一个字符  （先强制类型转换为char*，在*解引用）
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }

    return ret;
}

int main()
{
    int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr2[5] = { 0 };
    my_memcpy(arr2, arr1, 20);

return 0；

}

memmove 重叠拷贝

void * memmove ( void * destination , const void * source , size_t num );
和 memcpy 的差别就是 memmove 函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用 memmove 函数处理。

memmove应用

int main()
{
	

	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	              // 1 2 1 2 3 4 5 8 9 10
	memcpy(arr1+2, arr1, 20);
    int i = 0;
	int sz = sizeof(arr1) / sizeof(arr1[0]);

	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);
	}

	return 0;
}

 memmove模拟实现

首先分析拷贝顺序

将src内容拷贝到dest里面，当dest位于src左边时，从前往后拷贝，即先拷贝3-->2  4-->3  5-->4 

#include<stdio.h>

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

	return ret;
}
	int main()
{

	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	              // 1 2 1 2 3 4 5 8 9 10
	memcpy(arr1+2, arr1, 20);

	my_memmove(arr1+2, arr1, 20);//可以实现重叠内存的拷贝
	//my_memmove(arr1, arr1+2, 20);//可以实现重叠内存的拷贝

	int i = 0;
	int sz = sizeof(arr1) / sizeof(arr1[0]);

	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);
	}

	return 0;

memcp  字符内存比较

int memcmp ( const void * ptr1 ,
const void * ptr2 ,
size_t num   字节为单位 );

细化到每个字节进行比较，前17个字节一样。有没有\0仍然会继续比较。 

memset   设置内存空间

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

以字节为单位设置，将内存空间变为指定数

 

裙下的霸气
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言库函数size_t strlen(const char *str)的用法
qq_39758638的博客
03-14 2613
1、小编今天调试程序一直对strlen函数的用法不是很理解，在搞清楚后在此做记录，如有问题请指教，谢谢！ 2、函数定义：C 库函数size_t strlen(const char *str)计算字符串str的长度，直到空结束字符('\0')，但不包括空结束字符。 3、个人理解：空结束符('\0')是ascii中的空结束符（0），所以要赋值数字0，就应该是ascii码的十进制48； ...
C语言常用函数详解之STRLEN()
最新发布
Cdy126的博客
05-17 3904
在处理堆上分配的字符数组或通过指针传递的字符数组时，应该使用其他字符串处理函数，例如`strnlen`、`strncpy`、`strndup`等。如果字符串中包含非ASCII码字符，例如中文、日文、韩文等，`strlen`函数的行为是未定义的，可能会导致程序崩溃或产生不可预测的结果。如果字符数组是在堆上分配的，或者是通过指针传递的，`strlen`函数的行为是未定义的，可能会导致程序崩溃或产生不可预测的结果。函数计算字符串的长度，第二个参数指定最多计算的字符数，以避免程序崩溃或产生不可预测的结果。
C++ - C - strlen
既然选择了远方 便只顾风雨兼程 - 永强
03-10 3224
C++ - C - strlen 1. C++ - std::strlen size_t strlen ( const char * str ); 定义于头文件 <cstring> Get string length - 获取字符串长度 Returns the length of the C string str. 返回 C 字符串 str 的长度。 The length of a C string is determined by the terminating null-character:
C语言：str函数（一）
weixin_62450887的博客
04-15 8074
目录 一.求字符串长度 1.strlen 二.长度不受限制的字符串函数 1.strcpy 2.strcat 3.strcmp 一.求字符串长度 1.strlen size_t strlen ( const char * str ); （1）.字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包 含 '\0' ) 这里值得注意的是 int main() { char arr1[] = { "ab...
C语言字符串函数的详解
qq_45726327的博客
09-25 3369
C语言字符串方法详解
连续动态内存管理模拟实现
05-15
通过这样的模拟实现，开发者可以深入理解动态内存管理的工作原理，以及各种内存分配策略的优缺点。这对于编写高效、健壮的C语言程序以及理解操作系统内核的内存管理机制具有重要意义。此外，这个模拟器还可以作为一...
stm32标准例程库函数_stm32标准函数库_
09-28
9. **ADC和DAC**：模拟数字转换器（ADC）和数字模拟转换器（DAC）的库函数，用于进行模拟信号的采集和生成。 10. **DMA（直接存储器访问）**：通过DMA库函数，开发者可以设置数据传输通道，减轻CPU负担，提高系统...
Matlab中unwrap函数C代码实现
05-27
在Matlab中，这个功能被内置在`unwrap`函数中，但在C或C++中，我们需要自己实现类似的功能。 在Matlab的`unwrap`函数中，其主要逻辑是检测相位变化超过π的跳跃，并进行相应的调整。对于C/C++程序员来说，理解这个...
三角函数查表方式c语言实现
02-22
三角函数在计算机科学中扮演着重要角色，尤其是在数学计算、图形学、物理模拟等领域。当涉及到高频率或者性能敏感的计算时，系统自带的库函数调用可能因为浮点运算的开销而变得效率低下。这时，查表法（Table Lookup...
stm32 F4系列库函数
04-23
10. **HAL库的使用**：理解HAL库的基本结构，如初始化、配置、读写和中断处理函数，能够快速进行项目开发。 通过学习和实践这些知识点，结合提供的"标准例程-V3.5库函数版本"，开发者可以更好地掌握STM32 F4系列的...
C语言字符串处理函数
qq_42714102的博客
09-22 227
字符串处理函数是在头文件<string.h>中。 测字符串长度函数 函数名称：size_t strlen(const char *s); 函数功能：返回字符串s的长度，不包括字符串结尾的’\0’。 字符串拷贝函数 函数名称：char *strcpy(char *dest,const char *src); 函数功能：拷贝src指向的字符串，拷贝到dest指向的内存中，’\0’也会拷贝...
C语言学习笔记（浙大翁恺版）第十周 字符串函数（2）
m0_56661338的博客
07-16 634
其中的CtrlC会让shell直接关闭程序，而CtrlD在shell收到后，在末尾填一个-1，程序读到-1，程序就正常结束了。这里有一个小技巧先把查找到的字符位置处更换为0，此时输出这个字符串，就得到需要的部分，然后再将其换回原来的字符，其他功能仍然可以正常运行，数组改动前后也没有变化。当然不行，要知道，放在格式化输出符后面比较数组，实质是比较两个数组的地址是否相同。因此在处理字符串时，要么把它当作数组，把参数作为下标，要么就把它当作指针，移动指针实现自增，指针加减实现返回值。...
C语言中字符串处理函数详解
weixin_42617375的博客
11-16 1091
1.C语言的字符串 首先C语言中并没有字符串这个基础数据类型。但是字符串在c语言中的涉及却是十分的广泛，并且也是十分重要的。 定义： 由双引号" "引起来的内存中的一串字符且以’\0’为结束标志符 的字符。 字符串的操作 1.size_t strlen(const char *s); 2.char *strcpy(char *dest,const char * src); 3.char *st...
字符串函数strlen
吴小宝的博客
09-06 1636
strlen() 是C语言标准库包含的一个字符串函数，用来返回字符串 s 的长度（不包括结尾的 0），函数的原型是： size_t strlen(const char *s); 编程实现该函数的代码如下： size_t myStrlen(const char *str) { size_t index = 0; while (str[index] != '\0') { inde
C strlen( ), sizeof
xl365t
12-15 448
一、strlen()函数 #include size_t strlen(const char *s); strlen()函数，计算字符串的长度，不包含最后的'\0'。 在运行时才能计算，参数必须是字符型指针(char *)，且必须以'\0'结尾。 当数组名作为参数传入时，实际上数组就退化成指针了。 二、sizeof运算符 sizeof是一个运算符，在头文件中type
C语言strlen函数详细讲解
m0_57121135的博客
08-01 1万+
C语言中的字符串和strlen函数实现
C语言size_t类型
热门推荐
C语言技术网-码农有道
04-22 1万+
在C语言中，很多库参数的参数和返回值的数据类型是size_t，让很多初学都不理解。size_t不是C语言的关键字，也不是基本数据类型，而是C语言自定义的数据类型。 例如以下库函数的声明： size_t strlen(const char *s); void *memset(void *s, int c, size_t n); char *strncpy(char *dest, const char...
C语言__字符串__
qq_41258050的博客
12-09 454
1.什么是字符串： 字符串是由字符构建而成的串行结构，'\0'是它的结束标志。 2.字符串存在的方式及如何创建： 1.字符串字面值：被双引号包括起来的若干个字符，有一个隐藏的'\0'，这种字符串以地址的形式存在在代码中，并且该字 符串储存在只读区，一旦定义，不能修改。 创建方法： char a[] = &quot;Hello&quot;; 2.字符数组：char类型的数组，里面存储的是ASCII值，**要注意为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

裙下的霸气

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

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

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

打赏作者

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

抵扣说明：

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

余额充值