字符串的相关库函数

strlen 求字符串个数的函数

size_t strlen(const char *str);
strlen不包括‘\0’的计算,并且遇到’\0’就退出计算

• 课外知识
  \xhh表示十六进制数代表的符号
  \ddd表示8进制的

  	char arr[] = "abcdf";
    printf("%d", sizeof(arr));//6
    printf("%d", strlen(arr));//5
    char arr[] = "abc\0df";
    printf("%d", sizeof(arr));//7
    printf("%d", strlen(arr));//3

函数实现方式

#include <stddef.h> // 为了使用 size_t 类型
 
size_t strlen(const char *str) 
{
    size_t length = 0; // 初始化字符串长度为 0
 
    // 循环直到遇到字符串的结尾
    while (*str != '\0') 
    {
        length++; // 每遍历一个字符，长度加一
        str++;    // 指针向后移动到下一个字符
    }
 
    return length; // 返回字符串长度
}

字符串拷贝函数 strcpy

char *strcpy(char *dest, const char *src);
字符串拷贝函数 strcpy会覆盖掉原来的字符串进行返回，并且还要保证内存足够大
格式：strcpy(字符数组1,字符串2)
功能：将字符串2，拷贝到字符数组1中去
返值：返回字符数组1的首地址
说明： 字符数组1必须足够大 ，拷贝时‘\0’一同拷贝

#include <stdio.h>
#include <string.h>  //加入头文件

int main()
{

   char arr[1024] = "aaa";
   char arr2[19] = "ddd";
   strcpy(arr, arr2);
   printf("%s", arr); // ddd
   return 0;
}

字符串拼接函数strcat

*char *strcat(char *dest, const char src);
格式：strcat(字符数组1,字符数组2)
功能：把字符数组2连到字符数组1后面
返值：返回字符数组1的首地址
说明： 字符数组1必须足够大 以容纳原始字符串的内容和新的字符串内容
连接前,两串均以‘\0’结束;
连接后,串1的‘\0’取消,新串最后加‘\0’

   char arr[15] = "aaa";
   char arr2[19] = "ddd";
   strcat(arr, arr2);
   printf("%s", arr); // aaaddd

字符串比较函数strcmp

int strcmp(const char *str1,const char *str2)
格 式：strcmp(字符串1,字符串2)
功 能：比较两个字符串 比较规则：对两串从左向右逐个字符比较
（ASCII码），直到遇到不同字符或‘\0’为止
返 值：返回int型整数
a. 若字符串1< 字符串2， 返回负整数
b. 若字符串1> 字符串2， 返回正整数
c. 若字符串1== 字符串2， 返回零

int main()
{

   char arr[15] = "aaa";
   char arr2[19] = "ddd";
   char arr3[19] = "aaa";
   int a = strcmp(arr, arr2);
   int b = strcmp(arr2, arr);
   int c = strcmp(arr, arr3);
   printf("%d %d %d", a,b,c); // -3  ,3,0
   return 0;
}

复制指定长度字符串 strncpy(p, p1, n)

char *strncpy(char *dest, const char *src, size_t n);

• dest：目标字符串，即要复制到的字符串。
• src：源字符串，即要复制的字符串。
• n：要复制的最大字符数。

strncpy 是一个用于安全地复制字符串的函数，可以帮助预防缓冲区溢出。在使用时，务必确保目标数组的大小，并在必要时手动添加字符串结束符 \0。还需注意当复制字符串小于目标字符串时，如果原有就在原有的位置上进行复制，见以下代码

int main()
{
   char src[] = "Hello, World!";
   char dest[20] = "ddd";
   // 使用 strncpy 复制字符串
   strncpy(dest, src, 1);
   printf("目标字符串: %s\n", dest);//Hdd  ddd-->1-->Hdd
   strncpy(dest, src, 4);
   printf("目标字符串: %s\n", dest);//Hell
   // 确保 dest 以 '\0' 结尾
   dest[sizeof(dest) - 1] = '\0';
   printf("源字符串: %s\n", src);//Hello, World!

   return 0;
}

