2024-02-18-物联网C语言(7-字符串处理函数)

合集 - 物联网(25)

1.2024-02-16-物联网C语言(1-数据类型与语句)2024-02-162.2024-02-17-物联网C语言(2-数组)2024-02-173.2024-02-17-物联网C语言(3-函数)2024-02-174.2024-02-17-物联网C语言(4-预处理)2024-02-175.2024-02-17-物联网C语言(5-指针)2024-02-186.2024-02-18-物联网C语言(6-动态内存申请)2024-02-18

7.2024-02-18-物联网C语言(7-字符串处理函数)2024-02-18

8.2024-02-18-物联网C语言(8-结构体、共用体、枚举)2024-02-199.2024-02-19-物联网C语言(9-链表)2024-02-2010.2024-02-20-物联网C语言(10-文件)2024-02-2011.2024-02-21-物联网系统编程(1-Shell语言)2024-02-2112.2024-02-21-物联网系统编程(2-系统调用)2024-02-2213.2024-02-22-物联网系统编程(3-进程)2024-02-2314.2024-02-23-物联网系统编程(4-信号)2024-02-2515.2024-02-24-物联网系统编程(5-管道、命名管道)2024-02-2616.2024-02-27-物联网系统编程(6-消息队列)2024-02-2717.2024-02-27-物联网系统编程(7- 共享内存)2024-02-2718.2024-02-27-物联网系统编程(8-线程)2024-02-2819.2024-02-28-物联网系统编程(9-多任务互斥与同步)2024-02-2820.2024-02-29-Linux高级网络编程(1-计算机网络概述)2024-02-2821.2024-02-29-Linux高级网络编程(2-UDP编程)2024-02-2922.2024-02-29-Linux高级网络编程(3-UDP编程-TFTP、广播、多播)2024-02-2923.2024-02-29-Linux高级网络编程(4-TCP编程)2024-03-0124.2024-03-01-Lniux高级网络编程(5-网络通信过程)2024-03-0125.2024-03-01-Linux高级网络编程(6-原始套接字)2024-03-01

收起

7. 字符串

7.1 获取字符串的长度函数 - strlen

头文件： #include <string.h>
函数定义： size_t strlen(const char *s)
参数：s - 指定的字符串
返回值：当前字符串的长度

#include <stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    // 使用strlen获取字符串的长度
    // strlen获取字符串长度，遇到\0结束
    char s[100] = "hello world";
    printf("s1_len = %d\n",strlen(s));
    return 0;
}

输出结果

s1_len = 11

7.2 字符串拷贝函数 - strcpy

头文件: #include <string.h>
函数的定义: char *strcpy(char *dest, const char *sre);
函数的说明:
		拷贝 sc 指向的字符串到 dest指针指向的内存中，"\0"也会拷贝
函数的返回值:
		目的内存的地址
注意: 在使用此函数的时候，必须保证 dest 指向的内存空间足够大，否则会出现内存污染。
    
char *strncpy(char *dest,const char *src,size_t n);
函数的说明:将src指向的字符串前n个字节，拷贝到dest指向的内存中
返回值:目的内存的首地址
注意:
1、strncpy不拷贝 "\0"
2、如果n大于src指向的字符串中的字符个数，则在dest后面填充 n-strlen(src) 个 "\0"  

#include <stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    char s1[100] = "hello world";
    char s2[30] = "dasfasfags";
    // 将s2拷贝到s1中
	// 需要保证s1的空间足够大，不然会出现内存问题
    strcpy(s1, s2);
    printf("s1 = %s\n", s1);
    return 0;
}

输出结果

s1 = dasfasfags

7.3 字符串追加函数 - strcat

头文件:#include <string.h>
函数定义:char *strcat(char *deet, const char *src);
函数功能: strcat,函数追加 src字符串到 dest,指向的字符串的后面。追加的时候会追加"\0"
注意:保证 dest 指向的内存空间足够大。
    
char *strncat(char *dest, const char *src, size_t n);
追加 src指向的字符串的前 n个字符到 dest指向的字符串的后面。
注意: 如果 n 大于 src,的字符个数，则只将 src字符串追加到dest, 指向的字符串的后面追加的时候会追加"\0"

