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

C语言字符串+内存库函数详解

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

1.求字符串长度

1.1 strlen库函数

size_t strlen ( const char * str );

1.1.1函数讲解

1.函数功能：统计字符串中\0之前出现的字符个数

2.字符串已经将 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包

含 ‘\0’ )。

3.参数指向的字符串必须要以 ‘\0’ 结束。

4.注意函数的返回值为size_t，是无符号的

5.头文件#include<string.h>

代码运用：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr[] = "cjcwqr";
  printf("%d", strlen(arr));//6
  return 0;
}

1.1.2 strlen模拟实现

//strlen模拟实现
#include<stdio.h>
#include<assert.h>
int my_strlen(const char* str)
{
  assert(str);
  const char* start = str;
  const char* end = str;
  while (*end != '\0')
  {
    end++;
  }
  return end - start;
}
int main()
{
  char arr[] = "cjcwqr";
  printf("%d", my_strlen(arr));//6
  return 0;
}

2.长度不受限制的字符串

2.1 strcpy库函数

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

2.1.1函数讲解

1.函数功能：将一个字符串中\0之前的内容拷贝到另一个字符串中(替换)

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

3.会将源字符串中的 ‘\0’ 拷贝到目标空间。

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

5.目标空间必须可变.

6.头文件#include<string.h>

代码运用：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[20] = "happy";
  char arr2[] = "cjcwqr";
  strcpy(arr1, arr2);
  printf("%s\n",arr1);//cjcwqr
  return 0;
}

2.1.2 strcpy模拟实现

//strcpy模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, char* src)
{
  assert(dest);
  assert(src);
  char* start = dest;
  while (*dest++ = *src++)
  {
    ;
  }
  return start;
}
int main()
{
  char arr1[20] = "happy";
  char arr2[] = "cjcwqr";
  printf("%s\n", my_strcpy(arr1, arr2));//cjcwqr
  return 0;
}

2.2 strcat库函数

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

2.2.1函数讲解

1.函数功能：在一个字符串后面连接另一个字符串

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

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

4.目标空间必须可修改。

5.可以实现字符串自己给自己追加（有风险）

6.头文件#include<string.h>

代码运用：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[20] = "cjc";
  char arr2[] = "wqr";
  strcat(arr1, arr2);
  printf("%s",arr1);//cjcwqr
  return 0;
}

2.2.2 strcat模拟实现

//strcat模拟实现
#include<stdio.h>
char* my_strcat(char* dest, const char* src)
{
  //1.找到目标空间中的\0
  char* start = dest;
  while (*dest)
  {
    dest++;
  }
  //2.拷贝源头数据\0之后的空间
  while (*dest++ = *src++)
  {
    ;
  }
  return start;
}
int main()
{
  char arr1[20] = "cjc";
  char arr2[] = "wqr";
  my_strcat(arr1, arr2);
  printf("%s",arr1);//cjcwqr
  return 0;
}

2.3 strcmp库函数

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

2.3.1函数讲解

1.函数功能：比较两个字符串的值（ASCII值）

2.从左到右一个一个字符依次比较,遇到’\0’停止，比较的是字符的ASCII值

3.返回值：相等返回0，小于返回大于0的数字，大于返回小于0的数字

4.头文件#include<string.h>

代码运用

#include<stdio.h>
#include<string.h>
int main()
{
  //char arr1[] = "cjcwqr";
  //char arr2[] = "czc";//-1
  //char arr1[] = "cjcwqr";
  //char arr2[] = "cjc";//1
  //char arr1[] = "cjcwqr";
  //char arr2[] = "cjcwqr";//0
  char arr1[] = { 'w','q','r' };
  char arr2[] = { 'w','q','r' };//遇到\0停止无法比较
  int ret = strcmp(arr1, arr2);
  printf("%d\n", ret);
  return 0;
}

2.3.2 strcmp模拟实现

//模拟实现strcmp
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* s1, const char* s2)
{
  assert(s1 && s2);
  while (*s1 == *s2)
  {
    if (*s1 == '\0')
    {
      return 0;
    }
    s1++;
    s2++;
  }
  return *s1 - *s2;
}
int main()
{
  //char arr1[] = "cjcwqr";
  //char arr2[] = "czc";//arr1<arr2
  //char arr1[] = "cjcwqr";
  //char arr2[] = "cjc";//arr1>arr2
  char arr1[] = "cjcwqr";
  char arr2[] = "cjcwqr";//arr1==arr2
  int ret = my_strcmp(arr1, arr2);
  if (ret > 0)
  {
    printf("arr1>arr2\n");
  }
  else if(ret<0)
  {
    printf("arr1<arr2\n");
  }
  else
  {
    printf("arr1==arr2\n");
  }
  return 0;
}

