AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【C语言进阶】字符串函数与内存函数的学习与模拟实现（下）

2023-06-05 62
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【C语言进阶】字符串函数与内存函数的学习与模拟实现（下）

1.9 strtok 函数：

strtok 函数（string token）的作用为将字符串分解为一组字符串。该函数有两个数组作为参数，它的实际作用便是将其中一个数组为分割数组，在另一个数组中寻找这些“分割符”，并在分割符处将这个数组内的字符串加上结束标识符 ’ \0 ’ ，将其分割成一组（多个）字符串。若第一个参数不为 NULL ，将找到字符数组中的第一个标记并保存它在字符串中的位置；若第一个参数为 NULL ，将在同一个字符串中被保存的位置开始，查找下一个标记

strtok 函数的基本使用方式：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[] = "1254594572@QQ.COM";
  char arr2[30] = { 0 };
  strcpy(arr2, arr1);
  const char* arr3 = "@.";
  printf("账号：%s\n", strtok(arr2, arr3));
  //找到第一个标记停止
  printf("服务商：%s\n", strtok(NULL, arr3));
  //从保存好的位置开始往后找
  printf("网址后缀：%s\n", strtok(NULL, arr3));
  //从保存好的位置开始往后找
  return 0;
}

de13a207948441a6bad6fff7c99a1cb6.png1.strtok 函数是会对数组本身进行操作的，所以我们为了保护原始数据，在定义并初始化好字符数组之后，又定义了一个新的数组并将原始数据拷贝过去，作为临时拷贝供我们进行操作。

2.接着我们定义并初始化了分割符数组，函数将根据分割符数组 arr3 对 临时拷贝 arr2 进行分割。第一次执行函数时之前没有标记，于是直接进行操作找到第一个标记并分割打印。

3.此时就已经存在标记了，再连续两次找到前一次执行作下的标记按照分割符将数组分割完毕并打印。我们可以将上面段代码优化为：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[] = "1254594572@QQ.COM";
  char arr2[30] = { 0 };
  strcpy(arr2, arr1);
  const char* arr3 = "@.";
  char* str = NULL;
  for (str = strtok(arr2, arr3); str != NULL; str = strtok(NULL, arr3))
  {
    printf("%s\n", str);
  }
  return 0;
}

注意:若字符串中不存在更多的标记，则返回 NULL 指针。

1.10 strerror 函数：

strerror函数（string error）的作用为返回错误码对应的信息。即根据接收到的错误码（错误码 errno 为全局变量），返回错误原因的详细信息。

我们来看 strerror 函数的基本使用方式：

#include<stdio.h>
#include<string.h>
int main()
{
  int i = 0;
  for (i = 0; i <= 4; i++)
  {
    printf("错误原因为：%s\n", strerror(i));
  }
  return 0;
}

e0f26fed0e0d4302b9e88ec145729d14.png

2.内存函数介绍

2.1 memcpy 函数：

memcpy函数（memory copy）的作用为从源内存空间向目的内存空间拷贝限制数量（单位是字节）的数据。它与 strcpy 函数类似，作用均为拷贝数据，不同的是 strcpy 仅仅只操作字符串故会在结束标识符 ’ \0 ’ 处停止，而 memcpy 函数操作的是内存，内存中的数据是相邻的，故不会在结束标识符处停止。

memcpy 函数的基本使用方式：

#include<stdio.h>
#include<string.h>
int main()
{
  int arr1[10] = { 1,2,3,4,5,6,7,8,9 };
  int arr2[5] = { 0 };
  printf("Before copy , the char inside arr2 are :>");
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    printf(" %d", arr2[i]);
  }
  printf("\n");
  memcpy(arr2, arr1, 20);
  printf("After copy , the char inside arr2 are :>");
  for (i = 0; i < 5; i++)
  {
    printf(" %d", arr2[i]);
  }
  printf("\n");
  return 0;
}

