大家好，我是安然无虞。

前言：

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

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

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

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

本章重点：

求字符串长度

strlen

长度不受限制的字符串库函数

strcpy

strcat

strcmp

长度受限制的字符串库函数

strncpy

strncat

strncmp

字符串查找

strstr

strtok

错误信息报告

strerror

字符操作库函数

内存操作库函数

memcpy

memmove

memset

memcmp

注意：

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

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

1、strlen()

函数原型：

函数功能：

求字符串的长度

注意：返回值类型是 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 ，属于无符号数，所以两个无符号数相减，答案一定是无符号数，如果大家还是不明白的话，可以看看这篇文章，说的很清楚哦。

那怎么修改呢？

方案一：强制类型转换

#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

方法：

计数器的方法

递归的方法

指针 - 指针

方法一：计数器的方法

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()

函数原型：

函数功能：

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

解读下列代码：

#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 时，它们存放的数据是这样的：

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

可以看到，将字符串 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;
}

代码执行结果：

所以需要注意的是：如果想将源字符串拷贝给目标字符串，那么就要保证源字符串中是包含 '\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;
}

执行程序是错误的，因为此时的目标字符串是被 const 修饰的，是不可以修改的。

自定义函数模拟实现strcpy

代码执行：

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

3、strcat()

函数原型：

函数功能：

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

解读下列代码：

#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" 的后面，所以打印结果如下：

其实，使用 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()

函数原型：

函数功能：

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

标准规定：

第一个字符串 > 第二个字符串，则返回大于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()

函数原型：

看下面一段代码：

#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;
}

这样的函数相对来说更加安全，更加可控灵活一些。

6、strncat()

函数原型：

看一段代码：

#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;
}

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

7、strncmp()

函数原型：

看下面一段代码：

#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;
}

注意：以上代码比较的是字符串的前三个字符，而不是第三个字符。

8、strstr()

函数原型：

返回值：

函数功能：

查找字符串

看一下下面的代码：

#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;
}

自定义函数模拟实现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()

函数原型：

使用前注意事项：

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[] = "zpengwei@yeah.net";
  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;
}

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

#include<stdio.h>
#include<string.h>
int main()
{
  const char* p = "@.";
  char arr[] = "zpengwei@yeah.net";
  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语言可以操作文件
//打开文件 - 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;
}

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

二、字符分类函数

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

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

字符转换：

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;
}

三、常见内存操作函数

1、memcpy()

函数原型：

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

想想为什么是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;
}

自定义函数模拟实现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语言只要求：

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()

函数原型：

返回值：

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

#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;
}

4、memset()

函数原型：

函数参数：

函数功能：

以字节为单位设置内存

看下面一段代码：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr[20] = { 0 };
  memset(arr, 'x', 10);
  printf("%s\n", arr);
  return 0;
}

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

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

万字博文，原创不易。

求个三连

【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()

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

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【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()

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

热门文章

最新文章

相关课程

相关电子书