3.长度受限制的字符串函数

3.1 strncpy库函数

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

3.1.1函数讲解

1.函数功能：拷贝num个字符从源字符串到目标空间。

2.如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

3.不会将源字符串中的 ‘\0’ 拷贝到目标空间，其余要点同strcpy

代码运用：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[20] = "cjchappy";
  char arr2[] = "wqr";
  //strncpy(arr1, arr2, 3);//wqrhappy
  //printf("%s", arr1);
  strncpy(arr1, arr2, 5);
  printf("%s", arr1);//wqr,因为会追加两个0，读字符串遇到0停止往后读
  return 0;
}

3.1.2 strncpy模拟实现

//strncpy模拟实现
#include<stdio.h>
char* my_strncpy(char* dest, const char* src, size_t count)
{
  char* start = dest;
  while (count != '0' && (*dest++ = *src++) != '\0')
  {
    count--;
  }
  if (count)
  {
    while (--count)
    {
      *dest++ = '\0';
    }
  }
  return start;
}
int main()
{
  char arr1[20] = "cjchappy";
  char arr2[] = "wqr";
  my_strncpy(arr1, arr2, 3);//wqr
  printf("%s", arr1);
  //my_strncpy(arr1, arr2, 5);
  //printf("%s", arr1);//wqr,因为会追加两个0，读字符串遇到0停止往后读
  return 0;
}

3.2 strncat库函数

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

3.2.1函数讲解

可以实现字符串自己给自己追加

其余要点同strncat

代码运用：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[20] = "cjc";
  char arr2[] = "wqrhappy";
  //strncat(arr1, arr2, 3);
  //printf("%s", arr1);//cjcwqr
  strncat(arr1, arr1, 3);
  printf("%s", arr1);//cjccjc
  return 0;
}

3.2.2 strncat模拟实现

//strncat模拟实现
#include<stdio.h>
char* my_strncat(char* front, char* back, size_t count)
{
  char* start = front;
  while (*front++)
  {
    ;
  }
  front--;
  while (count--)
  {
    if ((*front++ = *back++) == 0)
    {
      return start;
    }
  }
  *front = '\0';
  return start;
}
int main()
{
  char arr1[20] = "cjc";
  char arr2[] = "wqrhappy";
  my_strncat(arr1, arr2, 3);
  printf("%s", arr1);//cjcwqr
  //my_strncat(arr1, arr1, 3);
  //printf("%s", arr1);//cjccjc
  return 0;
}

3.3 strncmp库函数

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

3.3.1函数讲解

要点同strcmp

代码运用：

#include<stdio.h>
#include<string.h>
int main()
{
  //int ret = strncmp("cjcwqr", "cjc", 3);
  //printf("%d\n", ret);//0
  //int ret = strncmp("cjcwqr", "cjc", 4);
  //printf("%d\n", ret);//1
  int ret = strncmp("cjcwqr", "czc", 2);
  printf("%d\n", ret);//-1
  return 0;
}

3.3.2 strncmp模拟实现

//strncmp模拟实现
#include<stdio.h>
#include<assert.h>
int my_strncmp(const char* s1, const char* s2, size_t num)
{
  assert(s1 && s2);
  if (!num)
    return 0;
  while (--num && *s1 && (*s1 == *s2))
  {
    s1++;
    s2++;
  }
  return *s1 - *s2;
}
int main()
{
  int ret = my_strncmp("cjcwqr", "cjc", 3);
  printf("%d\n", ret);//0
  //int ret = my_strncmp("cjcwqr", "cjc", 4);
  //printf("%d\n", ret);//119
  //int ret = my_strncmp("cjcwqr", "czc", 2);
  //printf("%d\n", ret);//-16
  return 0;
}

4.字符串查找函数

4.1 srtstr库函数

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

4.1.1函数讲解

1.函数功能： 判断在一个字符串中另一个字符串是否存在

2.返回值：存在，返回子串第一次出现的位置的地址；不存在，返回NULL

3.头文件：#include<string.h>