#include <stdio.h>
#include <string.h>
int main(int argc, char *argy[])
{
    // 使用strcat函数追加字符串
    char s1[32] = "hello world";
    char s2[32] = "abcdef";
    // strcat是从s1的\@的位置开始追加，直到s2的第一个0复制完毕后结束
    strcat(s1, s2);
    printf("sl =%s\n", s1);
    return 0;
}

输出结果

sl =hello worldabcdef

7.4 字符串比较函数 - strcmp

//比较strcmp/strncmp
头文件:#include<string.h>
函数定义:int strcmp(const char *sl,const char *s2);
函数说明: 比较 s1 和 s2 指向的字符串的大小,
比较的方法: 逐个字符去比较 ascII 码，一旦比较出大小返回
返回值:
    1. 如果 s1 指向的字符串大于 s2 指向的字符串 返回 1;
    2. 如果 s1 指向的字符串小于 s2 指向的字符串 返回-1;
    3. 如果相等的话返回 0;
 
strncmp( const char *sl,const char *s2,size_t n) - 比较前n个字符

#include <stdio.h>
#include <string.h>
int main(int argc, char *argy[])
{
 
    char s1[32] = "hella";
    char s2[32] = "hello";
 
    int ret = strcmp(s1, s2);
 
    if (ret == 0){
        printf("s1 = s2 \n");
    }else if (ret>0)
    {
        printf("s1 > s2 \n");
    }else{
        printf("s1 < s2 \n");
    }
 
    return 0;
}

输出结果

s1 < s2 

7.5 字符串查找函数 - strchr

头文件:#include <string.h>
char *strchr(const char *s,int c);
功能:在字符指针s指向的字符串中，找ascii码为c的字符
参数:
	s:指定的字符串
    c:要查找的字符返回值:
成功:找到的字符的地址
失败:NULL注意:s指向的字符串中有多个ASCII为c的字符，则找的是第1个字符
    
char *strrchr(const char *s,int c);
功能:在s指向的字符串中，找最后一次出现的ASCII为c的字符，

#include <stdio.h>
#include <string.h>
int main(int argc, char *argy[])
{
 
    char s1[32] = "hella6dasdas";
    char *ret = strchr(s1,'6');
    if(ret == NULL){
        printf("NOT FOUND\n");
    } else {
        printf("GOT , IN POSITINO %d !  \n", ret -s1 );
    }
    
    return 0;
}

输出结果

GOT , IN POSITINO 5 ! 

7.6 字符串匹配函数 - strstr

头文件：#include <string.h>
char *strstr(const char *haystack, const char *needle);
函数说明: 在 haystack 指向的字符串中查找 needle 指向的字符串，也是首次匹配
返回值:
    1. 找到了: 找到的字符串的首地址
    2. 没找到: 返回 NULL

#include <stdio.h>
#include <string.h>
int main(int argc, char *argy[])
{
 
    char s1[32] = "hella6dasdas";
    char *ret = strstr(s1, "6d");
    if (ret == NULL)
    {
        printf("NOT FOUND\n");
    }
    else
    {
        printf("GOT , IN POSITINO %d !  \n", ret - s1);
    }
 
    return 0;
}

输出结果

GOT , IN POSITINO 5 !  

7.7 字符串转换为数值 - atoi

atoi/atol/atof  //字符串转换功能
头文件:#include <stdlib.h>
函数的定义:int atoi(const char *nptr);
函数的功能: 将 nptr 指向的字符串转换成整数，返回

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argy[])
{
 
    char s1[32] = "12314";
    int ret1 = atoi(s1);
 
    printf("ret1 =  %d  \n", ret1);
 
    char s2[] = "3.1456414";
    double ret2 = atof(s2);
    printf("ret2 =  %lf  \n", ret2);
 
    return 0;
}

输出结果

ret1 =  12314  
ret2 =  3.145641

7.8 字符串切割函数 - strtok

#include<string.h>
char *strtok(char *str,const char *delim);
功能:对字符串进行切割
参数:
	str:要切割的字符串第一次切割，就传入指定的字符串，后面所有次的切割传NULL
    delim:标识符，要根据指定的delim进行切割，切割的结果不包含delim返回值:
返回切割下来的字符串的首地址，如果都切割完毕，则返回NULL

#include <stdio.h>
#include <string.h>
 
int main(int argc, char *argy[])
{
 
    char s1[32] = "12314:dasda1:54131das:31321das";
    char *ret1;
    ret1 = strtok(s1, ":");
    // 第一次切割
    printf("ret1 =  %s  \n", ret1);
	// 后面所有次的切割传NULL
    while ((ret1 = strtok(NULL, ":")) != NULL)
    {
 
        printf("ret1 =  %s  \n", ret1);
    }
 
    return 0;
}

ret1 =  12314  
ret1 =  dasda1  
ret1 =  54131das  
ret1 =  31321das  

7.9 格式化字符串操作函数

#include <stdio.h>
int sprintf(char *str,const char *format,...);
功能:将按照格式保存的字符串复制给str
参数:
	str:保存字符串
	format: 同printf
返回值:
	保存的字符串的字节数
 
#include<stdio.h>
int sscanf(const char *str,const char *format,...)
功能:scanf是从终端读取数据并赋值给对应变量，而sscanf是从第一个参数中读取数据
参数:
	str:指定要获取内容的字符串
	format:按照格式获取数据保存在变量中
返回值:
	成功获取的个数

#include <stdio.h>
 
void test1(){
    char buf[20];
    int a,b,c;
 
    sprintf(buf,"%d:%d:%d",2013,10,1);
    printf("buf = %s\n",buf);
}
 
void test2(){
    //1. 跳过数据：%s或%*d
    char buf1[20];
    sscanf("1234 5678","%*d %s",buf1);
    printf("%s\n",buf1);
 
    // 2. 读指定宽度的数据，%[width]s
    char buf2[20];
    sscanf("12345678","%4s",buf2);
    printf("%s\n",buf2);
 
    
    // 3. 支持集合操作:只支持获取字符串
    // %[a-z]  表示匹配a到z中任意字符(尽可能多的匹配)
    // %[aBc]  匹配a、B、c中一员，贪婪性
    // %[^aFc] 匹配非a、F、c的任意字符，贪婪性
    // %[^a-z] 表示读取除a-z以外的所有字符
    char buf3[20];
    sscanf("agcd32DajfDdFF","%[a-z]",buf3);
    printf("%s\n",buf3);
    return 0;
}
 
int main(int argc, char const *argv[])
{
    test1();
    test2();
    return 0;
}
 

输出结果

buf = 2013:10:1
5678
1234
agcd

7.10 const

// 1.const 修饰普通变量，代表只读的意思
const int a=100; //定义了一个只读变量a值为100, 以后在程序中，不能再给a赋值了
a=200;//错误的，a只读
 
// 2:const 修饰指针
// 意思是 str 指向的内存的内容,不能通过 str来修改
const char *str  

修饰全局变量

//const修饰全局变量
//此时全局变量只能使用，不能修改;
//如果直接拿全局变量修改值，编译直接报错;
//如果使用全局变量的地址修改值，运行时程序异常结束;
const int a =100;
void test1(){
    printf("a = %d\n",a);
    a = 6600; // 错误，编译直接报错
    
    int *p = &a;
    *p = 888; // 错误，运行时程序异常结束
    printf("a = %d\n",a);
}

修饰局部变量

//const修饰局部变量
//如果直接使用局部变量修改值，编译直接报错;
//如果使用局部变量的地址修改值，正确;
void test2(){
    const int b = 100;
    b = 666;			// 错误，编译直接报错
    printf("b = %d\n",b); 
    
    int *p = &a;
    *p = 888;   		// 正确，可以通过变量的地址修改值
    printf("a = %d\n",a);
}

修饰指针变量

// 如果const修饰指针变量的类型，无法通过指针变量来修改地址里面的值
	const int *p = &c;
// 如果const修饰指针变量，无法修改指针变量保存的地址
	int * const p = &c;
// 如果const既修饰指针变量的类型，又修饰指针变量，则只能通过原本变量修改值
	const int * const p = &c;