求字符串长度

strlen

函数介绍

strlen------size_t strlen(const char* str)

1.字符串以’\0’作为结束标志，strlen函数返回的是在字符串中’\0’前面出现的字符个数(不包含’\0’)。

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

3.注意函数返回值类型为size_t，是无符号的。

4.学会strlen函数的模拟实现

先来用一段代码来简单的写一个程序：

模拟实现

上面是利用已有的库函数strlen来实现功能，那我们也可以通过自已设计的一个类似于strlen的函数。这里展现三种方法：

1.计数器的方法

2.递归

3.指针-指针

首先展示计数器的方法：

#include<stdio.h>
int my_strlen(char* str)
{
  int count = 0;
  while (*str != '\0')
  {
  count++;
  str++;
  }
  return count;
}
int main()
{
  int len = my_strlen("helloworld");
  printf("len=%d\n", len);
  return 0;
}

再来展示递归方法：

#include<stdio.h>
#include<string.h>
int my_strlen(char* str)
{
  if (*str != '\0')
  return 1 + my_strlen(str + 1);
  else
  return 0;
}
int main()
{
  char arr[] = "helloworld";
  int len = my_strlen(arr);
  printf("len=%d\n", len);
  return 0;
}

再来展示指针-指针的方法：

#include<stdio.h>
int my_strlen(char* str)
{
  int tmp = str;
  while (*str != '\0')
  {
  str++;
  }
  return str - tmp;
}
int main()
{
  char arr[] = "hello world";
  int len = my_strlen(arr);
  printf("len=%d\n", len);
  return 0;
}

上面三种方法就是模拟实现strlen函数

下面来看一段代码：

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

请问上述代码打印的是hehe还是haha呢？在说出答案之前，我们需要了解到strlen函数返回的是无符号数，两个无符号数相减得到的依然是无符号数，虽然上述代码计算得出的为（3-6=-3），结果为-3但是别忘了，这个值是一个无符号数，-3的补码在内存中会被当作无符号数来看待，所以最终得到的是一个正数。所以答案打印出来的是hehe🙂。

这里要注意的是strlen函数返回的是无符号数。size_t strlen(const char* string ),size_t相当于unsigned int即无符号数。

而我们刚刚自己实现的一个my_strlen函数，即int my_strlen(const char* str)返回的是一个int。

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

strcpy

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

函数介绍

1.源字符必须以’\0’结束。

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

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

4.目标空间必须可变。

5.学会该函数的模拟实现

举个例子：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[] = "abcdefghi";
  char arr2[] = "world";
  strcpy(arr1, arr2);
  printf("%s", arr1);
  return 0;
}

模拟实现

下面我们来模拟实现strcpy函数：

#include<stdio.h>
#include<string.h>
#include<assert.h>
void my_strcpy(char* dest, char* src)
{
  assert(dest != NULL);
  assert(src != NULL);
  while (*src != '\0')
  {
  *dest = *src;
  dest++;
  src++;
  }
  *dest = *src;
}
int main()
{
  char arr1[] = "abcdef";
  char arr2[] = "world";
  my_strcpy(arr1, arr2);
  printf("%s\n", arr1);
  return 0;
}

对上述代码进行优化，即：

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcpy(char* dest,const char* src)
{
  assert(dest != NULL);
  assert(src != NULL);
  char* ret = dest;
  //拷贝src指向的字符串到dest指向的空间，包含'\0'
  while (*dest++ = *src++)
  {
  ;
  }
  //返回目的空间的起始地址
  return ret;
}
int main()
{
  char arr1[] = "abcdef";
  char arr2[] = "world";
  my_strcpy(arr1, arr2);
  printf("%s\n", arr1);
  return 0;
}

这才是真正的满分代码。

strcat

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

1.源字符串必须以’\0’最为结束。

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

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

4.学会该函数的模拟实现

5.目标字符串中必须也有’\0’，否则要从哪里开始追加就不清楚了。

来看一个典型错误：

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

这样做会造成越界访问。

所以说我们的目的地必须足够强大，来存放追加的数据。

这里有一个疑问，当我们进行字符串追加时，有没有把'\0'追加过去呢？这里我们可以通过代码实践一下就可以了。请看：

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

根据调试结果我们可以发现strcat函数在进行字符串追加时也会把'\0'追加到目的地。

注意当strcat函数自己给自己进行追加时，程序会崩溃。

模拟实现

下面我们自己来写一个函数来实现strcat函数的功能。请看：

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
  char* ret = dest;
  assert(dest && src);
  //找到目的字符串中的'\0'
  while (*dest != '\0')
  {
  dest++;
  }
  //追加
  while (*dest++ = *src++)
  {
  ;
  }
  return ret;
}
int main()
{
  char arr1[30] = "hello\0xxxxxxxx";
  char arr2[] = "world";
  my_strcat(arr1, arr2);
  printf("%s\n", arr1);
  return 0;
}

strcmp

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

标准规定：

1.第一个字符串大于第二个字符串，则返回大于0的数字

2.第一个字符串等于第二个字符串，则返回0

3.第一个字符串小于第二个字符串，则返回小于0的数字

