AI 助理
备案控制台
开发者社区 人工智能 文章 正文

C语言字符串操作函数(库函数)及其实现

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

本章重点：

重点介绍处理字符串和字符串的库函数的使用和注意事项

函数介绍及模拟实现

1.1strlen

size_t strlen ( const char * str );

  • 字符串已经以'\0'作为结束标志，而strlen函数的功能是返回在字符串中'\0'前面出现的字符个数（不包括'\0'）。
  • 参数指向的字符串必须要以'\0'结束。
  • 注意函数的返回值为size_t，是无符号整形（易错）。
  • strlen函数的模拟实现。

示例>

#include <stdio.h>
int main()
{
const char*str1 = "abcdef";
const char*str2 = "bbb";
if(strlen(str2)-strlen(str1)>0)
{
printf("str2>str1\n");
}
else
{
printf("srt1>str2\n");
}
return 0;
}

运行结果>


2a305863f3c74b88999629575be8f9dc.png strlen函数实现有三种方式：

  • 常规
  • 指针运算
  • 递归实现

模拟实现>

/*模拟实现strlen*/
//常规
size_t my_strlen1(char* str)
{
  assert(str);
  size_t count = 0;
  while (*str)
  {
    str++;
    count++;
  }
  return count;
}
//指针运算
size_t my_strlen2(char* str)
{
  assert(str);
  char* strat = str;
  while (*str)
  {
    str++;
  }
  return str - strat;
}
//递归实现
size_t my_strlen3(char* str)
{
  assert(str);
  if (*str)
    return 1 + my_strlen3(str + 1);
  else
    return 0;
}
int main()
{
  char arr[] = "abcdef";
  size_t ret = my_strlen1(arr);
  printf("%d\n", ret);
  ret = my_strlen2(arr);
  printf("%d\n", ret);
  ret = my_strlen3(arr);
  printf("%d\n", ret);
  return 0;
}

这里的assert函数是判断传递过来的指针是否为空，如果为空直接终止程序报告错误。

运行结果>



ace7ddd2bfc7448a8ee8140c0a1f74c2.png

1.2strcpy

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

将源指向的C字符串复制到目标指向的数组中，包括结束空字符(并在该点停止)。

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

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

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

目标空间必须可变

模拟实现


int main()
{
  char str[20] = "";
  char* p = "hello world!";
  strcpy(str, p);
  printf("%s", str);
  return 0;
}


99252c2795fb472a833fd52497499624.png


 模拟实现>

/*模拟实现strcpy*/
char* my_strcpy( char* str1,const char* str2)
{
  char* ret = str1;
  assert(str1 && str2);
  while (*str1++ = *str2++)
  {
    ;
  }
  return ret;
}
int main()
{
  char str[20] = "";
  char* p = "hello world!";
  my_strcpy(str, p);
  printf("%s", str);
  return 0;
}

结果跟上面例子相同。

1.3strcat

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


将源字符串的副本追加到目标字符串。destination中的终止空字符将被source的第一个字符覆盖，并且在destination中由两者连接形成的新字符串的末尾包含一个空字符。

源字符串必须是以’\0‘结束。

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

目标空间必须可修改。

字符串自己给自己追加又如何呢？

模拟实现>


/*模拟实现strcat*/
char* my_strcat(char* str1, const char* str2)
{
  assert(str1 && str2);
  char* ret = str1;
  while (*str1)
  {
    str1++;
  }
  while (*str1++ = *str2++)
  {
    ;
  }
  return ret;
}
int main()
{
  char arr[20] = "hello";
  char* p = " world!";
  my_strcat(arr, p);
  printf("%s", arr);
  return 0;
}

运行结果 >


5ab22a80e31f46ebaad152e5748d16e7.png


那自己追加自己会发生什么呢？

我们来写代码演示演示(这里还是用我们的my_strcat)>


char* my_strcat(char* str1, const char* str2)
{
  assert(str1 && str2);
  char* ret = str1;
  while (*str1)
  {
    str1++;
  }
  while (*str1++ = *str2++)
  {
    ;
  }
  return ret;
}
int main()
{
  char arr[20] = "hello";
  my_strcat(arr, arr);
  printf("%s", arr);
  return 0;
}

393dc639ceb540d8b48de7c2ca479148.png

我们可以看到程序挂掉了，那为什么会挂掉呢？

我们来画图解释一下>



