天天看点
返回

【C进阶】鹏哥带你玩转 · 字符串和内存函数

大家好，我是安然无虞。

目录

​​一、常见字符串库函数介绍​​

​​1、strlen()​​

​​自定义函数模拟实现strlen​​

​​2、strcpy()​​

​​自定义函数模拟实现strcpy​​

​​3、strcat()​​

​​自定义函数模拟实现strcat​​

​​4、strcmp()​​

​​自定义函数模拟实现strcmp​​

​​5、strncpy()​​

​​6、strncat()​​

​​7、strncmp()​​

​​8、strstr()​​

​​自定义函数模拟实现strstr​​

​​9、strtok()​​

​​10、strerror()​​

​​二、字符分类函数​​

​​三、常见内存操作函数​​

​​1、memcpy()​​

​​自定义函数模拟实现memcpy​​

​​2、memmove()​​

​​自定义函数模拟实现memmove​​

​​3、memcmp()​​

​​4、memset()​​

​​四、遇见安然遇见你，不负代码不负卿。​​

前言：

前段时间状态不好，所以已经有24天没有更新了，打开手机有很多铁子的消息没有及时回复，这几天正在陆陆续续回，实在抱歉，感谢大家的支持与陪伴，现在的话我正开始慢慢追，一起加油。 

一、常见字符串库函数介绍

C语言中对字符和字符串的操作处理很是频繁，但是C语言本身是没有字符串类型的，所以C语言中的字符串通常放在常量字符串中或者字符数组中；

字符串常量适用于那些对它不作任何修改的字符串函数。

本章重点：

求字符串长度
  • strlen
长度不受限制的字符串库函数
  • strcpy
  • strcat
  • strcmp
长度受限制的字符串库函数
  • strncpy
  • strncat
  • strncmp
字符串查找
  • strstr
  • strtok
错误信息报告
  • strerror

字符操作库函数

内存操作库函数

  • memcpy
  • memmove
  • memset
  • memcmp

注意：

长度不受限制表示的是一直追加到 '\0' ，跟长度无关；

长度受限制表示跟长度有关，可能这样说不好理解，别担心，看到后面你就明白了。 

1、strlen()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

函数功能：

求字符串的长度 

注意：返回值类型是 size_t，这 size_t 到底是什么？

其实 size_t 是为 sizeof 操作符返回值设计的，可以浅显的认为 size_t 就是我们熟知的 unsigned int ，因为是求长度，所以肯定不会是负数，故而使用无符号整型，但是由此也容易产生 bug，请看下面代码：

解读下面代码，请问输出结果是什么：

#include<stdio.h>
#include<string.h>

int main()
{
  if (strlen("abc") - strlen("abcdef") > 0)
    printf(">");
  else
    printf("<=");
  return 0;
}

没错，答案是输出 ">"，为什么呢？3 - 6 = -3鸭，这是怎么回事？

这是因为strlen的返回值是 size_t ，属于无符号数，所以两个无符号数相减，答案一定是无符号数，如果大家还是不明白的话，可以看看这篇文章，说的很清楚哦。

深度剖析数据在内存中的存储

【C进阶】鹏哥带你玩转 · 字符串和内存函数

那怎么修改呢？

方案一：强制类型转换

#include<stdio.h>
#include<string.h>

int main()
{
  if ((int)strlen("abc") - (int)strlen("abcdef") > 0 )
    printf(">");
  else
    printf("<=");
  return 0;
}

方案二：直接比较

#include<stdio.h>
#include<string.h>

int main()
{
  if (strlen("abc") > strlen("abcdef"))
    printf(">");
  else
    printf("<=");
  return 0;
}

注意：

  • 字符串以 '\0' 作为结束标志，strlen 返回的是在字符串中 '\0' 之前的字符个数（不包括'\0'）;
  • 参数中指向的字符串必须以 '\0' 结束；
  • 注意strlen函数的返回值是 size_t 类型，属于无符号类型（特易错）

代码示例：

#include<stdio.h>
#include<string>

int main()
{
    int len = strlen("abcdef");
    printf("%d\n", len);

    return 0;
}

自定义函数模拟实现strlen

【手把手带你刷LeetCode】——18.自定义函数实现strlen()功能（作业）_安然无虞的博客博客今天是力扣打卡第18天！这道题并不是力扣上面的题目，而是一道作业，鹏哥说很重要，我便把它整理成一篇小博文了。原题：自定义函数实现strlen()功能先让我们感受一下strlen()函数：#include<stdio.h>#include<string.h>int main(){char arr[] = "abcdefghij";printf("%d\n", strlen(arr));//输出10return 0;}strlen().

  1. 计数器的方法
  2. 递归的方法
  3. 指针 - 指针

