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

字符函数和字符串函数

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

 目录

求字符串长度

strlen

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

strcpy

strcat

strcmp

长度受限制的字符串函数

strncpy

strncat

strncmp

字符串查找

strstr

strtok

错误信息报告

strerror

内存操作函数

memcpy

memmove

memset

memcmp

本篇博客将介绍处理字符和字符串的库函数的使用和注意事项

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

字符串常量适用于那些对它不做修改的字符串函数.

求字符串长度

strlen

size_t strlen ( const char * str );

image.gif

    • 字符串已经 '\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;
}

    image.gif

    模拟实现strlen

    #include<stdio.h>
#include<string.h>
#include<assert.h>
size_t my_strlen(const char *string)
{
  assert(string != NULL);
  int count = 0;
  while ((*string++) != '\0')
    count++;
  return count;
}
void main()
{
  char str[] = { 'a', 'b', 'c', 'd', '\0' };
  const char *p = str;
  int res = my_strlen(p);
  printf("%d\n", res);
}

    image.gif

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

    strcpy

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

    image.gif

      • 源字符串必须以 '\0' 结束。
      • 会将源字符串中的 '\0' 拷贝到目标空间。
      • 目标空间必须足够大，以确保能存放源字符串。
      • 目标空间必须可变。

      使用strcpy函数

      #include<stdio.h>
#include<string.h>
void main()
{
  char str[100] = "Hello";
  const char* str1 = "Bit";
  puts(strcpy(str, str1));
}

      image.gif

      模拟实现strcpy函数

      #include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcpy(char *strDestination, const char *strSource)
{
  assert(strDestination != NULL && strSource != NULL);
  char *pDest = strDestination;
  const char *pSce = strSource;
  while (*pSce != '\0')
    *pDest++ = *pSce++;
  *pDest = *pSce;
  return strDestination;
}
void main()
{
  char str1[] = "abcdef";
  const char *str2 = "asdf";
  my_strcpy(str1, str2);
  printf("%s\n", str1);
}

      image.gif

      strcat

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

      image.gif

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

        使用strcat函数

        #include<stdio.h>
#include<string.h>
void main()
{
  char str[100] = "Hello";
  const char* str1 = "Bit";
  puts(strcat(str, str1));
}

        image.gif

        模拟实现strcat函数

        #include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcat(char *strDestination, const char *strSource)
{
  assert(strDestination != NULL && strSource != NULL);
  char *pDest = strDestination;
  const char *pSce = strSource;
  while (*pDest != '\0')
    pDest++;
  while (*pSce != '\0')
    *pDest++ = *pSce++;
  *pDest = *pSce;
  return strDestination;
}
void main()
{
  char str1[100] = "asdf";
  const char *str2 = "hsbh";
  my_strcat(str1, str2);
  printf("%s\n", str1);
}

        image.gif

        在使用过程中，我们发现在连接自己时，程序出现了bug，什么原因呢？

              我们在调用strcat函数时，传入的字符串通过指针访问字符串的地址，当我们用第一个字符替换末尾的"\0"后，原字符串已无"\0"，则会造成死循环。

        strcmp

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

        image.gif

          • 第一个字符串大于第二个字符串，则返回大于0的数字
          • 第一个字符串等于第二个字符串，则返回0
          • 第一个字符串小于第二个字符串，则返回小于0的数字

          使用strcmp函数

          #include<stdio.h>
#include<string.h>
void main()
{
  const char* str = "Hello";
  const char* str1 = "Bit";
  printf("%d\n",strcmp(str, str1));
}

          image.gif

          模拟实现strcmp函数

          #include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strcmp(const char *string1, const char *string2)
{
  assert(string1!=NULL && string2!=NULL);
  while ((*string1 != '\0') && (*string2 != '\0'))
  {
    if (*string1 < *string2)
    {
      return -1;
    }
    else if (*string1>*string2)
    {
      return 1;
    }
    else
    {
      ++string1;
      ++string2;
    }
  }
  if (*string1 < *string2)
  {
    return -1;
  }
  else if (*string1>*string2)
  {
    return 1;
  }
  return 0;
}
void main()
{
  const char* str1 = "asdf";
  const char* str2 = "djshfs";
  int res = my_strcmp(str1, str2);
  if (res = 1)
    printf("str1 > str2\n");
  else if (res = 0)
    printf("str1 = str2\n");
  else
    printf("str1 < str2\n");
}

          image.gif

          长度受限制的字符串函数

          strncpy

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

          image.gif

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

            使用strncpy函数

            #include<stdio.h>