07907b35534b47ff9b7ea0bb45bf39ac.png首先创建并初始化了两个整形数组，接着打印出数组 arr2 内数据的存放情况。通过内存拷贝函数，将数组 arr1 内的前20个字节的数据拷贝给了 arr2数组。整型数组内每个数据元素所占的内存空间为4个字节，20个字节即将数组 arr1 中的前五个数据元素拷贝给了数组 arr2。最后再次打印数组 arr2 中的数据，验证拷贝结果。


注意:如果源内存空间和目标内存空间有任何的重叠，复制的结果都是未定义的。

2.2 memmove 函数：

memmove函数（memory move）的作用为弥补 memcpy 函数的不足，主要用于处理内存的重叠部分。即如果源空间和目标空间出现重叠，就得使用 memmove 函数来进行处理。

memcpy 函数的基本使用方式：

#include<stdio.h>
#include<string.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9 };
printf("Before copy , the char inside arr are :>");
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    printf(" %d", arr[i]);
  }
  printf("\n");
  memmove(arr+2, arr, 20);
  printf("After copy , the char inside arr are :>");
  for (i = 0; i < 5; i++)
  {
    printf(" %d", arr[i]);
  }
  printf("\n");
 return 0;
}

e98ea71c91e043b7b79c945a7d40ba44.png

2.3 memcmp 函数：

memcmp 函数（memory compare）的作用与 strcmp 函数的作用类似，不过 memcmp 函数是从内存的角度以字节为单位进行处理，故 memcmp 函数同样需要第三个参数进行限制，而不会在结束标识符 ’ \0 ’ 处停止比较。

memcmp 函数的基本使用方式：

#include<stdio.h>
#include<string.h>
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9 };
  int arr2[] = { 1,2,3,4,5,9,6,7,8 };
 int ret = memcmp(arr2, arr1, 24);
  if (ret > 0)
  {
    printf("arr1 < arr2\n");
  }
  else if (ret == 0)
  {
    printf("arr1 = arr2\n");
  }
  else
  {
    printf("arr1 > arr2");
  }
 return 0;
}

29ac226ae8a840b6a6e483556816f7c7.png

3.模拟库函数的实现

3.1 模拟实现strlen 函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* p)
{
  int count = 0;
  assert(p != NULL);
  //进行空指针校验，防止出现空指针
  while (*p != '\0')
  {
    count++;
    p++;
  }
  return count;
}
int main()
{
  const char arr[] = "Welcome!";
  int ret = my_strlen(arr);
  printf("The length of arr is %d\n", ret);
  return 0;
}

3.2 模拟实现strcpy 函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* p2, const char* p1)
{
  assert(p2 != NULL);
  assert(p1 != NULL);
  //等价于assert(p2 && p1);
  char* ret = p2;
    //将目的地址作为返回值
  while (*p2++ = *p1++)
  {
    ;
  }
 //返回目的地址的作用是为了实现链式访问
    return ret;
}
int main()
{
  const char arr1[] = "Welcome!";
  const char arr2[10] = { 0 };
  printf("Before copy , the char inside arr1 are %s\n", arr1);
  printf("Before copy , the char inside arr2 are %s\n", arr2);
  printf("\n");
  my_strcpy(arr2, arr1);
  printf("After copy , the char inside arr1 are %s\n", arr1);
  printf("After copy , the char inside arr2 are %s\n", arr2);
  return 0;
}

3.3 模拟实现strcat 函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* p2, char* p1)
{
  assert(p2 && p1);
  char* ret = p2;
  //查找目标空间中的结束标识符，找到后停止
  while (*p2)
  {
    p2++;
  }
  //从结束标识符开始追加
  //追加：
  while (*p2++ = *p1++)
  {
    ;
  }
  return ret;
} 
int main()
{
  const char arr1[20] = "Hellow!";
  const char arr2[20] = "Welcome!";
  printf("Before catenate , the char inside arr1 are %s\n", arr1);
  printf("Before catenate , the char inside arr2 are %s\n", arr2);
  printf("\n");
  my_strcat(arr2, arr1);
  printf("After catenate , the char inside arr1 are %s\n", arr1);
  printf("After catenate , the char inside arr2 are %s\n", arr2);
  return 0;
}

