字符函数和字符串函数-阿里云开发者社区

前言

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

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

字符分类函数

C语言中有一系列的函数是专门做字符分类，也就是一个字符是属于什么类型的字符的。

这些函数的使用都需要包含一个头文件ctype.h

函数	如果它的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格‘ ’，换页‘\f’，换行‘\n’,回车‘\r’,制表符‘\t’,或者垂直制表符‘\v’

isdigit	十进制数字‘0’~‘9’字符
isxdigit	十六进制数字，包括所有十进制数字字符，小写字母a~f，大写字母A~F
islower	小写字母a~z

isupper	大写字母A~Z
isalpha	字母a~z或A~Z
isalnum	字母或者数字，a~z,A~Z,0~9

ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

函数介绍

strlen

size_t strlen( const char* str );

字符串以 ‘ \0 ’作为结束标志，strlen 函数返回的是再字符串中' \0 '前面出现的字符个数（不包括' \0 ' )。
参数指向的自负床必须以 ' \0 ' 结束。
注意函数的返回值为size_t，是无符号的。（易错）
strlen的使用需要包含头文件<string.h>

正常情况下的strlen的使用

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

返回结果为6。一共是六个字符。

在没有' \0 '的情况下

#include<stdio.h>
#include<string.h>
int main()
{
  char arr[] = { 'a','b','c' };
  int len = strlen(arr);
  printf("%d\n", len);
  return 0;
}

这里返回的就是一个随机值，因为没有' \0 '函数就会一直查找下去，直到遇到内存中的' \0 '才会停止，所以这里返回的是随机值。

（易错）strlen的返回值是无符号类型

#include<stdio.h>
#include<string.h>
int main()
{
  if (strlen("abc") - strlen("abcdef"))
  {
    printf(">\n");
  }
  else
  {
    printf("<\n");
  }
  return 0;
}

对strlen的返回类型不了解容易产生错误

由于strlen返回的是无符号类型，所以无符号类型的变量相减，得到的也是无符号类型，不会有负数

#include<stdio.h>
#include<string.h>
int main()
{
  if (strlen("abc") - strlen("abcdef"))
  {
    printf(">\n");
  }
  else
  {
    printf("<\n");
  }
  return 0;
}

学会strlen函数的模拟实现

学会strlen的模拟实现，可以让我们进一步地了解strlen 的内部结构，也能让我们掌握编写函数的能力。

当我们在编写函数的时候，都要想到3种方法，

1.计数器方法

2.指针-指针方法

3.递归方法

1.计数器方法

#include<stdio.h>
#include<string.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
  size_t count = 0;
  assert(str);
  while (*str != '\0')
  {
    count++;
    str++;
  }
  return count;
}
int main()
{
  char arr[] = "abcdef";
  size_t n = my_strlen(arr);
  printf("%u\n", n);
  return 0;
}

2.指针-指针方法

这里是指针-指针的方法，通过指针-指针的方法同样可以实现strlen函数。

但是这里要注意：指针-指针，我们要用高地址的指针来减低地址的指针，不然就会返回负数，无符号类型没有负数就会返回一个较大的数，这里容易产生错误

#include<stdio.h>
#include<string.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
  char* tmp = str;
  assert(str);
  while (*str != '\0')
  {
    str++;
  }
    return (str-tmp);
}
int main()
{
  char arr[] = "abcdef";
  size_t n = my_strlen(arr);
  printf("%u\n", n);
  return 0;
}

3.递归方法

递归就是直接或者间接地调用自身，把一个大型复杂的程序简化为规模较小的程序，将大量的程序用简单的程序来代替。

递归的主旨是将大事化小。

#include<stdio.h>
#include<string.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
  char count = 0;
  assert(str);
  if (*str == '\0')
    return 0;
  else
  {
    count++;
    str++;
  }
  return (count + my_strlen(str));
}
int main()
{
  char arr[] = "abcdef";
  size_t n = my_strlen(arr);
  printf("%u\n", n);
  return 0;
}

strcpy

字符串拷贝

把source空间的字符串传给destination空间里去。

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

源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷⻉到⽬标空间。
⽬标空间必须⾜够⼤，以确保能存放源字符串。
⽬标空间必须可修改。

正常情况下：

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

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

这里的arr数组并没有这个‘ \0 ’就会导致不相干的其他内容被拷贝到数组中，并且会有数组越界。

#include<stdio.h>
#include<string.h>
int main()
{
  char name[20] = "xxxxxxxx";
  char arr[] = { 'a','b','c' };
  strcpy(name, arr);
  printf("%s\n", name);
  return 0;
}

⽬标空间必须⾜够⼤，以确保能存放源字符串

如果空间不够大，将大内存的内容存放到这个空间，系统就会崩溃，还会产生越界访问。

#include<stdio.h>
#include<string.h>
int main()
{
  char name[3] = "";
  char arr[] = "abcdef";
  strcpy(name, arr);
  printf("%s\n", name);
  return 0;
}

