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

求字符串长度

strlen

strlen介绍

size_t strlen(const char* str);

获取字符串长度：C 字符串的长度由终止 null 字符决定：C 字符串的长度与字符串开头和终止 null 字符之间的字符数（不包括终止 null 字符本身）一样长。

头文件：#include<string.h>
参数：字符串
返回值：字符串的长度

注意事项：

1.strlen 是求字符串长度的，求出的长度不可以为负，所以返回类型为size_t，是无符号的（size_t可以看作是umsigned int 类型，但俩者不同之处在于俩个size_t的返回值相减得到的值任然是size_t）

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

3.参数指向的字符串必须要以’\0’为结束标准

实际使用：

//strlen的实际使用
#include<stdio.h>
#include<string.h>
int main(void)
{
  
  char arr[] = "hello!";
  int ret1 = (int)strlen(arr);
  printf("%d\n", ret1);
    
  printf("%d\n", (int)strlen("future"));
  return 0;
}

运行截图：
模拟实现：
方法1：使用计数器模拟实现strlen

#include<stdio.h>
#include<assert.h>
//使用计数器模拟实现strlen
size_t my_strlen(const char* str)
{
  //断言：字符串不能为空
  assert(str);
  int count = 0;
  while (*str)
  {
    count++;
    str++;
  }
  return count;
}
int main(void)
{
  char arr[] = "Hello China!";
  //接收字符串长度
  int ret = (int)my_strlen(arr);
  //打印
  printf("%d ",ret);
  return 0;
}

方法2：使用递归模拟实现strlen

//使用递归模拟实现strlen
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
  //断言：字符串不能为空
  assert(str);
  if (*str=='\0')
  {
    return 0;
  }
  else
  {
    return 1 + my_strlen(str+1);
  }
}
int main(void)
{
  char arr[] = "Hello beijing!";
  //接收字符串长度
  int ret = (int)my_strlen(arr);
  //打印
  printf("%d", ret);
  return 0;
}

方法3：使用指针与指针之间的运算模拟实现strlen

#define  _CRT_SECURE_NO_WARNINGS 1  
//使用指针与指针之间的运算模拟实现strlen
#include<stdio.h>
size_t my_strlen(const char* str)
{
  char* s = str;
  while (*s !='\0')
  {
    s++;
  }
    return s - str;
}
int main(void)
{
  char arr[] = "Hello shandong！";
  //接收返回值
  int ret = (int)my_strlen(arr);
  //打印
  printf("%d", ret);
  return 0;
}

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

strcpy

strcpy介绍

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

拷贝字符串：将源指向的 C 字符串复制到目标指向的数组中，包括终止 null 字符（并在该点停止）

头文件：#include<string.h>
参数destination：指向要复制内容的目标数组的指针
参数source：要复制的 C 字符串
返回值：返回目标数组起始的指针

注意事项：

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

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

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

4.目标空间可变

实际使用：

//strcpy的实际使用
#include<stdio.h>
#include<string.h>
int main(void)
{
  char destination[20] = { 0 };
  char source[] = "Hello shanxi!";
  //拷贝字符串
  strcpy(destination,source);
  //打印destination
  printf("%s\n",destination);
  return 0;
}

运行截图：

模拟实现

//模拟实现strcpy
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
  //断言
  assert(dest && src);
  //定义一个返回值
  char* ret = dest;
  while (*src != '\0')
  {
    *dest++ = *src++;
  }
  return ret;
}
int main(void)
{
  //destination数组
  char dest[30] = { 0 };
  //source数组
  char src[] = "Hello neimenggu!";
  //模拟实现strcpy
  my_strcpy(dest, src);
  //打印
  printf("%s",dest);
  return 0;
}

strcat

strcat介绍

char* strcat(char* destinaion,char* source)

追加字符串：将源字符串的副本追加到目标字符串。目标中终止的 null 字符被源的第一个字符覆盖，并且在目标中两者串联形成的新字符串的末尾包含一个 null 字符

头文件：#include<stdio.h>
参数desitination：指向目标数组的指针，该数组应包含 C 字符串，并且足够大以包含连接的结果字符串
参数source：要附加的 C 字符串。这不应与目标重叠
返回值：目标数组的地址

注意事项：

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

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

3.目标空间必须可以被修改

4.源字符串和目标空间相同时，可能会出现问题，不建议使用strcat

实际使用：

//实际使用strcat
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
  char dest[20] = "Hello ";
  char src[] = "gansu！";
  //使用strcat
  strcat(dest, src);
  //打印
  printf("%s", dest);
  return 0;
}