6a0d5815806a464bbdfd220c0e34b528.png

1.4strcmp

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


  • 这个函数开始比较每个字符串的第一个字符。如果它们相等，则继续执行尾随对，直到字符不同或到达终止空字符为止。
  • 标准规定：
  1. 第一个字符串大于第二个字符串，则返回大于0的数字。
  2. 第一个字符串等于第二个字符串，则返回0。
  3. 第一个字符串小于第二个字符串，则返回大于0的数字。

模拟实现>

/*模拟实现strcmp*/
int my_strcmp(const char* str1, const char* str2)
{
  assert(str1 && str2);
  while (*str1 == *str2)
  {
    if (*str1=='\0')
      return 0;
    str1++;
    str2++;
  }
  if (*str1 > *str2)
  {
    return 1;
  }
  else
  {
    return -1;
  }
}
int main()
{
  char arr1[] = "abr";
  char arr2[] = "abqde";
  int ret = my_strcmp(arr1, arr2);
  if (ret == 0)
    printf("相同\n");
  else if (ret > 0)
    printf("arr1>arr2\n");
  else
    printf("arr1<arr2\n");
  return 0;
}


运行结果>

cac3d480a88444d9895106b24b26a7b7.png


当然我们目前学习了strcpy、strcat、strcmp，这些都是不太安全的，一次性全部拷贝完、一次性全部追加完、一次性全部比较完，这些都不是很安全，那么接下来我们要学习一些相对于上面那三个比较安全一点的。strncpy、strncat、strncmp，这三个函数的功能和上面的一样，不同的是参数多了一个n，来确定每次拷贝几个字符、每次追加几个字符、每次比较几个字符。接下来我们来模拟实现一下这三个函数。


1.5strncpy

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


将源文件的第一个num字符复制到目标文件。如果在拷贝num个字符之前找到源C字符串的结尾(以nullcharacter为标志)，则destination将被填充为0，直到总共写入num个字符。

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

如果源字符串的长度小于num，则拷贝完源字符串后，在目标的后面追加0，知道num个。

模拟实现>

char* my_strncpy(char* dest, const char* src, size_t num)
{
  assert(dest && src);
  char* ret = dest;
  size_t i = 0;
  for (i = 0; i < num; i++)
  {
    *dest = *src;
    dest++;
    src++;
  }
  return ret;
}
int main()
{
  char str1[] = "abcdefg";
  char str2[20] = { 0 };
  my_strncpy(str2, str1, 5);
  printf(str2);
  return 0;
}

运行结果> 

d1cc530e426a4f16b9b9d9c218550659.png


1.6strncat

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


  • 将源文件的第一个num字符附加到目标文件，加上一个终止空字符。
  • 如果source中C字符串的长度小于num，则只复制到结束空字符的内容。

模拟实现>


char* my_strncat(char* dest, const char* src, size_t num)
{
  assert(dest && src);
  char* ret = dest;
  while (*dest)
  {
    dest++;
  }
  size_t i = 0;
  for (i = 0; i < num; i++)
  {
    *dest = *src;
    dest++;
    src++;
  }
  return ret;
}
int main()
{
  char str1[20] = "abcd";
  char str2[20] = "efghigk";
  my_strncat(str1, str2, 4);
  printf(str1);
  return 0;
}

运行结果>


700e0e26ab4e4f8d906e8c5adc337cb4.png



1.7strncmp

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



  • 将C字符串stri的最多num个字符与C字符串str2的字符进行比较。这个函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续处理下面的对，直到字符不同，直到到达一个终止null字符，或直到两个字符串中num字符匹配，以先发生的为准。

8f1f98ba04424858b33551ff2735ee18.png


 模拟实现>

int my_strcmp(const char* str1, const char* str2,size_t num)
{
  assert(str1 && str2);
  size_t i = 0;
  for (i = 0; i < num; i++)
  {
    if (*str1 > *str2)
      return 1;
    else if (*str1 < *str2)
      return -1;
    str1++;
    str2++;
  }
  if (*str1 == *str2)
    return 0;
}
int main()
{
  char arr1[] = "abqsg";
  char arr2[] = "abqde";
  int ret = my_strcmp(arr1, arr2,4);
  if (ret == 0)
    printf("相同\n");
  else if (ret > 0)
    printf("arr1>arr2\n");
  else
    printf("arr1<arr2\n");
  return 0;
}