⽬标空间必须可修改

这里的“abcdef”是常量字符串，不可以修改，强行修改的话，就会产生访问冲突。

#include<stdio.h>
#include<string.h>
int main()
{
  char* p = "abcdef";
  char arr[] = "abc";
  strcpy(p, arr);
  return 0;
}

strcpy的模拟实现

strcpy的实现原理就是，

将字符串一一对应地从source移到dest上去。

source，dest表示的是字符数组，C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。

由于是数组，source ,dest表示的都是数组名，就是首元素的地址，source表示的就是 ' a '.

我们要把source搬到dest上，*dest = *source,就是将第一个元素搬过去

然后就是source++,dest++,逐个地将每一个元素都搬运过去。

assert,断言，作用是防止传过来的参数是空指针

#include<stdio.h>
char* my_strcpy(char* dest, const char* source)
{
  assert(dest && source);
  char* start = dest;
  while (*source != '\0')
  {
    *dest = *source;
    dest++;
    source++;
  }
  *dest = *source;
  return start;  //strcpy的返回值是目标字符串，所以要将原来的dest的位置记下来
}
int main()
{
  char arr1[] = "abcdef";
  char arr2[20] = { 0 };
  my_strcpy(arr2, arr1);
  printf("%s\n", arr2);
  return 0;
}

strcat

字符串追加,当我们想要在原有的字符串后面追加字符串。

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

源字符串必须以 '\0' 结束。
⽬标字符串中也得有 \0 ，否则没办法知道追加从哪⾥开始。
⽬标空间必须有⾜够的⼤，能容纳下源字符串的内容。
⽬标空间必须可修改。

正常使用

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[20] = "hello ";
  strcat(arr1, "world");
  printf("%s\n", arr1);
  return 0;
}

strcat的模拟实现

strcat的实现原理，

就是现在dest找到' \0 '，然后从' \0 ' 开始将需要追加的字符串加到后面。

1.找到dest 的' \0 ' ，如果dest不是' \0 ' ，那就dest++;

2.直到找到我们的' \0 '.拷贝字符串。

#include<stdio.h>
char* my_strcat(char* dest, const char* source)
{
  assert(dest && source);
  char* start = dest;
    //1.找到dest的' \0 '
  while (*dest != '\0')
  {
    dest++;
  }
    //2.拷贝字符串
  while (*dest++ = *source++)
  {
    ;
  }
  return start;
}
int main()
{
  char arr1[20] = "hello ";
  strcat(arr1, "world");
  printf("%s\n", arr1);
  return 0;
}

strcmp

介绍

比较字符串

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

strcmp是一位一位通过ASCII码值进行比较的，如果是下面两个字符数组比较，就是

第一位一样，第二位一样

第三位arr2的q比arr1的c大，

那么arr2就比arr1大

#include<stdio.h>
int main()
{
  char arr1[20] = "abc";
  char arr2[] = "abcd";
  int num = strcmp(arr1, arr2);
  if (num < 0)
  {
    printf("<\n");
  }
  else if(num = 0)
  {
    printf("=\n");
  }
  else
  {
    printf(">\n");
  }
  return 0;
}

strcpy的模拟实现

strcpy的实现原理

通过ASCII码值进行一一比较，如果arr1,arr2的元素相同的话，就进行下一位的比较。

直到遇到不一样的元素进行比较，直接返回它们的差就可以了。

#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
  assert(str1 && str2);
  while (*str1 == *str2)
  {
    str1++;
    str2++;
  }
  return *str1 - *str2;
}
int main()
{
  char arr1[20] = "abc";
  char arr2[] = "abcd";
  int num = my_strcmp(arr1, arr2);
  if (num < 0)
  {
    printf("<\n");
  }
  else if(num = 0)
  {
    printf("=\n");
  }
  else
  {
    printf(">\n");
  }
  return 0;
}

长度受限函数

strncpy

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

拷⻉num个字符从源字符串到⽬标空间。
如果源字符串的⻓度⼩于num，则拷⻉完源字符串之后，在⽬标的后边追加0，直到num个。

strncpy的使用

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[20] = "abcdef";
  char arr2[] = "hello world";
  strncpy(arr1, arr2, 5);
  printf("%s\n", arr1);
  return 0;
}

源字符串的⻓度⼩于num

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[20] = "abcdef";
  char arr2[] = "bit";
  strncpy(arr1, arr2, 5);
  printf("%s\n", arr1);
  return 0;
}

strncpy的模拟实现

和strcpy不同的是，strncpy有长度的限制，原来的while循环，加上num--的限制条件。

如果源字符串的⻓度⼩于num，则拷⻉完源字符串之后，在⽬标的后边追加0，直到num个。

char* my_strncpy(char* dest, const char* source, size_t num)
{
  assert(dest && source);
  char* start = dest;
  while (num && *source)
  {
    num--;
    *dest++ = *source++;
  }
  while(num != 0)
  {
    *dest = '\0';
    dest++;
    num--;
  }
  return start;
}