方法一：计数器的方法

int my_strlen(const char* str)
{
  assert(str);//断言str非空
  int count = 0;
  while (*str != '\0')
  {
    count++;
    str++;
  }
  return count;
}

方法二：递归的方法

int my_strlen(const char* str)
{
  assert(str);//断言str非空
  //找边界
  if (*str == '\0')
  {
    return 0;
  }
  int count = my_strlen(str + 1);
  //注意str++和str+1是不同的概念
  count++;
  return count;
}
这里需要注意的是，str++ 和 str+1 不是一个概念，str++是先使用后++，本题可以写成++str的形式，先++再使用。

方法三：指针 - 指针

指针-指针其实表示的是两个指针中间的元素个数，注意哦，不是中间有几个字节。 
int my_strlen(const char* str)
{
  assert(str);
  const char* cur = str;
  while (*cur != '\0')
  {
    cur++;
  }
  return cur - str;
}

2、strcpy()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

函数功能： 

 将源字符串拷贝到目标字符串，返回目标字符串首元素的地址。 

解读下列代码：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr1[] = "abcdef";
  char arr2[20] = { 0 };
  printf("%s\n", strcpy(arr2, arr1));

  return 0;
}

本题是将字符串 arr2 拷贝给字符串 arr1 ，返回的是 arrr2 首元素的地址（目标字符串首元素的地址）。所以上面代码输出的是：abcdef，那么这里的问题是，会不会将字符串arr1中的 '\0' 拷贝给字符串 arr2 ，所以这里用以下代码验证这个问题：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr1[] = "abcdef";
  char arr2[20] = "XXXXXXXXXX";
  printf("%s\n", strcpy(arr2, arr1));

  return 0;
}

首先，还没有将字符串 arr1 拷贝给 arr2 时，它们存放的数据是这样的：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

当执行 strcpy(arr2, arr1) 完后，此时 arr2 中存放的数据是这样的：

【C进阶】鹏哥带你玩转 · 字符串和内存函数
可以看到，将字符串 arr1（源字符串） 拷贝给字符串 arr2（目标字符串） 时会自动将源字符串末尾的 '\0' 拷贝过去，返回的是目标字符串起始位置的地址。

这里又有一个问题是：如果源字符串末尾没有加上 '\0' （这里用字符数组的形式演示，正常的字符串末尾会自动填充 '\0'），请看如下代码：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr1[] = { 'a','b','c','d','e','f' };
  char arr2[20] = "XXXXXXXXXX";
  
  printf("%s\n", strcpy(arr2, arr1));
  return 0;
}

代码执行结果：

【C进阶】鹏哥带你玩转 · 字符串和内存函数
所以需要注意的是：如果想将源字符串拷贝给目标字符串，那么就要保证源字符串中是包含 '\0' 的，否则会拷贝失败。 

所以，使用 strcpy 拷贝字符串是需要注意以下几点：

  • 源字符串必须以 '\0' 结束；
  • 拷贝时会将源字符串中的 '\0' 一同拷贝给目标字符串；
  • 目标字符串（目标空间）必须足够大，以确保能存放源字符串 ；
  • 还有一点就是，目标字符串必须是可以改变的

请看下面的代码：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr1[] = "abcdef";
  const char* p = "XXXXXXXXXX";
  printf("%s\n", strcpy(p, arr1));
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数
执行程序是错误的，因为此时的目标字符串是被 const 修饰的，是不可以修改的。 

自定义函数模拟实现strcpy

【手把手带你刷好题】——22.面试题：模拟实现strcpy库函数（非力扣）_安然无虞的博客-CSDN博客【前言】今天是刷题打卡第22天！这是一道很好的题目哦，里面有一些很好的coding技巧，要留心看哦。原题：模拟实现strcpy库函数OK，废话不多说，直接上代码...初级代码：满分10分---得5分#include<stdio.h>void my_strcpy(char* dest, char* src){while (*src != '\0'){*dest = *src;dest++;src++;}*dest =代码执行： 

char* my_strcpy(char* dest, const char* src)
{
  char* ret = dest;
  assert(dest && src);
  while (*dest++ = *src++)//很妙
  {
    ;
  }
  return ret;
}

3、strcat()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

函数功能： 

将源字符串追加到目标字符串的后面，返回目标字符串首字符的地址 

解读下列代码：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr1[30] = "hello";
  char arr2[] = "world";

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

以上代码是将 "world" 拼接到 "hello" 的后面，所以打印结果如下：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

其实，使用 strcat 库函数的注意事项与 strcpy 是十分相似的，在这里的话我就不重复解释了：

  • 源字符串必须以 '\0' 结束；
  • 目标空间必须足够大，能容纳下源字符串的内容；
  • 目标空间必须可变。