3.4 模拟实现strcmp 函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
//模拟实现strcmp函数：
int my_strcmp(const char* p1, const char* p2)
{
  assert(p1 && p2);
  //找到字符不同的对应位：
  while (*p1 == *p2)
  {
    if (*p1 == '\0')
    {
      return 0;
    }
    p1++;
    p2++;
  }
  if (*p1 > *p2)
  {
    return 1;
  }
  else
  {
    return -1;
  }
}
int main()
{
  const char arr1[] = "abcd";
  const char arr2[] = "abz";
  int ret = my_strcmp(arr1, arr2);
  //若arr1大于arr2，则返回大于零的数
  //若arr1等于arr2，则返回等于零的数
  //若arr1小于arr2，则返回小于零的数
  if (ret = 1)
  {
    printf("arr1 > arr2\n");
  }
  else if (ret = 0)
  {
    printf("arr1 = arr2\n");
  }
  else
  {
    printf("arr1 < arr2\n");
  }
  return 0;
}

3.5 模拟实现strstr 函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
char* my_strstr(char* p1, char* p2)
{
  assert(p1 && p2); 
  char* pp1 = p1;
  char* pp2 = p2;
  char* cur = p1;
  while (*cur)
  {
    pp1 = cur;
    pp2 = p2;
    while (*pp1 && *pp2 && (*pp1 == *pp2))
    {
      pp1++;
      pp2++;
    }
    if (*pp2 == '\0')
    {
      return cur;
    }
    cur++;
  }
  return NULL;
}
  //模拟strstr函数的实现：
int main()
{
  const char arr1[] = "abcdefg";
  const char arr2[] = "cde";
  char* ret = my_strstr(arr1, arr2);
  //从arr1中寻找arr2
  if (ret == NULL)
  {
    printf("找不到该字符串！\n");
  }
  else
  {
    printf("成功找到该字符串'%s'！\n", ret);
  }
  return 0;
}

3.6 模拟实现memcpy 函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* p2, const void* p1, size_t count)
{
  assert(p2 && p1);
    void* ret = p2; 
  while (count--)
  {
    *(char*)p2 = *(char*)p1;
    p2 = (char*)p2 + 1;
    p1 = (char*)p1 + 1;
  }
    return ret;
}
int main()
{
  int arr1[10] = { 1,2,3,4,5,6,7,8,9 };
  int arr2[5] = { 0 };
  printf("Before copy , the char inside arr2 are :>");
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    printf(" %d", arr2[i]);
  }
  printf("\n");
  my_memcpy(arr2, arr1, 20);
  printf("After copy , the char inside arr2 are :>");
  for (i = 0; i < 5; i++)
  {
    printf(" %d", arr2[i]);
  }
  printf("\n");
 return 0;
}

3.7 模拟实现memmove 函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* p2, const void* p1, size_t count)
{
  assert(p2 && p1);
  void* ret = p2;
  if (p2 < p1)
  {
    while (count--)
    {
      *(char*)p2 = *(char*)p1;
      p2 = (char*)p2 + 1;
      p1 = (char*)p1 + 1;
    }
  }
  else
  {
    while (count--)
    {
      *((char*)p2 + count) = *((char*)p1 + count);
    }
  }
  return ret;
}
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9 };
 printf("Before copy , the char inside arr are :>");
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    printf(" %d", arr[i]);
  }
  printf("\n");
 my_memmove(arr + 2, arr, 20);
 printf("After copy , the char inside arr are :>");
  for (i = 0; i < 5; i++)
  {
    printf(" %d", arr[i]);
  }
  printf("\n");
 return 0;
}
#define _CRT_SECURE_NO_WARNINGS 1