#include<string.h>
void main()
{
  char str[100] = "Hello";
  const char* str1 = "Bit";
  puts(strncpy(str, str1,2));
}

            image.gif

            模拟实现strncpy函数

            #include<stdio.h>
#include <string.h>
#include <assert.h>
char* my_strncpy(char * destination, const char * source, size_t num)
{
  assert(destination != NULL && source != NULL);
  char *pDest = destination;
  const char *pSce = source;
  while (num--)
    *pDest++ = *pSce++;
  if (strlen(destination) < num)
    *pDest = '\0';
  return destination;
}
void main()
{
  char arr1[50] = "bit";
  char arr2[] = "pouces";
  printf("%s\n", my_strncpy(arr1, arr2, 4));
}

            image.gif

            strncat

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

            image.gif

            使用strncat函数

            #include<stdio.h>
#include<string.h>
void main()
{
  char str[100] = "Hello";
  const char* str1 = "Bit";
  puts(strncat(str, str1,2));
}

            image.gif

            模拟实现strncat函数

            #include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strncat(char * destination, const char * source, size_t num)
{
  assert(destination != NULL && source != NULL);
  char *pDest = destination;
  const char *pSce = source;
  while (*pDest != '\0')
    pDest++;
  while (num--)
    *pDest++ = *pSce++;
  return destination;
}
void main()
{
  char str1[100] = "asdf";
  const char *str2 = "hsbh";
  printf("%s\n", my_strncat(str1, str2,2));
}

            image.gif

            strncmp

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

            image.gif

            使用strncmp函数

            #include <stdio.h>
#include <string.h>
int main ()
{
  char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
  int n;
  puts ("Looking for R2 astromech droids...");
  for (n=0 ; n<3 ; n++)
  if (strncmp (str[n],"R2xx",2) == 0)
 {
    printf ("found %s\n",str[n]);
 }
  return 0;
}

            image.gif

            模拟实现strncmp函数

            #include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strncmp(const char *str1, const char *str2,size_t num)
{
  assert(str1 != NULL && str2 != NULL);
  while (num > 0)
  {
    if (*str1 < *str2)
    {
      return -1;
    }
    else if (*str1>*str2)
    {
      return 1;
    }
    else
    {
      ++str1;
      ++str2;
    }
    num--;
  }
  return 0;
}
void main()
{
  const char* str1 = "asdf";
  const char* str2 = "djshfs";
  int res = my_strncmp(str1, str2,3);
  if (res = 1)
    printf("str1 > str2\n");
  else if (res = 0)
    printf("str1 = str2\n");
  else
    printf("str1 < str2\n");
}

            image.gif

            字符串查找

            strstr

            char *strstr( const char *string, const char *strCharSet );

            image.gif

            使用strstr函数

            #include<stdio.h>
#include<string.h>
int main()
{
  char str[] = "This is a simple string";
  char * pch;
  pch = strstr(str, "simple");
  strncpy(pch, "sample", 6);
  puts(pch);
  return 0;
}

            image.gif

            这个函数找到字串后会从找到的字串一直输出直到找到’\0’为止

            模拟实现strstr函数

            #include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strstr(const char *string, const char *strCharSet)
{
  assert(string && strCharSet);
  const char *str1 = NULL;
  const char *str2 = NULL;
  const char *str3 = string;
  if (*strCharSet == '\0')
    return (char*)string;
  while (*str3 != '\0')
  {
    str1 = str3;
    str2 = strCharSet;
    while (*str1 == *str2)
    {
      str1++;
      str2++;
    }
    if (*str2 == '\0')
      return (char*)str3;
    str3++;
  }
  return NULL;
}
void main()
{
  char str[] = "This is a simple string";
  char* pch;
  pch = my_strstr(str, "simple");
  puts(pch);
}

            image.gif

            strtok

            char *strtok( char *strToken, const char *strDelimit );

            image.gif

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

              使用strtok函数

              int main ()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \"%s\" into tokens:\n",str);
  pch = strtok (str," ,.-");
  while (pch != NULL)
 {
    printf ("%s\n",pch);
    pch = strtok (NULL, " ,.-");
 }
  return 0;
}

              image.gif

              #include<stdio.h>
#include<string.h>
int main()
{
  char *p = "zhangpengwei@bitedu.tech";
  const char* sep = ".@";
  char arr[30];
  char *str = NULL;
  strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
  for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
  {
    printf("%s\n", str);
  }
}

              image.gif

              错误信息报告

              strerror

              char *strerror( int errnum );

              image.gif

                • 返回错误码，所对应的错误信息。

                使用strerror函数

                #include<stdio.h>