附加指定长度字符串strncat(p, p1, n)

strncat 是 C 标准库中的一个字符串处理函数，定义在 <string.h> 头文件中。它用于将一个字符串的前 n 个字符追加到另一个字符串的末尾。

char *strncat(char *dest, const char *src, size_t n);

• dest：目标字符串，字符串将被追加到此。
  -src：源字符串，要追加的字符串。
  -n：要追加的最大字符数。

注意事项：

• 目标字符串长度：确保目标字符串 dest 有足够的空间以容纳追加的内容及终止符 \0。
• 结束符：strncat 会在复制后自动添加字符串结束符 \0，但目标字符串必须已经是一个合法的字符串（以 \0 结尾）

int main()
{
   char dest[20] = "Hello"; // 初始化目标字符串
   char src[] = " World!";
   // 使用 strncat 追加字符串
   strncat(dest, src, 6); // 只追加 " World"
   printf("目标字符串: %s\n", dest);//hello world！
   return 0;
}

忽略大小写比较字符串strcasecmp

strcasecmp 函数用于比较两个字符串，忽略大小写。

int strcasecmp(const char *str1, const char *str2);
参数 str1 和 str2 是要比较的两个字符串。如果两个字符串相等（不区分大小写），返回值为 0；否则返回非 0 值。

#include <stdio.h>

int main()
{
   char a[10] = "ABa";
   char b[10] = "aaA";
   int flag = 0;
   flag = strcasecmp(a, b);
   printf("%d", flag);//不区分大小写如果 a=b --》0   如果a>b 返回正整数  ，如果a<b 返回负整数
   return 0;
}

比较指定长度字符串strncmp(p, p1, n)

strncmp 函数用于比较两个字符串的前n个字符

int strncmp(const char *str1, const char *str2, size_t n);
参数 str1 和 str2 是要比较的两个字符串，n 是要比较的字符数。如果两个字符串的前n个字符相等，返回值为 0；否则返回非 0 值。

int main()
{
   char a[10] = "aBaA";
   char b[10] = "aaAA";
   int flag = 0;
   flag = strncmp(a, b, 4);
   printf("%d", flag);//-31
   return 0;
}

注意事项：区分大小写 从第一个字符开始比较一直比到两者不同的字符，如果a>b返回其差值的ASCII码值为正数，反之相等为0，小于为负整数

在字符串中查找指定字符strchr(p, c)

strchr 函数在字符串中查找指定字符，并返回第一个匹配到的字符的指针。
char *strchr(const char *str, int c);
参数 str 是要搜索的字符串，c 是要查找的字符。如果找到了指定字符，则返回该字符在字符串中的地址；否则返回 NULL。

int main()
{
   char a[10] = "bBaA";
   char b[10] = "bbAAa";
  printf("%s", strchr(a, 'a'));//aA
   printf("%s", strchr(b, 'a'));//a
   printf("%s", strchr(b, 'b'));//bbAAa
   printf("%s", strchr(b, 'c'));//(null)
   return 0;
}

返回的是当前字符串中需要查找的字符，并且要查找的字符前面不需要读取，只读取查找出来以及后面字符,如果找不到就返回null

查找字符串 strstr(p, p1)

strstr 函数在字符串中查找指定子字符串，并返回第一个匹配到的子字符串的指针

char *strstr(const char *haystack, const char *needle);
参数 haystack 是要搜索的字符串，needle 是要查找的子字符串。如果找到了指定的子字符串，则返回该子字符串在字符串中的地址；否则返回 NULL。

int main()
{
   char a[100] = "bbbbaaassdgf";
   char b[10] = "ss";

   printf("%s", strstr(a, b)); // ssdgf
   printf("%s", strstr(a, 'dd')); //null
   return 0;
}