4.总结：

今天我们对字符串函数与内存函数的相关知识又有了新的了解,学习了10个常用字符串操作函数以及3个常用内存函数的相关知识，完成了其中部分库函数的自定义模拟实现，希望我的文章和讲解能对大家的学习提供一些帮助。

当然，本文仍有许多不足之处，欢迎各位小伙伴们随时私信交流、批评指正！我们下期见~

c3ad96b16d2e46119dd2b9357f295e3f.jpg

文章标签：
C语言
关键词：
C语言函数
C语言内存
内存函数
c语言字符串函数内存
C语言内存函数
游客zmarifzwlqzqs
目录
相关文章
Skyund
|
8天前
|
C语言
c语言调用的函数的声明
被调用的函数的声明： 一个函数调用另一个函数需具备的条件: 首先被调用的函数必须是已经存在的函数，即头文件中存在或已经定义过； 如果使用库函数，一般应该在本文件开头用#include命令将调用有关库函数时在所需要用到的信息“包含”到本文件中。.h文件是头文件所用的后缀。 如果使用用户自己定义的函数，而且该函数与使用它的函数在同一个文件中，一般还应该在主调函数中对被调用的函数做声明。 如果被调用的函数定义出现在主调函数之前可以不必声明。 如果已在所有函数定义之前，在函数的外部已做了函数声明，则在各个主调函数中不必多所调用的函数在做声明
Skyund
23 6
ephemerals__
|
22天前
|
C语言
【c语言】动态内存管理
本文介绍了C语言中的动态内存管理，包括其必要性及相关的四个函数：`malloc`、``calloc``、`realloc`和`free`。`malloc`用于申请内存，`calloc`申请并初始化内存，`realloc`调整内存大小，`free`释放内存。文章还列举了常见的动态内存管理错误，如空指针解引用、越界访问、错误释放等，并提供了示例代码帮助理解。
ephemerals__
33 3
c的前世今生
|
21天前
|
存储 算法 程序员
C语言：库函数
C语言的库函数是预定义的函数，用于执行常见的编程任务，如输入输出、字符串处理、数学运算等。使用库函数可以简化编程工作，提高开发效率。C标准库提供了丰富的函数，满足各种需求。
c的前世今生
26 1
ephemerals__
|
24天前
|
存储 C语言
【c语言】字符串函数和内存函数
本文介绍了C语言中常用的字符串函数和内存函数，包括`strlen`、`strcpy`、`strcat`、`strcmp`、`strstr`、`strncpy`、`strncat`、`strncmp`、`strtok`、`memcpy`、`memmove`和`memset`等函数的使用方法及模拟实现。文章详细讲解了每个函数的功能、参数、返回值，并提供了具体的代码示例，帮助读者更好地理解和掌握这些函数的应用。
ephemerals__
20 0
ephemerals__
|
24天前
|
C语言
【c语言】qsort函数及泛型冒泡排序的模拟实现
本文介绍了C语言中的`qsort`函数及其背后的回调函数概念。`qsort`函数用于对任意类型的数据进行排序，其核心在于通过函数指针调用用户自定义的比较函数。文章还详细讲解了如何实现一个泛型冒泡排序，包括比较函数、交换函数和排序函数的编写，并展示了完整的代码示例。最后，通过实际运行验证了排序的正确性，展示了泛型编程的优势。
ephemerals__
19 0
白子寰
|
1月前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
白子寰
34 3
大东瓜123
|
C# C语言 C++
从头开始学习c语言
以前的时候学习C语言时候认为C语言不过是一个学习的工具,学习一些理论知识就达到目的了,谁会用这么傻的语言啊,连个界面也没有,不像vb一下子就做出一个窗体来,放上几个按钮就可以了 后来学习C++的时候,认为C++与C是一种完全不同的语言,两者基本没有什么兼容性,当时在学校里看书的时候,一直比较纳闷为会c++的书上会写C++/C语言教程,到了现在才明白,我去C++与C本来就是一体是一脉相承的
大东瓜123
1049 0
ephemerals__
|
27天前
|
存储 缓存 C语言
【c语言】简单的算术操作符、输入输出函数
本文介绍了C语言中的算术操作符、赋值操作符、单目操作符以及输入输出函数 `printf` 和 `scanf` 的基本用法。算术操作符包括加、减、乘、除和求余，其中除法和求余运算有特殊规则。赋值操作符用于给变量赋值，并支持复合赋值。单目操作符包括自增自减、正负号和强制类型转换。输入输出函数 `printf` 和 `scanf` 用于格式化输入和输出，支持多种占位符和格式控制。通过示例代码详细解释了这些操作符和函数的使用方法。
ephemerals__
35 10
ephemerals__
|
26天前
|
机器学习/深度学习 C语言
【c语言】一篇文章搞懂函数递归
本文详细介绍了函数递归的概念、思想及其限制条件，并通过求阶乘、打印整数每一位和求斐波那契数等实例，展示了递归的应用。递归的核心在于将大问题分解为小问题，但需注意递归可能导致效率低下和栈溢出的问题。文章最后总结了递归的优缺点，提醒读者在实际编程中合理使用递归。
ephemerals__
54 7
ephemerals__
|
26天前
|
存储 编译器 程序员
【c语言】函数
本文介绍了C语言中函数的基本概念，包括库函数和自定义函数的定义、使用及示例。库函数如`printf`和`scanf`，通过包含相应的头文件即可使用。自定义函数需指定返回类型、函数名、形式参数等。文中还探讨了函数的调用、形参与实参的区别、return语句的用法、函数嵌套调用、链式访问以及static关键字对变量和函数的影响，强调了static如何改变变量的生命周期和作用域，以及函数的可见性。
ephemerals__
29 4

