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

前言

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的使用

热门文章

最新文章

相关电子书