运行截图：
模拟实现：

//strcat模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
  assert(dest && src);
  //将dest的起始位置保存
  char ret = dest;
  //将dest循环至\0
  while (*dest != '\0')
  {
    dest++;
  }
  //将src字符串连接在dest后面
  while (*src != '\0')
  {
    *dest = *src;
    dest++;
    src++;
  }
  return ret;
}
int main(void)
{
  char dest[30] = "Hello ";
  char src[] = "heilongjiang!";
  //模拟实现strcat
  my_strcat(dest, src);
  //打印
  printf("%s", dest);
  return 0;
}

strcmp

strcmp介绍：

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

比较俩个字符串:此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续执行以下对，直到字符不同或达到终止 null 字符.此函数执行字符的二进制比较。

头文件:#include<string.h>
参数:被比较的字符串
返回值:返回一个整数值，该值指示字符串之间的关系:

返回值	表明
<0	第一个字符串小于第二字符串
0	第一个字符串等于第二个字符串
>0	第一个字符串大于第二个字符串

注意事项:

1.比较俩个字符串时比较俩个字符串对应位置的ASCII码值(将其转换为2进制比较)

2.在vs环境下返回>0,=0,<0的值

实际使用:

//strcmp的实际使用
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
  //俩个不相等的字符串
  char str1[] = "Hello!";
  char str2[] = "hello!";
  //俩个相等的字符串
  char str3[] = "liaoning";
  char str4[] = "liaoning";
  //比较1和2
  int ret1 = strcmp(str1, str2);
  //打印
  printf("%d\n",ret1);
  //比较3和4
  int ret2 = strcmp(str3, str4);
  //打印
  printf("%d\n", ret2);
  return 0;
}

运行结果:
模拟实现:

#define  _CRT_SECURE_NO_WARNINGS 1  
//strcmp的模式实现
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
  //断言
  assert(str1 && str2);
  int cmp = 0;
  //循环相同的字符
  while (*str1 ==*str2)
  {
    if (*str1 == '\0')
    {
      return 0;
    }
    str1++;
    str2--;
  }
  //比较不同的字符
  if (*str1 > *str2)
  {
    return 1;
  }
  else
  {
    return -1;
  }
}
int main(void)
{
  char str1[] = "Hello Tianjin！";
  char str2[] = "Hello tianjin！";
  //模拟实现strcmp
  int ret = my_strcmp(str1, str2);
  //打印
  printf("%d", ret);
  return 0;
}

长度受限制的字符串函数

strncpy

strncpy介绍:

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

从字符串中复制字符:将源的前 num 个字符复制到目标。如果在复制 num 个字符之前找到源 C 字符串的末尾（由 null 字符表示），则 destination 将用零填充，直到将 num 个字符写入该字符串。

头文件:#include<string.h>
参数destination:指向要复制内容的目标数组的指针
参数source:要复制的 C 字符串
参数num:要从源复制的最大字符数(size_t 是无符号整数类型)
返回值:返回目标数组起始的指针

注意事项:

1.如果 source 的长度大于 num，则不会在目标末尾隐式附加 null 字符。因此，在这种情况下，destination 不应被视为以 null 结尾的 C 字符串(这样读取它会溢出)

2.目的地和源不得重叠

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

实际使用:

#define  _CRT_SECURE_NO_WARNINGS 1  
//实际使用strncpy
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
  char destination[20] = "***************";
  char source[] = "Hello hebei!";
  //从字符串中复制字符
  strncpy(destination, source, 12);
  //打印
  printf("%s", destination);
  return 0;
}

运行结果:
模拟实现:

//模拟实现strncpy
#include<stdio.h>
#include<assert.h>
char* my_strncpy(char* destination, const char* source, int num)
{
  assert(destination && source);
  char* ret = destination;
  int i = 0;
  while(num--)
  {
    *destination = *source;
    destination++;
    source++;
  }
  return ret;
}
int main(void)
{
  char dest[] = "***************";
  char src[] = "Hello jilin!";
  //模拟实现strncpy
  my_strncpy(dest, src, 12);
  //打印
  printf("%s", dest);
  return 0;
}

strncat

strncat介绍:

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

从字符串中附加字符:将源的前 num 字符追加到 destination 后，加上一个终止的 null 字符。

头文件:#include<string.h>
参数destination:指向目标数组的指针
参数source:要附加的 C 字符串
参数num:要追加的最大字符数(size_t 是无符号整数类型)

注意事项:

1.如果源代码中 C 字符串的长度小于 num，则仅复制终止 null 字符之前的内容

2.目标数组应包含 C 字符串，并且足够大以包含连接的结果字符串，包括其他 null 字符

实际使用:

//实际使用strncat
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
  char dest[30] = "Hello ";
  char src[] = "xinjiang!";
  //使用strncat
  strncat(dest,src,3);
  //打印
  printf("%s",dest);
  return 0;
}

运行截图:

模拟实现:

//模拟实现strncap
#include<stdio.h>
#include<assert.h>
char* my_strncat(char* dest, const char* src, int num)
{
  assert(dest && src);
  char* ret = dest;
  //循环dest至结束
  while (*dest)
  {
    dest++;
  }
  //连接字符串
  while (num--)
  {
    *dest = *src;
    dest++;
    src++;
  }
  return ret;
}
int main(void)
{
  char dest[30] = "Hello ";
  char src[] = "xizang!";
  //模拟实现strncap
  my_strncat(dest, src, 2);;
  //打印
  printf("%s",dest);
  return 0;
}

strncmp

介绍strncmp:

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

比较两个字符串的字符:将 C 字符串 str1 的字符数与 C 字符串 str2 的字符数进行比较。

头文件:#include<string.h>
参数str1:要比较的 C 字符串
参数str2:要比较的 C 字符串
参数num:要从源复制的最大字符数(size_t 是无符号整数类型)
返回值:返回一个整数值，该值指示字符串之间的关系:

返回值	表明
<0	第一个字符串小于第二字符串
0	第一个字符串等于第二个字符串
>0	第一个字符串大于第二个字符串

注意事项:

1.此函数开始比较每个字符串的第一个字符。

2.如果它们彼此相等，则继续执行以下对，直到字符不同，直到达到终止的 null 字符，或者直到两个字符串中的 num 个字符匹配，以先发生者为准

实际使用:

//实际使用strncmp
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
  char str1[] = "Hello Qinghai!";
  char str2[] = "Hello qinghai!";
  //比较字符串
  int ret = strncmp(str1,str2,10);
  //打印
  printf("%d",ret);
  return 0;
}

运行结果:

模拟实现:

//模拟实现strncmp
#include<stdio.h>
#include<assert.h>
int my_strncmp(const char* str1, const char* str2, int num)
{
  assert(str1 && str2);
  while (*str1 == *str2 && num)
  {
    if (*str1 == '\0'||num==0)
    {
      return 0;
    }
    str1++;
    str2++;
    num--;
  }
  if (*str1 > *str2)
  {
    return 1;
  }
  else
    return -1;
}
int main(void)
{
  char str1[] = "Hello Sichuan!";
  char str2[] = "Hello sichuan!";
  //模拟实现比较字符串
  int ret = my_strncmp(str1, str2, 10);
  //打印
  printf("%d",ret);
  return 0;
}

字符串查找

strstr

strstr介绍：

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

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

查找子字符串：返回指向 str1 中首次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回空指针

头文件：#include<string.h>
参数str1：要扫描的 C 字符串
参数str2：包含要匹配的字符序列的 C 字符串
返回值：指向 str1 中指定的整个字符序列在 str1 中首次出现的指针，如果序列在 str1 中不存在，则为空指针

注意事项：

1.匹配过程不包括终止 null 字符

实际使用：

//实际使用strstr
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
  char str1[] = "Hello yunnan!";
  char str2[] = "yunnan";
  //查找子字符串
  char* ret = strstr(str1, str2);
  //打印
  printf("%s",ret);
  return 0;
}

运行结果：

模拟实现：

//strstr模拟实现
#include<stdio.h>
#include<assert.h>
const char* my_strstr(const char* str1, const char* str2)
{
  assert(str1 && str2);
  while (*str1!='\0')
  {
    //引用俩个指针代替str1,str2
    char* S1 = str1;
    char* S2 = str2;
    //代替指针进入比较循环
      while (*S1 == *S2&&*S1!='\0' && *S2 != '\0')
      {
          S1++;
          S2++;
      }
      if (*S2 == '\0')
      {
        return str1;
      }
      str1++;
  }
  return NULL;
}
int main(void)
{
  char str1[] = "Hello hainan!";
  char str2[] = "hainan";
  //模拟实现strstr
  char* ret = my_strstr(str1, str2);
  //打印
  printf("%s",ret);
  return 0;
}

strtok

介绍strtok：

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

