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

简介: 【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

相关文章
|
7天前
|
C语言
【c语言】动态内存管理
本文介绍了C语言中的动态内存管理,包括其必要性及相关的四个函数:`malloc`、``calloc``、`realloc`和`free`。`malloc`用于申请内存,`calloc`申请并初始化内存,`realloc`调整内存大小,`free`释放内存。文章还列举了常见的动态内存管理错误,如空指针解引用、越界访问、错误释放等,并提供了示例代码帮助理解。
23 3
|
6天前
|
存储 算法 程序员
C语言:库函数
C语言的库函数是预定义的函数,用于执行常见的编程任务,如输入输出、字符串处理、数学运算等。使用库函数可以简化编程工作,提高开发效率。C标准库提供了丰富的函数,满足各种需求。
|
12天前
|
机器学习/深度学习 C语言
【c语言】一篇文章搞懂函数递归
本文详细介绍了函数递归的概念、思想及其限制条件,并通过求阶乘、打印整数每一位和求斐波那契数等实例,展示了递归的应用。递归的核心在于将大问题分解为小问题,但需注意递归可能导致效率低下和栈溢出的问题。文章最后总结了递归的优缺点,提醒读者在实际编程中合理使用递归。
35 7
|
9天前
|
存储 C语言
【c语言】字符串函数和内存函数
本文介绍了C语言中常用的字符串函数和内存函数,包括`strlen`、`strcpy`、`strcat`、`strcmp`、`strstr`、`strncpy`、`strncat`、`strncmp`、`strtok`、`memcpy`、`memmove`和`memset`等函数的使用方法及模拟实现。文章详细讲解了每个函数的功能、参数、返回值,并提供了具体的代码示例,帮助读者更好地理解和掌握这些函数的应用。
12 0
|
9天前
|
C语言
【c语言】qsort函数及泛型冒泡排序的模拟实现
本文介绍了C语言中的`qsort`函数及其背后的回调函数概念。`qsort`函数用于对任意类型的数据进行排序,其核心在于通过函数指针调用用户自定义的比较函数。文章还详细讲解了如何实现一个泛型冒泡排序,包括比较函数、交换函数和排序函数的编写,并展示了完整的代码示例。最后,通过实际运行验证了排序的正确性,展示了泛型编程的优势。
11 0
|
22天前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
30 3
|
13天前
|
存储 缓存 C语言
【c语言】简单的算术操作符、输入输出函数
本文介绍了C语言中的算术操作符、赋值操作符、单目操作符以及输入输出函数 `printf` 和 `scanf` 的基本用法。算术操作符包括加、减、乘、除和求余,其中除法和求余运算有特殊规则。赋值操作符用于给变量赋值,并支持复合赋值。单目操作符包括自增自减、正负号和强制类型转换。输入输出函数 `printf` 和 `scanf` 用于格式化输入和输出,支持多种占位符和格式控制。通过示例代码详细解释了这些操作符和函数的使用方法。
30 10
|
12天前
|
存储 编译器 程序员
【c语言】函数
本文介绍了C语言中函数的基本概念,包括库函数和自定义函数的定义、使用及示例。库函数如`printf`和`scanf`,通过包含相应的头文件即可使用。自定义函数需指定返回类型、函数名、形式参数等。文中还探讨了函数的调用、形参与实参的区别、return语句的用法、函数嵌套调用、链式访问以及static关键字对变量和函数的影响,强调了static如何改变变量的生命周期和作用域,以及函数的可见性。
24 4
|
17天前
|
存储 编译器 C语言
C语言函数的定义与函数的声明的区别
C语言中,函数的定义包含函数的实现,即具体执行的代码块;而函数的声明仅描述函数的名称、返回类型和参数列表,用于告知编译器函数的存在,但不包含实现细节。声明通常放在头文件中,定义则在源文件中。