那么试想：如果让我们自己实现 strcat 函数，该怎么做呢？先想一下大致思路，我们首先要找到目标字符串的结束标志'\0'，然后将源字符串拼接到目标字符串的后面，最后返回目标字符串的首字符的地址，看起来好像挺简单的，那我们实现一下：

自定义函数模拟实现strcat

代码执行：

char* my_strcat(char* dest, const char* src)
{
  char* ret = dest;
  assert(dest && src);
  //1、找到目标字符串的\0
  while (*dest)//注意循环条件写成*dest++是错误的，因为会跳过\0，请细品
  {
    dest++;
  }
  //2、拷贝源字符串
  while (*dest++ = *src++)
  {
    ;
  }
  return ret;
}

4、strcmp()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

函数功能： 

比较对应位置上字符的字典序 

标准规定：

  • 第一个字符串 > 第二个字符串，则返回大于0的数字；
  • 第一个字符串 == 第二个字符串，则返回0；
  • 第一个字符串 < 第二个字符串，则返回小于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 *str1 - *str2;
    return 1;
  else
    return -1;
}

5、strncpy()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

看下面一段代码：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr1[] = "xxxxxxxxxxxxxx";
  char arr2[] = "hello world";
  strncpy(arr1, arr2, 5);
  printf("%s\n", arr1);
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数
这样的函数相对来说更加安全，更加可控灵活一些。 

6、strncat()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

看一段代码：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr1[20] = "hello\0xxxxx";
  char arr2[] = "world";
  strncat(arr1, arr2, 3);
  printf("%s\n", arr1);
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数

从上面我们能看出，追加完后会自动填充 '\0' ，而且是追加到目标字符串中第一个 '\0' 的后面。

7、strncmp()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

看下面一段代码：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr1[] = "acbdef";
  char arr2[] = "abcdef";
  int ret = strncmp(arr1, arr2, 3);
  printf("%d\n", ret);
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数
注意：以上代码比较的是字符串的前三个字符，而不是第三个字符。

8、strstr()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

返回值： 

【C进阶】鹏哥带你玩转 · 字符串和内存函数

函数功能：

查找字符串

看一下下面的代码：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr1[] = "abcdef";
  char arr2[] = "bcd";

  char* ret = strstr(arr1, arr2);

  if (NULL == ret)
    printf("没找到\n");
  else
    printf("%s\n", ret);
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数

自定义函数模拟实现strstr

代码执行：

char* my_strstr(const char* str, const char* substr)
{
  const char* s1 = str;
  const char* s2 = substr;
  const char* cur = str;

  assert(str && substr);
  //特殊情况
  if (*substr == '\0')
    return (char*)str;
  while (*cur)
  {
    s1 = cur;
    s2 = substr;
    while (*s1 && *s2 && *s1 == *s2)//注意*s1!='\0&&*s2!='\0
    {
      s1++;
      s2++;
    }
    if (*s2 == '\0')
      return (char*)cur;
    cur++;
  }
  return NULL;
}

9、strtok()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

使用前注意事项：

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

也可以这样说：

  • strtok函数找第一个标记的时候，函数的第一个参数不是NULL；
  • strtok函数找非第一个标记的时候，函数的第一个参数是NULL

看下面一段代码：

#include<stdio.h>
#include<string.h>