运行结果>


090879c0b1db4da1ae0843a6137fc3b7.png



1.8strstr

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


  • 返回指向str1中str2第一次出现的指针。如果str2不是stri的一部分，则为空指针。

模拟实现（暴力算法）>

/*模拟实现strstr*/
char* my_strstr(const char* str1, const char* str2)
{
  assert(str1 && str2);
  if (*str2 == '\0')
    return (char*)str1;
  const char* s1 = NULL;
  const char* s2 = NULL;
  const char* cp = str1;
  while (*cp)
  {
    s1 = cp;
    s2 = str2;
    while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
    {
      s1++;
      s2++;
    }
    if (*s2 == '\0')
    {
      return (char*)cp;
    }
    cp++;
  }
  return NULL;
}
int main()
{
  char* str1 = "acdbbbcdefa";
  char* str2 = "bbc";
  char* ret = my_strstr(str1, str2);
  if (ret == NULL)
    printf("没找着\n");
  else
  {
    printf("%s", ret);
  }
  return 0;
}


运行结果>


029fb54165d94227b72f26b3ab00dca2.png

1.9strtok

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

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

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

strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：

strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

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

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

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

代码演示>


int main()
{
  char arr[] = "192#168.120.85";
  char* p = "#.";
  char buf[20] = { 0 };
  strcpy(buf, arr); 
  char* ret = strtok(buf, p);
  printf("%s\n", ret);
  ret = strtok(NULL, p);
  printf("%s\n", ret);
  ret = strtok(NULL, p);
  printf("%s\n", ret);
  ret = strtok(NULL, p);
  printf("%s\n", ret);
  return 0;
}


bfc813d953e7443ca521178aa1a804e8.png也可以使用for循环>

int main()
{
  char arr[] = "192#168.120.85";
  char* p = "#.";
  char buf[20] = { 0 };
  strcpy(buf, arr);
  char* ret = NULL;
  for (ret = strtok(buf, p); ret != NULL; ret=strtok(NULL, p))
  {
    printf("%s\n", ret);
  }
  return 0;
}


5f14e6de0e4a42e6bdc47d10c2aaa920.png


结果和上面相同。

1.10strerror

char * strerror ( int errnum );

  • C语言的库函数在运行的时候，如果发生错误，就会将错误码存在一个变量中，这个变量是：errno
  • 错误码是一些数字：1 2 3 4 5
  • 我们需要讲错误码翻译成错误信息


108cb4250ef14f43b65f9cf14a62b0b0.png

字符分类函数>


1686203020247.png

字符转换>

1. int tolower ( int c );
2. int toupper ( int c );

1.11memcpy

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


  • 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
  • 这个函数在遇到 '\0' 的时候并不会停下来。
  • 如果source和destination有任何的重叠，复制的结果都是未定义的

模拟实现>

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()
{
  char arr[] = {"hello world!"};
  int arr1[20] = {0};
  my_memcpy(arr1, arr, 12);
  printf("%s", arr1);
  return 0;
}


649e5a339cca45bba52fcd1ad19aaa6a.png

1.12memmove

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


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

模拟实现>


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);
    }
  }
  return ret;
}
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9 };
  my_memmove(arr+2, arr, 16);
  int i = 0;
  for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}


86727ac962494e839e035a6c83c74ab9.png


1.13memcmp

int memcmp ( const void * ptr1, const void * ptr2, size_t num );
  • 比较从ptr1和ptr2指针开始的num个字节
  • 返回值如下：



025d9671777740e389566d90314a873c.png

代码演示>

int main()
{
  char buffer1[] = "DWgaOtP12df0";
  char buffer2[] = "DWGAOTP12DF0";
  int n;
  n = memcmp(buffer1, buffer2, sizeof(buffer1));
  if (n > 0)
    printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
  else if (n < 0)
    printf("'%s' is less than '%s'.\n", buffer1, buffer2);
  else
    printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
  return 0;
}


595f9ef8a6694cc68c8487e0707bebf7.png


小结

      今天我们学习了字符串操作函数（库函数）的理解、实现、模拟，相信大家看完有一定的收获。


      种一棵树的最好时间是十年前，其次是现在！ 把握好当下，合理利用时间努力奋斗，相信大家一定会实现自己的目标！加油！创作不易，辛苦各位小伙伴们动动小手，三连一波💕💕~~~，本文中也有不足之处，欢迎各位随时私信点评指正！