热门文章

最新文章

  • 1
    C语言中的逗号操作符
  • 2
    《C语言及程序设计》实践参考——改造链表
  • 3
    C语言连接MySQL数据库
  • 4
    C语言中用于计算数组长度的函数 “strlen（） ”。
  • 5
    C语言预处理之二-----宏定义那点事儿
  • 6
    《C语言程序设计进阶教程》一第3章 预防、检测及消除bug
  • 7
    《C语言及程序设计》实践项目——数据的输入
  • 8
    C语言库函数大全及应用实例十
  • 9
    C语言中大小写字母的转化
  • 10
    带你实现初阶扫雷小游戏—【C语言】
  • 1
    深入理解JavaScript内存泄漏：原因与解决方法
    134
  • 2
    动态内存的管理（内存储存的god）
    39
  • 3
    数据在内存中的存储（探索内存的秘密）
    140
  • 4
    C语言—内存函数的实现和模拟实现（内存函数的丝绸之路）
    47
  • 5
    android内存优化面试题，挑战大厂重燃激情
    37
  • 6
    容器内存可观测性新视角：WorkingSet 与 PageCache 监控
    56264
  • 7
    Java一分钟之-Java内存模型与垃圾回收机制概览
    77
  • 8
    内存 vs 硬盘：固态硬盘代替内存可以工作吗？
    126
  • 9
    webserver--Buffer类实现内存缓冲区读写（全代码）
    80
  • 10
    内存映射mmap拓展
    54

    • 相关课程

    更多
  • 你的第一门C语言课
  • C语言学习教程
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • 从 0 入门函数计算
  • Python语言基础 - 函数、面向对象、异常处理

    • 相关电子书

    更多
  • 内存取证与IaaS云平台恶意行 为的安全监控
  • 云服务器ECS内存增强型实例re6全新发布
  • 低代码开发师（初级）实战教程
    • 下一篇
    阿里云OSS设置跨域访问