#include<string.h>
#include <errno.h>
int main()
{
  FILE * pFile;
  pFile = fopen("unexist.ent", "r");
  if (pFile == NULL)
    printf("Error opening file unexist.ent: %s\n", strerror(errno));
  //errno: Last error number 
  return 0;
}

                image.gif

                内存操作函数

                memcpy

                void *memcpy( void *dest, const void *src, size_t count );

                image.gif

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

                  使用memcpy函数

                  #include<stdio.h>
#include<string.h>
struct {
  char name[40];
  int age;
} person, person_copy;
int main()
{
  char myname[] = "Pierre de Fermat";
  /* using memcpy to copy string: */
  memcpy(person.name, myname, strlen(myname) + 1);
  person.age = 46;
  /* using memcpy to copy structure: */
  memcpy(&person_copy, &person, sizeof(person));
  printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
  return 0;
}

                  image.gif

                  模拟实现memcpy函数

                  #include<stdio.h>
#include<assert.h>
#include<string.h>
void* my_memcpy(void * dst, const void * src, size_t count)
{
  void * ret = dst;
  assert(dst);
  assert(src);
  /*
  * copy from lower addresses to higher addresses
  */
  while (count--) {
    *(char *)dst = *(char *)src;
    dst = (char *)dst + 1;
    src = (char *)src + 1;
  }
  return(ret);
}
struct {
  char name[40];
  int age;
} person, person_copy;
int main()
{
  char myname[] = "Pierre de Fermat";
  /* using memcpy to copy string: */
  my_memcpy(person.name, myname, strlen(myname) + 1);
  person.age = 46;
  /* using memcpy to copy structure: */
  my_memcpy(&person_copy, &person, sizeof(person));
  printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
  return 0;
}

                  image.gif

                  memmove

                  void *memmove( void *dest, const void *src, size_t count );

                  image.gif

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

                    使用memmove函数

                    #include<stdio.h>
#include<string.h>
int main()
{
  char str[] = "memmove can be very useful......";
  memmove(str + 20, str + 15, 11);
  puts(str + 20);
  return 0;
}

                    image.gif

                    模拟实现memmove函数

                    #include<stdio.h>
#include<string.h>
void * memmove(void * dst, const void * src, size_t count)
{
  void * ret = dst;
  if (dst <= src || (char *)dst >= ((char *)src + count)) {
    /*
    * Non-Overlapping Buffers
    * copy from lower addresses to higher addresses
    */
    while (count--) {
      *(char *)dst = *(char *)src;
      dst = (char *)dst + 1;
      src = (char *)src + 1;
    }
  }
  else {
    /*
    * Overlapping Buffers
    * copy from higher addresses to lower addresses
    */
    dst = (char *)dst + count - 1;
    src = (char *)src + count - 1;
    while (count--) {
      *(char *)dst = *(char *)src;
      dst = (char *)dst - 1;
      src = (char *)src - 1;
    }
  }
  return(ret);
}
int main()
{
  char str[] = "memmove can be very useful......";
  memmove(str + 20, str + 15, 11);
  puts(str + 20);
  return 0;
}

                    image.gif

                    memset

                    void *memset( void *dest, int c, size_t count );

                    image.gif

                    使用memset函数

                    #include<stdio.h>
#include<string.h>
int main(){
  char a[4];
  memset(a, '1', 4);
  for (int i = 0; i<4; i++){
    printf("%c\n", a[i]);
  }
  return 0;
}

                    image.gif

                    memcmp

                    int memcmp( const void *buf1, const void *buf2, size_t count );

                    image.gif

                      • 比较从buf1和buf2指针开始的num个字节

                      使用memcmp函数

                      #include<stdio.h>