文章标签：
C语言
安全
算法
关键词：
C语言函数
C语言字符串
C语言库
C语言字符串操作
C语言字符串操作函数
cv工程师小智
目录
相关文章
LuckiBit
|
24天前
|
存储 C语言 开发者
【C语言】字符串操作函数详解
这些字符串操作函数在C语言中提供了强大的功能，帮助开发者有效地处理字符串数据。通过对每个函数的详细讲解、示例代码和表格说明，可以更好地理解如何使用这些函数进行各种字符串操作。如果在实际编程中遇到特定的字符串处理需求，可以参考这些函数和示例，灵活运用。
LuckiBit
48 10
LuckiBit
|
24天前
|
存储 程序员 C语言
【C语言】文件操作函数详解
C语言提供了一组标准库函数来处理文件操作，这些函数定义在 `<stdio.h>` 头文件中。文件操作包括文件的打开、读写、关闭以及文件属性的查询等。以下是常用文件操作函数的详细讲解，包括函数原型、参数说明、返回值说明、示例代码和表格汇总。
LuckiBit
43 9
LuckiBit
|
24天前
|
存储 Unix Serverless
【C语言】常用函数汇总表
本文总结了C语言中常用的函数，涵盖输入/输出、字符串操作、内存管理、数学运算、时间处理、文件操作及布尔类型等多个方面。每类函数均以表格形式列出其功能和使用示例，便于快速查阅和学习。通过综合示例代码，展示了这些函数的实际应用，帮助读者更好地理解和掌握C语言的基本功能和标准库函数的使用方法。感谢阅读，希望对你有所帮助！
LuckiBit
33 8
LuckiBit
|
24天前
|
C语言 开发者
【C语言】数学函数详解
在C语言中，数学函数是由标准库 `math.h` 提供的。使用这些函数时，需要包含 `#include <math.h>` 头文件。以下是一些常用的数学函数的详细讲解，包括函数原型、参数说明、返回值说明以及示例代码和表格汇总。
LuckiBit
43 6
LuckiBit
|
24天前
|
存储 C语言
【C语言】输入/输出函数详解
在C语言中，输入/输出操作是通过标准库函数来实现的。这些函数分为两类：标准输入输出函数和文件输入输出函数。
LuckiBit
166 6
LuckiBit
|
24天前
|
存储 缓存 算法
【C语言】内存管理函数详细讲解
在C语言编程中，内存管理是至关重要的。动态内存分配函数允许程序在运行时请求和释放内存，这对于处理不确定大小的数据结构至关重要。以下是C语言内存管理函数的详细讲解，包括每个函数的功能、标准格式、示例代码、代码解释及其输出。
LuckiBit
52 6
LuckiBit
|
24天前
|
C语言 开发者
【C语言】断言函数 -《深入解析C语言调试利器 ！》
断言（assert）是一种调试工具，用于在程序运行时检查某些条件是否成立。如果条件不成立，断言会触发错误，并通常会终止程序的执行。断言有助于在开发和测试阶段捕捉逻辑错误。
LuckiBit
35 5
东方睿赢
|
27天前
|
存储 算法 C语言
C语言中常见的字符串处理技巧，包括字符串的定义、初始化、输入输出、长度计算、比较、查找与替换、拼接、截取、转换、遍历及注意事项
本文深入探讨了C语言中常见的字符串处理技巧，包括字符串的定义、初始化、输入输出、长度计算、比较、查找与替换、拼接、截取、转换、遍历及注意事项，并通过案例分析展示了实际应用，旨在帮助读者提高编程效率和代码质量。
东方睿赢
81 4
XIAZHI
|
1月前
|
存储 人工智能 算法
数据结构实验之C 语言的函数数组指针结构体知识
本实验旨在复习C语言中的函数、数组、指针、结构体与共用体等核心概念，并通过具体编程任务加深理解。任务包括输出100以内所有素数、逆序排列一维数组、查找二维数组中的鞍点、利用指针输出二维数组元素，以及使用结构体和共用体处理教师与学生信息。每个任务不仅强化了基本语法的应用，还涉及到了算法逻辑的设计与优化。实验结果显示，学生能够有效掌握并运用这些知识完成指定任务。
XIAZHI
57 4
白子寰
|
2月前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
白子寰
41 3