函数运用：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[] = "cjcwqrcjcwqr";
  char arr2[] = "wqr";
  char* p = strstr(arr1, arr2);//输出：wqrcjcwqr
  char arr3[] = "czc";
  //char* p = strstr(arr1, arr3);//输出：不存在
  if (p == NULL)
  {
    printf("不存在\n");
  }
  else
  {
    printf("%s\n", p);
  }
  return 0;
}

4.1.2 strstr模拟实现

//strstr模拟实现
#include<stdio.h>
char* my_strstr(const char* str1, const char* str2)
{
  const char* s1 = str1;
  const char* s2 = str2;
  const char* p = str1;
  if (*str2 == '\0')//子串是空字符串
  {
    return str1;
  }
  while (*p)
  {
    s1 = p;
    s2 = str2;
    while (*s1 != '\0' && s2 != '\0' && (*s1 == *s2))
    {
      s1++;
      s2++;
    }
    if (*s2 == '\0')
    {
      return (char*)p;//找到子串了
    }
    p++;
  }
  return NULL;//找不到子串
}
int main()
{
  char arr1[] = "cjcwqrcjcwqr";
  char arr2[] = "wqr";
  char* p = my_strstr(arr1, arr2);//输出：wqrcjcwqr
  char arr3[] = "czc";//输出：不存在
  //char* p = my_strstr(arr1, arr3);
  if (p == NULL)
  {
    printf("不存在\n");
  }
  else
  {
    printf("%s\n", p);
  }
  return 0;
}

4.2 strtok库函数

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

4.2.1函数讲解

1.函数功能：根据标识符分割字符串

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

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

记。

4.strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

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

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

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

8.头文件：#include <string.h>

函数运用：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr[] = "cjc@wqr.com";
  char buf[200] = { 0 };
  strcpy(buf, arr);
  //strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改
  const char* p = "@.";
  char* str = NULL;
  for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
  {
    printf("%s\n", str);
  }       
  return 0;
}
//输出cjc
//    wqr
//    com

5.错误信息报告函数

5.1 strerror库函数

char * strerror ( int errnum );

5.1.1函数讲解

1.函数功能：返回错误码，所对应的错误信息。

2.头文件：#include<string.h>

函数运用：

9105bd240ab1fef7dfa1c184a5ae323c.png

6.字符操作函数

函数 如果他的参数符合下列条件就返回真

iscntrl 任何控制字符

isspace 空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’

isdigit 十进制数字 0~9

isxdigit 十六进制数字，包括所有十进制数字，小写字母a ~f，大写字母A ~F

islower 小写字母a~z

isupper 大写字母A~Z

isalpha 字母az或AZ

isalnum 字母或者数字，az,AZ,0~9

ispunct 标点符号，任何不属于数字或者字母的图形字符（可打印）

isgraph 任何图形字符

isprint 任何可打印字符，包括图形字符和空白字符

字符转换运用：

#include<stdio.h>
#include <ctype.h>
int main()
{
  char arr[] = "Are you ok?";
  char* p = arr;
  while (*p)
  {
    if (islower(*p))
    {
      *p = toupper(*p);
    }
    p++;
  }
  printf("%s\n", arr);
  return 0;
}
//输出 ARE YOU OK?

7.内存操作函数

7.1 memcpy库函数

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

7.1.1函数讲解

1.函数功能：从source的位置开始向后复制num个字节的数据到destination的内存位置。

2.这个函数在遇到 ‘\0’ 的时候并不会停下来。

3.如果source和destination有任何的重叠，复制的结果都是未定义的。

4.头文件：#include<string.h>

函数代码运用：

4bb8f4cae6c7656299bc3619ee15ec45.png

7.1.2 memcpy模拟实现

//memcpy模拟实现
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, 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()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[10] = { 0 };
  my_memcpy(arr2, arr1, 16);//从arr1复制16个字节到arr2，即为1，2，3，4
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", arr2[i]);
  }
  return 0;
}
//输出：1 2 3 4 0 0 0 0 0 0

7.2 memmove库函数

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

7.2.1函数讲解

1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

2.如果源空间和目标空间出现重叠，就得使用memmove函数处理。

3.头文件：#include<string.h>

代码运用：

#include<stdio.h>
#include<string.h>
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  memmove(arr1 + 2, arr1, 20);
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", arr1[i]);
  }
  return 0;
}
//原数组：1 2 3 4 5 6 7 8 9 10
//           1 2 3 4 5         （从下标2开始覆盖原数组前20个字节，即1 2 3 4 5覆盖3 4 5 6 7）
//       1 2 1 2 3 4 5 8 9 10  （最终输出）