int main()
{
  const char* p = "@.";
  char arr[] = "[email protected]";
  char buf[50] = { 0 };//作为临时拷贝
  strcpy(buf, arr);
  char* str = strtok(buf, p);
  printf("%s\n", str);//zpengwei
  str = strtok(NULL, p);
  printf("%s\n", str);//yeah
  str = strtok(NULL, p);
  printf("%s\n", str);//net
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数

不过这样使用看起来太繁琐了，看看下面的改进代码：

#include<stdio.h>
#include<string.h>

int main()
{
  const char* p = "@.";
  char arr[] = "[email protected]";
  char buf[50] = { 0 };//作为临时拷贝
  strcpy(buf, arr);
  char* str = NULL;
  for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
  {
    printf("%s\n", str);
  }
  //char* str = strtok(buf, p);
  //printf("%s\n", str);//zpengwei
  //str = strtok(NULL, p);
  //printf("%s\n", str);//yeah
  //str = strtok(NULL, p);
  //printf("%s\n", str);//net
  return 0;
}

10、strerror()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

返回值：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

函数功能：

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

看下面这段代码：

//C语言可以操作文件
//打开文件 - fopen

//当库函数使用的时候，发生错误会把errno这个全局的错误变量设置为本次执行库函数产生的错误码
//errno是C语言提供的一个全局变量，可以直接使用，放在errno.h文件中的
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main()
{
  //打开文件
  FILE* pf = fopen("test.txt", "r");
  if (NULL == pf)
  {
    //出错误的原因是什么
    printf("%s\n", strerror(errno));
    return 0;
  }
  //读文件
  //...

  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数

常见字符串库函数终于讲解完了，换换心情。

【C进阶】鹏哥带你玩转 · 字符串和内存函数

二、字符分类函数

使用字符操作函数需要注意的是头文件为ctype.h

下面函数比较简单，就不详细介绍了。

【C进阶】鹏哥带你玩转 · 字符串和内存函数

字符转换：

  • int tolower(int c)
  • int toupper(int c)

代码示例：

#include<stdio.h>
#include<ctype.h>

int main()
{
  char ch = 0;
  ch = getchar();
  if (islower(ch))
    ch = toupper(ch);
  else
    ch = tolower(ch);

  printf("%c\n", ch);

  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数

三、常见内存操作函数

1、memcpy()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

注意哦，内存操作函数中的第三个参数单位是字节。

想想为什么是void*类型？

因为设计者在设计这个库函数的时候不知道会用来拷贝何种类型，所以只有设计成void*最合适。 

看下面一段代码：

#include<stdio.h>
#include<string.h>

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

  int i = 0;
  for (i = 0; i < 5; i++)
  {
    printf("%d ", arr2[i]);
   }
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数

自定义函数模拟实现memcpy

代码执行： 

void* my_memcpy(void* dest, const void* src, size_t num)
{
  void* ret = dest;//注意返回类型是void*,而不是void，
  assert(dest && src);
  while (num--)//先使用，后--
  {
    *(char*)dest = *(char*)src;//想想为什么强制类型转换成char*，因为只有它最合适
    dest = (char*)dest + 1;//注意直接进行dest++,src++是错误的，因为它是空类型
    src = (char*)src + 1;
  }
  return ret;
}

2、memmove()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

其实C语言只要求：

memcpy能拷贝不重叠的内存空间就可以了，memmove去处理那些重叠的内存拷贝，也就是说，如果记memcpy的功能是A，那么memmove的功能就是A+B 

那么何为重叠的内存拷贝呢，请看下面一段代码：

#include<stdio.h>
#include<string.h>

int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  
  memmove(arr1 + 2, arr1, 5 * sizeof(arr1[0]));//处理同一块空间时会发生重叠内存拷贝

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

自定义函数模拟实现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//从后向前拷贝
  {
    //src = (char*)src + num - 1;//注意一定要-1
    //dest = (char*)dest + num - 1;
    //while (num--)
    //{
    //  *(char*)dest = *(char*)src;
    //  dest = (char*)dest - 1;
    //  src = (char*)src - 1;
    //}
    while (num--)//先使用，后--，在循环体中是--后的num（真的妙）
    {
      *((char*)dest + num) = *((char*)src + num);
    }
  }
  return ret;
}

3、memcmp()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

 返回值：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

 比较简单，看一下下面的代码：

#include<stdio.h>
#include<string.h>

int main()
{
  int arr1[] = { 1,2,7,4,5 };
  int arr2[] = { 1,2,3,4,5 };
  int ret = memcmp(arr1, arr2, 9);

  printf("%d\n", ret);
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数

4、memset()

函数原型：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

函数参数：

【C进阶】鹏哥带你玩转 · 字符串和内存函数

 函数功能：

以字节为单位设置内存 

看下面一段代码：

#include<stdio.h>
#include<string.h>

int main()
{
  char arr[20] = { 0 };
  memset(arr, 'x', 10);
  printf("%s\n", arr);
  return 0;
}
【C进阶】鹏哥带你玩转 · 字符串和内存函数

也可以对整型进行操作，不过因为是对内存进行操作，所以要考虑到大小端字节序的问题，如果大家忘记了何为大小端，可以看看这篇文章：

【手把手带你刷好题】——27.大小端字节序判断（非力扣，百度笔试题）_安然无虞的博客【前言】今天是刷题打卡第27天！感谢的陪伴，你们的认可就是我最大的动力，抱拳了哈！！大小端引入看一下下面这段代码：#include<stdio.h>int main(){int a = 0x11223344;return 0;}在内存中存储的顺序不对呀，这是为什么？这里就要介绍大小端了。什么是大端小端？大端字节序存储：当一个数据的低位放到高地址处，数据的高位放到低地址处；小端字节序存储：当一个数据的低位放到低地址处，数

四、遇见安然遇见你，不负代码不负卿。

万字博文，原创不易。
c语言 开发语言 字符串 #include 自定义函数
上一篇: 深度剖析基础数据结构系列第一章——开胃小菜之复杂度
下一篇: 剑指offer笔试题 · 常量字符串

继续阅读