举个例子：

#include<stdio.h>
#include<string.h>
int main()
{
  char* p1 = "qbcdef";
  char* p2 = "asjix";
  int ret = (strcmp(p1, p2));
  printf("ret=%d\n", ret);
  return 0;
}

在代码运行起来后，发现在VS编译下，strcmp函数的返回值只有1、-1、0。前提这是在VS环境下。但是不同的编译器下strcmp函数返回的值是不同的。

#include<stdio.h>
#include<string.h>
int main()
{
  char* p1 = "qbcdef";
  char* p2 = "asjix";
  if (strcmp(p1, p2) > 0)
  {
  printf("p1>p2\0");
  }
  else if (strcmp(p1, p2) < 0)
  {
  printf("p1<p2");
  }
  else
  printf("p1==p2");
  return 0;
}

再次强调，一定要注意strcmp函数的返回值，不同的编译环境下返回值是可能是不同的。

模拟实现

#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++;
  }
  /*if (*str1 > *str2)
  return 1;
  else
  return -1;*/
  return(*str1 - *str2);//这种方式也可以
}
int main()
{
  char* p1 = "abcdefg";
  char* p2 = "abczgujj";
  int ret = my_strcmp(p1, p2);
  printf("ret=%d\n", ret);
  return 0;
}

长度受限制的字符串函数介绍

strncpy

strncpy------

char *strncpy(char *strDest,const char *strSource,size_t count)。

拷贝num个字符从源字符串到目标空间

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

其中count单位是字节。

那这里有没有把\0拷贝过去呢？我们一试便知：

可以看出strncpy函数并没有把\0拷贝过去。

再来看一段代码及调试过程：

注意：通过观察可以发现当指定的个数比源的字符串多时，在这里依然会拷贝6个，不够时会拿\0来补充。

模拟实现

#include<stdio.h>
#include<assert.h>
#include<string.h>
char* my_strncpy(char* dest, const char* src, size_t n)
{
  assert(dest && src);
  char* ret = dest;
  while (n&&(*dest++ = *src++))
  {
  n--;
  }
  if (n)
  {
  while (n--)
  {
    *dest++ = '\0';
  }
  }
  return ret;
}
int main()
{
  char arr1[] = "hello world";
  char arr2[] = "i am a student";
  printf("%s\n", my_strncpy(arr2, arr1, strlen(arr1)));
  return 0;
}

上述模拟实现主要分两种情况：

其一：当字符串源头的长度大于等于copy的数目时，根据字符数目照常复制即可。

其二：当字符串源头的长度小于copy的数目时，剩下几个copy数目，就在字符串目的地后面加几个\0。

strncat

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

我们依然验证一下在追加完源字符串后会不会补充\0。请看：

可以看出strncat函数会主动放一个\0进去。

再来看一段代码：

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

通过调试结果可以发现如果个数比我们要追加的这个源字符串长时，我们补充完一个\0之后就啥也不管了。我们可以对比一下strncpy函数，对于strncpy函数而言，如果个数比要拷贝的字符串长时，我们会补齐那么多个，但是strncat函数可不会管这么多个。

对于strncat函数，无论追加多少个，它最后都会在后面补一个\0。

strncmp

strncmp------int strncmp(const char *string1, const char *string2,size_t count)。

出现到另一个字符不一样或者一个字符串结束或者num个字符全部比较完。

请看代码举例：

#include<stdio.h>
#include<string.h>
int main()
{
  const char* p1 = "abczef";
  const char* p2 = "abctefh";
  int ret = strncmp(p1, p2, 4);
  printf("ret=%d\n", ret);
  return 0;
}

字符串查找

strstr

strstr------字符串查找

代码举例：

#include<stdio.h>
#include<string.h>
int main()
{
  char* p1 = "abcdef";
  char* p2 = "def";
  char* ret = strstr(p1, p2);
  if (ret == NULL)
  printf("子串不存在\n");
  else
  printf("%s\n", ret);
  return 0;
}

模拟实现

//strstr---查找字符串
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strstr(const char* p1,const char* p2)
{
  assert(p1 && p2);
  char* s1 = NULL;
  char* s2 = NULL;
  char* cur = (char*)p1;
  if (*p2 == '\0')
  {
  return (char*)p1;
  }
  while (*cur)
  {
  s1 = cur;
  s2 = (char*)p2;
  while (*s1 && *s2 && (*s1 == *s2))
  {
    s1++, s2++;
  }
  if (*s2 == '\0')
  {
    return cur;//找到子串
  }
  if (*s1 == '\0')
  {
    return NULL;
  }
  cur++;
  }
  return NULL;//找不到子串
}
int main()
{
  char* p1 = "abcdef";
  char* p2 = "def";
  char* ret = my_strstr(p1, p2);
  if (ret == NULL)
  printf("子串不存在\n");
  else
  printf("%s\n", ret);
  return 0;
}

strtok

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

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