找出b在a字符串中的首次出现的位置并依次打印，如果未找到则输出（null）,跟strchr类似只不过它找的是字符strstr找的是字符串

检查是否为字母字符isalpha()

isalpha 函数用于检查一个字符是否为字母字符（即 A-Z 或 a-z）。

int main()
{
   char a = '+';
   printf("%d", isalpha(a)); // 0
   char c = 'a';
   printf("%d", isalpha(c)); // 1024 至于具体这个值怎么来的自己可以查看相关资料
   int b = 75;
   printf("%d", isalpha(b)); // 1024
   return 0;
}

如果是一个字母字符，则返回非零值（即真）1024内存值；否则返回 0。

检查是否为大写字母字符isupper()

isupper 函数用于检查一个字符是否为大写字母字符（即 A-Z）

int isupper(int c);

int main()
{
   char a = '+';
   printf("%d\n", isupper(a)); // 0
   int b = 98;
   printf("%d\n", isupper(b)); //c  0
   int d = 75;
   printf("%d\n", isupper(d)); //K 256
   int c = 'C';
   printf("%d\n", isupper(c)); // 256
   int e = 'e';
   printf("%d\n", isupper(e)); // 0
   return 0;
}

如果是一个大写字母字符，则返回非零值（即真）；否则返回 0。

检查是否为小写字母字符 islower()

islower函数用于检查一个字符是否为大写字母字符（即 a-z）

int islower(int c);

int main()
{
   char a = '+';
   printf("%d\n", islower(a)); // 0
   int b = 98;
   printf("%d\n", islower(b)); //c  512
   int d = 75;
   printf("%d\n", islower(d)); //K 0
   int c = 'C';
   printf("%d\n", islower(c)); // 0
   int e = 'e';
   printf("%d\n", islower(e)); // 512
   return 0;
}

如果是一个小写字母字符，则返回非零值（即真）；否则返回 0。

检查是否为数字isdigit()

isdigit 函数用于检查一个字符是否为数字字符（即 0-9）注意：只检测字符1~字符9 即’1’~‘9’

int isdigit(int c);

int main()
{
   int d = '1';
   printf("%d\n", isdigit(d)); // 1
   int g = '9';
   printf("%d\n", isdigit(g)); // 1
   int f = '10';
   printf("%d\n", isdigit(f)); // 0
   char a = '+';
   printf("%d\n", isdigit(a)); // 0
   int b = 98;
   printf("%d\n", isdigit(b)); // 0
   int c = 'C';
   printf("%d\n", isdigit(c)); // 0
   int e = 'e';
   printf("%d\n", isdigit(e)); // 0
   return 0;
}

如果 是一个数字字符，则返回非零值（即真1）；否则返回

字符串格式化打印函数sprintf()

int sprintf(char *str,const char *format,...)
功能：根据参数format字符串来转换并格式化数据，
然后将结果输出到str指定的空间中，
直到出现字符串结束符’\0’为止
参数：
str:字符串的首地址
format:字符串格式，用法和printf()一样
返回值：
成功：实际格式化的字符个数
失败：-1

    char arr[100] = {0};
    int a = 10;
    char *b = "snbvv";
    sprintf(arr, "a=%d,b=%s", a, b);
    printf("%s", arr); //a=10,b=snbvv

总结 ：第一个参数是要格式化的字符串地址，第二参数是要格式化的格式，第三个参数是格式化的数据，注意sprintf本身不具备打印功能

字符串读取函数sscanf()

int sscanf(const char *str,const char *format,...)
功能：从str指定的字符串读取数据，
并根据参数format字符串来转换并格式化数据
参数：
str：指定的字符串的首地址
format：字符串格式，用法和scanf()一样
返回值：
成功：参数数据，成功转换的值的个数
失败：-1