7.2.2 memmove模拟实现

//memmove模拟实现
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, 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 arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  my_memmove(arr1 + 2, arr1, 20);
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", arr1[i]);
  }
  return 0;
}
//输出 1 2 1 2 3 4 5 8 9 10

7.3 memcmp库函数

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

7.3.1函数讲解

1.函数功能：比较从ptr1和ptr2指针开始的num个字节

2.和strncpy很相似，但是memcpy针对各种类型，strncpy只能比较char类型的。

3.返回值：ptr1的字符ASCII码值大于ptr2就返回大于0的值，等于返回0，小于则返回小于0的值

4.头文件：#include<string.h>

代码运用：

int main()
{
  int arr1[] = { 1,2,3,0,5 };//01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00 ...
  int arr2[] = { 1,2,3,4,0 };//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 ...
  int ret = memcmp(arr1, arr2, 13);
  //比较arr1和arr2的前13个字节的值
  printf("%d\n", ret);
  //arr1<arr1,输出-1
  return 0;
}

7.4 memset库函数

void * memset ( void * ptr, int value, size_t num );

7.4.1函数讲解

1.函数功能：把ptr指针指向的内容后的num个字节全部改为value值

2.头文件：#include<string.h>

代码运用：

554a83e8056a33ded27329d88a2a7d19.png

好了今天的内容到这儿就结束了，对友友们有帮助的话，不妨三连加关注支持一下，后期会持续更新C语言干货！

文章标签：
C语言
关键词：
C语言库
C语言函数
C语言内存
C语言内存函数
内存函数
诚酱
目录
相关文章
白子寰
|
19天前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
白子寰
30 3
ephemerals__
|
4天前
|
C语言
【c语言】动态内存管理
本文介绍了C语言中的动态内存管理，包括其必要性及相关的四个函数：`malloc`、``calloc``、`realloc`和`free`。`malloc`用于申请内存，`calloc`申请并初始化内存，`realloc`调整内存大小，`free`释放内存。文章还列举了常见的动态内存管理错误，如空指针解引用、越界访问、错误释放等，并提供了示例代码帮助理解。
ephemerals__
12 3
c的前世今生
|
10天前
|
程序员 C++ 容器
在 C++中，realloc 函数返回 NULL 时，需要手动释放原来的内存吗？
在 C++ 中，当 realloc 函数返回 NULL 时，表示内存重新分配失败，但原内存块仍然有效，因此需要手动释放原来的内存，以避免内存泄漏。
c的前世今生
46 4
阿客不是客
|
19天前
|
编译器 程序员 C语言
深入C语言：动态内存管理魔法
深入C语言：动态内存管理魔法
阿客不是客
16 1
ephemerals__
|
6天前
|
存储 C语言
【c语言】字符串函数和内存函数
本文介绍了C语言中常用的字符串函数和内存函数，包括`strlen`、`strcpy`、`strcat`、`strcmp`、`strstr`、`strncpy`、`strncat`、`strncmp`、`strtok`、`memcpy`、`memmove`和`memset`等函数的使用方法及模拟实现。文章详细讲解了每个函数的功能、参数、返回值，并提供了具体的代码示例，帮助读者更好地理解和掌握这些函数的应用。
ephemerals__
9 0
白子寰
|
15天前
|
C语言
保姆级教学 - C语言 之 动态内存管理
保姆级教学 - C语言 之 动态内存管理
白子寰
13 0
阿客不是客
|
19天前
|
存储 C语言
深入C语言内存：数据在内存中的存储
深入C语言内存：数据在内存中的存储
阿客不是客
26 0
禁默
|
19天前
|
C语言 C++
c语言回顾-内存操作函数
c语言回顾-内存操作函数
禁默
38 0
GuGuStudy
|
21天前
|
存储 C语言 C++
来不及哀悼了，接下来上场的是C语言内存函数memcpy，memmove，memset，memcmp
本文详细介绍了C语言中的四个内存操作函数：memcpy用于无重叠复制，memmove处理重叠内存，memset用于填充特定值，memcmp用于内存区域比较。通过实例展示了它们的用法和注意事项。
GuGuStudy
54 0
Hoshiᅟᅠ
|
3月前
|
存储 编译器 C语言
【C语言篇】数据在内存中的存储（超详细）
浮点数就采⽤下⾯的规则表⽰，即指数E的真实值加上127（或1023），再将有效数字M去掉整数部分的1。
Hoshiᅟᅠ
297 0