strncat

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

将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加⼀个 \0 字符。
如果source 指向的字符串的⻓度⼩于num的时候，只会将字符串中到 \0 的内容追加到destination指向的字符串末尾。

strncat的使用

#include <stdio.h>
#include <string.h>
int main()
{
  char str1[20];
  char str2[20];
  strcpy(str1, "To be ");
  strcpy(str2, "or not to be");
  strncat(str1, str2, 6);
  printf("%s\n", str1);
  return 0;
}

strncmp

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

⽐较str1和str2的前num个字符，如果相等就继续往后⽐较，最多⽐较num个字⺟，如果提前发现不⼀样，就提前结束，⼤的字符所在的字符串⼤于另外⼀个。如果num个字符都相等，就是相等返回0.

strstr

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

函数返回字符串str2在字符串str1中第⼀次出现的位置
字符串的⽐较匹配不包含 \0 字符，以 \0 作为结束标志

strstr的使用

如果存在子串的内容，就会返回子串在字符串中的位置。

#include <stdio.h>
#include <string.h>
int main()
{
  char email[] = "zpw@bitejiuyeke.com";
  char substr[] = "bitejiuyeke";
  char* ret = strstr(email, substr);
  if (ret == NULL)
  {
  printf("子串不存在\n");
  }
  else
  {
  printf("%s\n", ret);
  }
  return 0;
}

strstr的模拟实现

char* my_strstr(const char* str1, const char* str2)
{
  char* cp = (char*)str1;
  char* s1, * s2;
  if (!*str2)
    return((char*)str1);
  while (*cp)
  {
    s1 = cp;
    s2 = (char*)str2;
    while (*s1 && *s2 && !(*s1 - *s2))
      s1++, s2++;
    if (!*s2)
      return(cp);
    cp++;
  }
  return(NULL);
}

strtok

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

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

如果ret为空指针，strtok就会返回空指针。

#include<stdio.h>
#include<string.h>
int main()
{
  const char* sep = "@.";
  char email[] = "zhangpenwei@bitejiuyeke.com";
  char* ret = strtok(email, sep);
  printf("%s\n", email);
  ret = strtok(NULL, sep);
  printf("%s\n", ret);
  ret = strtok(NULL, sep);
  printf("%s\n", ret);
  ret = strtok(NULL, sep);
  printf("%s\n", ret);
  return 0;
}

这样就可以不需要知道email有多少个分割符。

#include<stdio.h>
#include<string.h>
int main()
{
  const char* sep = "@.";
  char email[] = "zhangpenwei@bitejiuyeke.com";
  char* ret = NULL;
  for (ret = strtok(email, sep)； ret != NULL; ret = strtok(NULL, sep))
  {
    printf("%s\n", ret);
  }
    return 0;
}

strerror函数可以把参数部分错误码对应的错误信息的字符串地址返回来。
errno是C语言设置的一个全局的错误码存放的的变量。

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
  int i = 0;
  for (i = 0; i <= 10; i++)
  {
    printf("%s\n", strerror(i));
  }
  return 0;
}

strerror的使用

有了strerror，我们就可以明确地知道错误信息是什么。

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
  FILE* pf = fopen("test.txt", "r");
  if (pf == NULL)
  {
    printf("%s\n", strerror(errno));
    return 1;
  }
  else
    //
  return 0;
}

字符函数和字符串函数

前言

字符分类函数

函数介绍

strlen

正常情况下的strlen的使用

在没有' \0 '的情况下

（易错）strlen的返回值是无符号类型

学会strlen函数的模拟实现

strcpy

正常情况下：

⽬标空间必须⾜够⼤，以确保能存放源字符串

⽬标空间必须可修改

strcpy的模拟实现

strcat

正常使用

strcat的模拟实现

strcmp

介绍

strcpy的模拟实现

长度受限函数

strncpy

strncpy的使用

源字符串的⻓度⼩于num

strncpy的模拟实现

strncat

strncat的使用

strncmp

strstr

strstr的使用

strstr的模拟实现

strtok

strerror的使用

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

字符函数和字符串函数

前言

字符分类函数

函数介绍

strlen

正常情况下的strlen的使用

在没有' \0 '的情况下

（易错）strlen的返回值是无符号类型

学会strlen函数的模拟实现

strcpy

正常情况下：

⽬标空间必须⾜够⼤，以确保能存放源字符串

⽬标空间必须可修改

strcpy的模拟实现

strcat

正常使用

strcat的模拟实现

strcmp

介绍

strcpy的模拟实现

长度受限函数

strncpy

strncpy的使用

源字符串的⻓度⼩于num

strncpy的模拟实现

strncat

strncat的使用

strncmp

strstr

strstr的使用

strstr的模拟实现

strtok

strerror的使用

热门文章

最新文章

相关电子书