int main()
{
	char str[]="a=10,b=20";
	int a,b;
	sscanf(str,"a=%d,b=%d",&a,&b);
	printf("%d %d\n",a,b );//10 20

	return 0;
}

总结:跟上面格式化相似，第一个参数读取的字符串地址，第二个参数读取的格式，切记格式必须一模一样，第三个参数就是赋值的参数的地址

分割字符串函数strtok()

char *strtok(char *str,const char *delim)
功能：将字符串分割成一个小片段，当strtok()在参数str的字符串发现
参数delim中包含的分割字符时，则会将字符串改为’\0’，当连续出现多个时
只替换第一个为’\0’
参数：
str：指向要分割的字符串
delim：为分割字符串中包含的字符
返回值：
成功：分割后字符串的首地址
失败：NULL

int main()
{
	char a[100]="abc*fcvf*gjka*bfdasjk";
	char *s=strtok(a,"*");
	// printf("%s\n",s );
	// printf("%s\n",a );
	while(s!=NULL)
	{
		printf("%s\n",s);
		s=strtok(NULL,"*");
	}
	return 0;
}

需要注意：
1.在第一次调用strtok()时，必须给于参数str（指定分割的字符串）
2.将字符串指定给strtok之后，函数会保存str记录
3.往后的调用过程中，如果需要继续分割字符串，就不需要再指定str了
4.往后的调用将参数str设置成NULL，每次调用成功则返回指向被分割片段的指针。

计算一个字符串（目标字符串）中不包含指定字符集的最长前缀的长度strcspn

size_t strcspn(const char *str1, const char *str2);

#include <stdio.h>
#include <string.h>

int main() {
    char str[100];
    
    printf("请输入一行文本: ");
    fgets(str, sizeof(str), stdin); // 读取输入

    // 使用 strcspn 去除换行符
    str[strcspn(str, "\n")] = 0; // 将换行符替换为字符串结束符

    printf("您输入的内容是: %s\n", str);
--------------------------------------------------------------------------
    char str[100] = "abcbcsbcbdbbdb";
    char str1[100] = "ed";
    char str2[100] = "bd";
    int num = 0;
    int num2 = 0;
    num = strcspn(str, str1);
    num2 = strcspn(str, str1);
    printf("%d", num); // 9  
    printf("%d", num2); // 1  
    return 0;
}

总结找出第一个匹配元素，比如上面e,没有找不到，那就开始找d,第一个d索引是9

字符串转小数或者整数atoi,atof,atol

头文件stdlib.h

#include <stdlib.h>
int atoi(const char *npstr)
    功能：atoi()会扫描npstr字符串，跳过前面的空格字符，
    直到遇到数字或者正负号才开始做转换，而遇到非数字(表示指数E或者e除外)
    或者字符串结束符'\0'结束转换，并将结果返回
    参数：
        npstr：待转换的字符串
    返回值：
        成功转换后的整数

类似的函数：
1.atof():将一个小数形式的字符串，转换成一个浮点数
2.atol():将一个字符串转换成long类型

#include <stdio.h>
#include <stdlib.h>
int main()
{
	char str[]="-10";
	int num1=atoi(str);
	printf("num1=%d\n",num1 );//-10

	char str1[]="          -10";//会跳过空格
	int num2=atoi(str1);
	printf("num2=%d\n",num2 );//-10

	char str2[]="ab-10";//遇到非数字字符就会结束转换
	int num3=atoi(str2);
	printf("num3=%d\n",num3 );//0

	char str3[]="-10ab";
	int num4=atoi(str3);
	printf("num4=%d\n",num4 );//-10

	char str4[]="9.623";
	int num5=atoi(str4);
	printf("num5=%d\n",num5 );//9

	double num6=atof(str4);
	printf("num6=%.3lf\n",num6 );//9.623

	char str5[]="9.12E3";
	double num7=atof(str5);
	printf("num7=%lf\n",num7 );//num7=9120.000000
	return 0;
}