将字符串拆分：对此函数的一系列调用将 str 拆分为标记，这些标记是由分隔符中的任何字符分隔的连续字符序列。

头文件：#include<stdio,h>
参数str：要截断的 C 字符串
参数delimiters：包含分隔符的 C 字符串
返回值：如果找到分隔符，则指向分隔符开头的指针，否则为空指针

注意事项：

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

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

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

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

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

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

实际使用：

//实际使用strtok
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
  const char str1[] = "Hello!China*I love you+lalalala";
  const char del[] = "!*+";
  char* ret = NULL;
  char s[50];
  //拷贝字符串
  strcpy(s, str1);
  //分割打印
  for (ret = strtok(s, del); ret != NULL; ret = strtok(NULL, del))
  {
    printf("%s\n",ret);
  }
  return 0;
}

运行结果：

错误信息报告

strerror

介绍strerror：

char* strerror(int errnum)

获得一个指向错误信息的地址：解释 errnum 的值，生成一个字符串，其中包含一条消息，该消息描述错误条件，就像库的函数设置为 errno 一样。返回的指针指向静态分配的字符串，程序不得修改该字符串。对此函数的进一步调用可能会覆盖其内容（不需要特定的库实现来避免数据争用）。strerror 生成的错误字符串可能特定于每个系统和库实现。

头文件：#include<stdio.h>
参数errnum：错误码
返回值：错误信息的地址

注意事项：

1.c语言的库函数在运行的时候，如果发生错误，就会将错误存在一个变量中，这个变量是：errno

2.错误码是一些数字：1，2，3，4，5

3.我们需要将错误码翻译成错误信息

实际使用：

//实际使用strerror
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main(void)
{
  //打开文件
  FILE* pf = fopen("my.txt","r");
  if (pf == NULL)
  {
    printf("%s",strerror(errno));
  }
  return 0;
}

运行结果：

字符分类函数

函数	参数符合条件则返回真
iscntrl	任何控制字符
isspace	空白字符:空格’ ‘,换页’\f’,换行’\n’,回车’\r’,制表符’\t’或者垂直制表符’\v’
isdigit	十进制数字0~9
iscdigit	十六进制数字,包括十进制数字,小写字母a-f,大写字母A-F
islower	小写字母a-f
isupper	大写字母A-F
isalpha	字母a-z或A-Z
isalnum	字母或者数字0-9,a-z,A-Z
ispunct	标点符号,任何不属于数字或者字母的图形字符(可打印)
isgraph	任何图形字符
isprint	任何可打印字符,包括图形字符和空白字符

显示详细信息

字符转换函数

tolower

int tolower(int c)

将大写字母转换为小写

toupper

int toupper(int c)

将小写字母转换为大写

内存操作函数

memcpy

介绍memcpy

void* memcpy(void* destination,const void* source,size_t um)

复制内存块:将 num 字节的值从源指向的位置直接复制到目标指向的内存块

头文件：#include<string.h>
参数destination：指向要拷贝内容的目标数组的指针，类型转换为 void* 类型的指针
参数source：指向要拷贝的数据源的指针，类型转换为类型为 const void* 的指针。
参数num：要拷贝的字节数（size_t 是无符号整数类型）
返回值：返回destination的指针

注意事项：

1.strcpy只能拷贝字符串，而memcpy可以拷贝内存块

2.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置

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

4.如果source和的destination有任何的重叠，复制的内容都是未定义的

实际使用：

//实际使用memcpy
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
  int src[] = {1,2,3,4,5};
  int dest[10];
  //使用memcpy
  memcpy(dest,src,sizeof(src));
  //打印
  int i = 0;
  for (i = 0; i < (sizeof(src) / sizeof(src[0])); i++)
  {
    printf("%d ",dest[i]);
  }
  return 0;
}

运行结果：

模拟实现：

//模拟实现memcpy
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
  assert(dest && src);
  void* ret = dest;
  while (num--)
  {
    *(char*)dest = *(char*)src;
    dest = (char*)dest + 1;
    src = (char*)src + 1;
  }
  return ret;
}
int main(void)
{
  int src[] = { 1,2,3,4,5,6,7,8,9 };
  int dest[10] = { 0 };
  //实现memcpy
  my_memcpy(dest, src+3, 17);
  //打印
  int i = 0;
  for (i = 0; i < (17 / sizeof(int)); i++)
  {
    printf("%d ",dest[i]);
  }
  return 0;
}

memmove

介绍memmove:

void* memcpy(void* destination,const void* source,size_t um)