#include<string.h>
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;
}

                      image.gif


                      文章标签：
                      C语言
                      游客lswgwdh6xc356
                      目录
                      相关文章
                      sunrr
                      |
                      12月前
                      |
                      人工智能 算法 数据管理
                      工业机理模型
                      工业机理模型
                      sunrr
                      506 2
                      Svan.
                      |
                      11月前
                      |
                      计算机视觉 Python
                      基于Dlib的人脸识别客户端（UI界面）
                      基于Dlib的人脸识别客户端（UI界面）
                      Svan.
                      359 2
                      土木林森
                      |
                      XML JSON 前端开发
                      【Web前端揭秘】XML与JSON：数据界的双雄对决，你的选择将如何改写Web世界的未来？
                      【8月更文挑战第26天】本文深入探讨了XML和JSON这两种广泛使用的数据交换格式在Web前端开发中的应用。XML采用自定义标签描述数据结构，适用于复杂层次数据的表示，而JSON则以键值对形式呈现数据，更为轻量且易解析。通过对两种格式的示例代码、结构特点及应用场景的分析，本文旨在帮助读者更好地理解它们的差异，并根据实际需求选择最合适的数据交换格式。
                      土木林森
                      191 1
                      长梦
                      |
                      9月前
                      |
                      数据可视化 数据挖掘 开发者
                      Pandas数据可视化：matplotlib集成(df)
                      Pandas 是 Python 中强大的数据分析库，Matplotlib 是常用的绘图工具。两者结合可方便地进行数据可视化，帮助理解数据特征和趋势。本文从基础介绍如何在 Pandas 中集成 Matplotlib 绘制图表，如折线图、柱状图等，并深入探讨常见问题及解决方案，包括图表显示不完整、乱码、比例不合适、多子图布局混乱、动态更新图表等问题，提供实用技巧和代码示例。掌握这些方法后，你将能更高效地处理数据可视化任务。
                      长梦
                      291 9
                      龙大吉
                      |
                      10月前
                      |
                      存储 缓存 算法
                      C语言在实现高效算法方面的特点与优势，包括高效性、灵活性、可移植性和底层访问能力
                      本文探讨了C语言在实现高效算法方面的特点与优势，包括高效性、灵活性、可移植性和底层访问能力。文章还分析了数据结构的选择与优化、算法设计的优化策略、内存管理和代码优化技巧，并通过实际案例展示了C语言在排序和图遍历算法中的高效实现。
                      龙大吉
                      264 2
                      土木林森
                      |
                      10月前
                      |
                      程序员 C语言
                      C语言中的指针既强大又具挑战性，它像一把钥匙，开启程序世界的隐秘之门
                      C语言中的指针既强大又具挑战性，它像一把钥匙，开启程序世界的隐秘之门。本文深入探讨了指针的基本概念、声明方式、动态内存分配、函数参数传递、指针运算及与数组和函数的关系，强调了正确使用指针的重要性，并鼓励读者通过实践掌握这一关键技能。
                      土木林森
                      194 1
                      楠竹11
                      |
                      10月前
                      |
                      算法 测试技术 量子技术
                      时隔5年，谷歌再创量子霸权里程碑！RCS算法让电路体积增加一倍
                      谷歌在量子计算领域取得重大突破，通过随机电路采样（RCS）算法，成功将量子电路体积翻倍，实现了量子霸权的里程碑。这一成果发表于《自然》杂志，展示了量子动力学与噪声交互作用下的相变现象，推动了量子计算在密码学、材料科学等领域的应用潜力。尽管如此，量子计算仍面临错误率高、可扩展性差等挑战。
                      楠竹11
                      199 3
                      bruce_xiaowei
                      |
                      11月前
                      |
                      数据采集 JSON 前端开发
                      JavaScript逆向爬虫实战分析
                      JavaScript逆向爬虫实战分析
                      bruce_xiaowei
                      174 4
                      阿里云基础设施.
                      |
                      12月前
                      |
                      供应链 安全 Cloud Native
                      阿里云容器服务助力企业构建云原生软件供应链安全
                      针对软件供应链的攻击事件在以每年三位数的速度激增，其中三方或开源软件已经成为攻击者关注的重要目标，其攻击方式和技术也在不断演进。通过供应链的传播，一个底层软件包的漏洞的影响范围可以波及世界。企业亟需更加标准和完善的供应链风险洞察和防护机制。本文将结合最佳实践的形式，面向容器应用完整的生命周期展示如何基于容器服务ACK/ACR/ASM助力企业构建云原生软件供应链安全。
                      阿里云基础设施.
                      452 10
                      Java开发者
                      |
                      12月前
                      |
                      Java
                      Java强制类型转换需要注意的点
                      在 Java 中，强制类型转换（显式类型转换）用于将一种数据类型转换为另一种。然而，这一过程需谨慎处理以避免以下问题：数据丢失，尤其是在从大范围类型转换到小范围类型时；类型不兼容，如 `String` 无法直接转换为 `int`；对象类型转换时应确认实际类型与目标类型兼容，可借助 `instanceof` 运算符；处理基本类型与包装类之间的自动装箱和拆箱时需注意 `null` 值；浮点数转整数时会截断小数部分；字符转整数则得到 Unicode 值。充分理解这些注意事项有助于避免运行时错误和数据不一致。
                      Java开发者
                      272 16