请看举例：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr[] = "abcd@efg.hijk";
  char* p = "@.";
  char buf[1024] = { 0 }; 
  strcpy(buf, arr);
  char* ret=strtok(arr,p);
  printf("%s\n", ret);
  ret = strtok(NULL, p);
  printf("%s\n", ret);
  ret = strtok(NULL, p);
  printf("%s\n", ret);
  return 0;
}

对上面代码进行改进：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr[] = "abcd@efg.hijk";
  char* p = "@.";
  char buf[1024] = { 0 };
  strcpy(buf, arr);
  char* ret = NULL;
  for (ret = strtok(buf, p); ret != NULL; ret = strtok(NULL, p))
  {
  printf("%s\n", ret);
  }
  return 0;
}

strtok函数在调用时会记住上次找到分隔符的位置，下次再次调用strtok函数时它会从记住的那个位置继续先后找。所以strtok函数本身就有记忆的一些功能，它会把一些执行过程中的一些值记录下来，下次调用它的时候就可以继续使用刚刚记录下来的值。

那strtok函数是怎么记录这些值的呢？这个函数内部就应该创建静态变量，当一个函数内部创建一些静态变量之后，出来该函数时不会销毁，下次进去的时候它依然会存在。

错误信息函数

strerror

strerror------char * strerror( int errnum)

返回错误码所对应的错误信息

#include<stdio.h>
#include<string.h>
int main()
{
  char* str1 = strerror(1);
  printf("%s\n", str1);
  char* str2 = strerror(2);
  printf("%s\n", str2);
  char* str3 = strerror(3);
  printf("%s\n", str3);
  return 0;
}

下面是运行结果：

1------Operation not permitted

2------No such file or directory

3------No such process

这里的1、2、3是错误码，每一个错误码对应着一个错误信息，就是我们的代码在执行过程中，发现哪个地方出问题了，那怎么办呢？这个时候，就制造一些错误码，在我们的程序之间流转，程序之间流转的错误码是没有问题的，但是用户去看的时候是不知道这里的1、2、3是什么意思的，那我们肯定是希望把这里的1、2、3这样的错误码转换成错误信息。上面的Operation not permitted、No such file or directory、No such process是错误信息描述。而strerror函数就是用来把我们的错误码转换成错误信息，然后返回它的地址，这就是strerror函数的基本作用。它可以把错误码翻译成所对应的错误信息。

另外在刚刚的代码中的1、2、3是我们放进去的，但是真实在代码中不是这样写的，而应该是这样的：

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
  char* str = strerror(errno);
  printf("%s\n", str);
  return 0;
}

这里的errno是一个全局的错误码的变量，当C语言的库函数在执行过程中，发生了错误，就会把对应的错误码赋值到errno中。

举例：

#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));
  }
  else
  {
  printf("open file success\n");
  }
  return 0;
}

字符分类函数

字符分类函数头文件为ctype.h

函数---------------如果它的参数符合下列条件就返回真
iscntrl-------------任意控制字符
isspace-----------空白字符：空格’ ‘，换页’lf’，换行’\n’,回车’\r’,制表符’\t’或者垂直制表符’\v’。
isdigit-------------十进制数字0到9
isxdigit-----------十六进制数字，包括所有十进制数字，小写字母a-f，大写字母A到F。
islower-----------小写字母a到z
isupper----------大写字母A到Z
isalnum----------字母或者数字，a到z，A到Z，0到9
ispunct-----------标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph----------任何图形字符
isprint------------任何可打印字符

字符转换函数

tolower和toupwer

tolower------int tolower (int c)

toupper------int toupper(int c)

举个例子：

#include<stdio.h>
#include<ctype.h>
int main()
{
  char ch1 = tolower('E');
  char ch2 = tolower('e');
  char ch3 = toupper('f');
  char ch4 = toupper('F');
  putchar(ch1);//e
  putchar(ch2);//e
  putchar(ch3);//F
  putchar(ch4);//F
  return 0;
}

举个例子：

#include<stdio.h>
#include<ctype.h>
int main()
{
  int i = 0;
  char arr[] = "I AM A STUDENT";
  while (arr[i])
  {
  if (isupper(arr[i]))
  {
    arr[i] = tolower(arr[i]);
  }
  i++;
  }
  printf("%s\n", arr);
  return 0;
}

本文至此结束，感谢！！！

C语言之详解字符操作函数

求字符串长度

strlen

模拟实现

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

strcpy

模拟实现

strcat

模拟实现

strcmp

模拟实现

长度受限制的字符串函数介绍

strncpy

模拟实现

strncat

strncmp

字符串查找

strstr

模拟实现

strtok

错误信息函数

strerror

字符分类函数

字符分类函数头文件为ctype.h

字符转换函数

tolower和toupwer

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C语言之详解字符操作函数

求字符串长度

strlen

模拟实现

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

strcpy

模拟实现

strcat

模拟实现

strcmp

模拟实现

长度受限制的字符串函数介绍

strncpy

模拟实现

strncat

strncmp

字符串查找

strstr

模拟实现

strtok

错误信息函数

strerror

字符分类函数

字符分类函数头文件为ctype.h

字符转换函数

tolower和toupwer

热门文章

最新文章

相关课程

相关电子书

相关实验场景