移动内存块:将 num 字节的值从源指向的位置复制到目标指向的内存块。复制就像使用了中间缓冲区一样进行，允许目标和源重叠

头文件：#include<string.h>
参数destination：指向要复制内容的目标数组的指针，类型转换为 void* 类型的指针
参数source：指向要复制的数据源的指针，类型转换为类型为 const void* 的指针。
参数num：要复制的字节数（size_t 是无符号整数类型）
返回值：返回destination的指针

注意事项：

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

2.如果源空间和目标空间出现重叠，就可以使用memmove

实际使用：

//实际使用memmove
#include<stdio.h>
#include<string.h>
int main(void)
{
  int str[] = { 1,2,3,4,5,6,7,8 };
  //使用memmove
    //模拟实现memmove
  memmove(str + 2, str, 20);
  //打印
  int i = 0;
  for (i = 0; i < (sizeof(str) / sizeof(str[0])); i++)
  {
    printf("%d ", str[i]);
  }
  return 0;
}

运行结果：

模拟实现：

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

memcmp

比较俩个内存块：将 ptr1 指向的内存块的第一个 num 字节与 ptr2 指向的第一个 num 字节进行比较，如果它们都匹配，则返回零，或者如果它们不匹配，则返回与零不同的值，表示哪个值更大

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

头文件：#include<string.h>
参数ptr1：指向内存块的指针
参数ptr2：指向内存块的指针
参数num：要比较的字节数
返回值：返回一个整数值，该值指示字符串之间的关系

返回值	表明
<0	在两个内存块中不匹配的第一个字节在 PTR1 中的值低于 PTR2 中的值（如果计算为无符号字符值）
0	两个内存块的内容相等
>0	在两个内存块中不匹配的第一个字节在 PTR1 中的值高于 PTR2 中的值（如果计算为无符号字符值）

实际使用：

//实际使用memcmp
#include<stdio.h>
#include<string.h>
int main(void)
{
  int str1[] = { 1,2,3,4,5 };
  int str2[] = { 1,2,5,4,5 };
  //实际使用memcmp
  int ret = memcmp(str1, str2,4);
  //打印
  printf("%d\n",ret);
  ret = memcmp(str1, str2, 12);
  //打印
  printf("%d\n", ret);
  return 0;
}

运行结果：

memset

介绍memset:

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

填充内存块:将 ptr 指向的内存块的第一个 num 字节设置为指定值（解释为无符号字符）

头文件：#include<stdio.h>
参数ptr：指向要填充的内存块的指针
参数value:要设置的值，该值作为 int 传递，但该函数使用此值的无符号字符转换填充内存块
参数num:要填充的字节数（size_t 是无符号整数类型）
返回值：返回 ptr的指针
实际使用：

//实际使用memset
#include<stdio.h>
#include<string.h>
int main(void)
{
  char str[] = "************";
  //实际使用memset
  memset(str, 'a', 5);
  //打印
  printf("%s",str);
  return 0;
}

运行结果：

在学习的过程中还会遇见其他的字符串函数，后续更新

strchr

介绍strchr

const strchr (const char* str , int character );

strchr (char* str , int character)

查找字符串中第一个出现的字符：返回一个指向第一次出现字符的地址

头文件：#include<stdio.h>
参数str：字符串
参数character：需要定位的字符
返回值：返回一个指向第一次出现字符的地址

注意事项：

1.末尾的NULL字符可以看作是C字符串的一部分，因此也可以定位NULL字符来确定字符串末尾的地址

2.character以int形式接收参数，但是内部以char类型进行比较

实际使用：

//实际使用strchr
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
  char str[] = "This is my history!";
  char* p = NULL;
  p = strchr(str, 's');
  //打印地址
  printf("%p\n",p);
  //打印字符
  printf("%c\n",*p);
  return 0;
}

运行结果：

字符以及字符串函数

求字符串长度

strlen

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

strcpy

strcat

strcmp

长度受限制的字符串函数

strncpy

strncat

strncmp

字符串查找

strstr

strtok

错误信息报告

strerror

字符分类函数

字符转换函数

tolower

toupper

内存操作函数

memcpy

memmove

memcmp

memset

strchr

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

字符以及字符串函数

求字符串长度

strlen

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

strcpy

strcat

strcmp

长度受限制的字符串函数

strncpy

strncat

strncmp

字符串查找

strstr

strtok

错误信息报告

strerror

字符分类函数

字符转换函数

tolower

toupper

内存操作函数

memcpy

memmove

memcmp

memset

strchr

热门文章

最新文章

相关电子书