函数（new)

函数（new)

一、字符串处理函数

1.字符串的输入

（1）scanf()

#include <stdio.h>
int mian()
{
    char buf[100]={0};
    printf("请输入字符串：");
    scanf("%s",buf);//不需要&,默认以空格分开
    printf("buf=%s\n",buf);
    
    char tmp[100]={0};
    printf("请输入字符串：");
    scanf("%s",tmp);
    printf("tmp=%s\n",tmp);
    //用户输入hello dd
    //scanf("%s",buf);
    //取第一个空格前的字符串即取hello
    //scanf("%s",tmp);
    //取缓冲区剩下的内容，即dd，\n不取
    return 0;
    //scanf()的缺陷，不做越界检查，此函数不安全
}

（2）gets()

#include <stdio.h>
char *gets(char *s);
//功能：从标准输入读入字符，并保存到s指定的内存空间，直到出现换行符或文件结尾为止
//参数：s:字符串首地址
//返回值：
//成功：读入的字符串
//失败：NULL

#include <stdio.h>
int main()
{
    char buf[100];
    //gets()从键盘读取字符串，放在指定的数组
    //gets()允许有空格，不做越界检查，此函数不安全
    gets(buf);
    printf("but=%s\n",buf);
    
    return 0;
}

（3）fgets()

#include <stdio.h>
char *fgets(char *s,int size,FILE *stream);
//功能：从stream指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行字符，读到文件结尾或是已读了size-1个字符，最后会自动加上字符'\0'作为字符串结束
//参数：
//s:字符串
//size:指定最大读取字符串的长度（size-1)
//stream:文件指针，如果读键盘输入的字符串，固定写为stdin
//返回值：
//成功：成功读取的字符串
//读到文件尾或出错：NULL

#include <Stdio.h>
int main()
{
    char but[10];
    //从stdin（代表标准输入，键盘），读取内容
    //如果输入内容如果大于sizeof(buf)-1，只取sizeof(buf)-1，放在buf所在的数组
    //会把换行符也读进去
    fgets(buf,sizeof(buf),stdin);
    printf("buf=%s\n",buf);
    
    return 0;
}

2.字符串的输出

（1）printf()

(2)puts()

#include <Stdio.h>
int puts(const char *s);
//功能：标准设备输出s字符，在输出完成后自动输出一个'\n'
//参数：
//s：字符串首地址
//返回值
//成功：非负数
//失败：-1

#include <stdio.h>
int main()
{
    char buf[]="hello"；
    puts(buf);//把buf内容输出到屏幕，自动在屏幕加换行，是在屏幕加，字符本身没有变量
    printf("%s",buf);//没有加换行符
    
    return 0；
}

(3)fgets()

#include <stdio.h>
int fputs(const char *str,FILE * stream);
//功能：将str所指定的字符串写入到stream指定的文件中，字符串结束符'\0'不写入文件
//参数：
//str:字符串
//stream：文件指针，如果把字符串输出到屏幕，固定写为stdout
//返回值：
//成功：0
//失败：-1

#include <stdio.h>
int main()
{
    char buf[]="hello";
    //往stdout(代表屏幕，标准输出)输出buf内容
    fputs(buf,stdout);
    
    return 0;
}

3.strlen的使用

#include <Stdio.h>
#include <string.h>//strlen()的头文件
size_t strlen(const char *s);
//功能：计算指定指定字符串s的长度，不包含字符串结束符'\0'
//参数：
//s:字符串首地址
//返回值：字符串s的长度，size_t为unsigned int类型

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

int main()
{
    char buf[]="hello";
    //strlen需要使用返回值，返回值就是字符串的长度
    //从首元素开始，到结束符为止的长度，结束符不算(遇到'\0'结束)
    int len=strlen(buf);
    printf("len=%d\n",len);//5
    printf("sizeof(buf)=%lu\n",sizeof(buf));//6 多了一个结束符\0
    
    char buf2[]="\0hello";
    len=strlen(buf2);
    printf("len2=%d\n",len)//0
    //sizeof是测数据类型的长度，不会因为结束符提前结束
    printf("sizeof(buf2)=%lu\n",sizeof(buf2 ));//7
    
    char str[100]="mike";
    printf("strlen(str)=%lu\n",strlen(str));//4
    printf("strlen(str)=%lu\n",sizeof(str));//100
    
}

4.字符串的拷贝

（1）strcpy()

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

int main()
{
    char src[100]="hello mike";//源字符串
    char dst[100];//目的
    
    //功能：把src字符数组的内容拷贝给dst所代表的数组
    strcpy(dst,src);//不可dst=src是因为二者均为常量，不可改变
    printf("dst=%s\n",dst);
    
    //拷贝原理：从首元素开始，遇到结束符'\0'结束
    char src2[100]="hello\0 mike";//原字符串
    char dst2[100];//目的
    
    strcpy(dst2,src2);
    printf("dst2=%s\n",dst);//hello
    
    return 0;
}

(2)strncpy()

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

int main()
{
    char src[100]="hello\0 mike";//原字符串
    char dst[100];//目的
    //功能：把src字符数组前8个字符的内容拷贝给dst所代表的数组
    //可以把'\0'拷贝过去，但是'\0'后面的内容无法拷贝
    strcnpy(dst,src，8);
    printf("dst=%s\n",dst);//hello 因为仍遇到结束符
    printf("dst=%s\n",)
    
    return 0;
    
}

（3）数组越界测试

char src[100]="uiuiuiybuiuyfydtvyvub";
char dst[10];
strcpy(dst,src);

5.字符串的比较

比较每个字符的ASCII

（1）strcmp()

#include<string.h>
int strcmp(const char *s1,const char *s2);
//功能：比较s1与s2的ASCII的大小
//参数：
//s1字符串1的首地址
//s2字符串2的首地址
//返回值：
//相等：0
//大于：>0
//小于：<0

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

int main(int argc,char *argv[])
{
    char s1[]="abc";
    char s2[]="abcd";
    
    int flag=strcmp(s1,s2);
    int flag=strncmp(s1,s2,3)//加个n代表比较前3个字符
    if(flag>0)
    {
        printf("[%s]>[%s]\n",s1,s2);
    }
    
    else if(flag<0)
    {
        printf("[%s]<[%s]\n",s1,s2);
    }
    
    else
    {
        printf("[%s]==[%s]\n",s1,s2);
    }
}

6.字符串的追加

(1)strcat()

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

int main(int argc,char *argv[])
{
    char src[]="hello mike";
    char dst[100]="abc";
    //把src的内容追加到dst的后面
    strcat(dst,src)；
    strncat(dst,src,strlen("hello"));//指定长度追加
    printf("dst=%s\n",dst;//dst="abc hello mike")
}

7.sprintf的使用

#include <stdio.h>

int main(int argc,char *argv[])
{
    int a=10;
    char ch='d';
    char buf[]="hello";
    
    //格式化一个字符串，把这个字符串输出到屏幕上
    printf("a=%d,ch=%c,buf=%s\n",a,ch,buf);
    
    char dst[100];
    //格式化一个字符串。把这个字符串输出到（保存在）指定的数组
    sprintf(dst,"a=%d,ch=%c,buf=%s\n",a,ch,buf);
    
    printf("@@%s@@",dst);
    
    return 0;
}

8.sscanf()的使用

#include <stdio.h>

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

#include <stdio.h>

int main()
{
    char buf[]="1 2 3";
    int a,b,c;
    //从buf中以指定的格式提取内容
    sscanf(buf,"%d %d %d",&a,&b,&c);
    printf("a=%d,b=%d,c=%d\n",a,b,c);
    
    char str1[]="a=1,b=2,c=3";
    a=0;
    b=0;
    c=0;
    sscanf(str,"a=%d,b=%d,c=%d",&a,&b,&c);
    printf("a1=%d,b1=%d,c1=%d\n",a,b,c);
    
    char str2[]="1,2,3";
    a=0;
    b=0;
    c=0;
    sscanf(str,"%d,%d,%d",&a,&b,&c);
    printf("a2=%d,b2=%d,c2=%d\n",a,b,c);
    
    char tmp[]="abc mike 250";//提取字符串，默认以空格分隔，可以提取
    char m[10],n[10],k[10];
    sscanf(tmp,"%s %s %s",m,n,k);//不用&，以因为数组名就是首元素地址
    
    return 0;
}

9.字符串查询

（1）strchr()用于查询char类型

#include <string.h.>
char *strchr(const char *s,int c);
//功能；在字符串中查找字母出现的位置
//参数：
//s字符串首地址
//c匹配字母(字符)
//返回值；
//成功：返回第一次出现的地址
//失败；NULL

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

int main(int argc,int *argv[])
{
    char buf[]="acbdefg";
    //在buf中查询字符d，如果找到，返回d所在位置的地址
    //如果查询失败，返回NULL
    char *p=strchr(buf,'p')
    if(p=NULL)
    {
        printf("查询失败\n")
    }
    else
    {
        printf("p=%s\n",p);//得到defg，打印d以后的字符
    }
}

（2）strstr()用于查询string类型

#include <string.h>
char *strstr(const char *haystack,const char *needle);
//功能：在字符串haystrack中查找字符串needle出现的位置
//参数：
//haystrack:源字符串首地址
//needle：匹配字符串首地址
//返回值：
//成功：返回第一次出现的needle地址
//返回值：
//成功：返回第一次出现的needle的地址
//失败：NULL
     

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

int main(int argc,int *argv[])
{
    char buf[]="abcdefg";
    //在buf中查询字符串“cde”，如果找到，返回d所在位置的地址
    //如果查询失败，返回NULL
    char *p=strstr(buf,"cde")
    if(p=NULL)
    {
        printf("查询失败\n")
    }
    else
    {
        printf("p=%s\n",p);//得到defg，打印d以后的字符
    }
}

10.字符串的切割

（1）strtok()

#include<string.h>
char *strtok(char *str,const char *delim);
//功能：来将字符串分割成一个个片段，当strtok()在参数的字符串中发现参数delim中包含的分割字符时，则会将改字符改为0字符，当连续出现多个时只替换第一个为0

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

int main(int argc,char *argv[])
{
    char buf[]="abc,mike,jiang,250";
    
    //第一个调研
    //第一个参数写源字符串，第二个参数写切割字符
    //返回值就是切割后的字符串
    //在匹配切割字符的地方换成结束符
    //使用strtok()会破坏原来字符串的结构
    char *p=strtok(buf,",")
    printf("p=%s\n",p);//abc
    printf("buf=%s\n",p);//abc
    printf("buf[3]=%d\n",buf[3]);//0
}

11.atoi()

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

类似的函数还有：

atof():把一个小数形式的字符串转化为一个浮点数。

atol():把一个字符串转化为long类型。

char str1[]="-10";
int num1=atoi(str1);
printf("num1=%d\n",num1);

char str2[]="0.123";
double num2=atof(str2);
printf("num2=%if\n",num2);

二、函数的分类和作用

1.函数的分类

C程序是由函数组成的，我们写的代码都是由主函数main()开始执行的，函数是C程序的基本模块，是用于完成特定任务的程序代码单元。

从函数的定义角度看，函数可分为系统函数与用户定义函数两种。

（1）系统函数

即为库函数，是编译系统提供的，用户不必自己定义这些函数，可以直接使用它们，如我们常用的打印函数printf().

(2)用户定义函数

用于解决用户的专门需要

三、函数的使用

1.无参无返回值的函数的使用

（1）无参无返回值函数的定义

// 没有返回值，用void关键字修饰
// 没有参数，可用void，也可空
// 第一个void代表返回值，fun代表函数名字，（）内部表示参数，空就是无参，{}就是函数体
//同一个文件不能出现同名函数
//不同的函数内部的变量是没有关系的
void fun(void)//等价于void fun(void)
{
    //函数内部，包含（）内部的变量，只有在调用时分配空间，调用完毕自动释放
    printf("abc");
    int a=10;
    int b=20;
    printf("a+b=%d\n",a+b);
     
}

int main(int argc,char *argv[])
{
    //除了主函数main（），其他函数只有调用了才起作用
    //函数的调用不可能出现void关键字
    //无参无返回值函数的调用格式：函数名字（）
    //fun(void);//err
    fun();
}

（2）有参无返回值的函数

//定义函数的参数叫做形参，形惨的格式必须为：类型+变量，不可赋值
//void fun1(ina a=10)//err
//函数没有调用，形参变量不会分配空间，函数调用完毕，形参变量会自动释放
//如果形参有多个，用逗号，隔开
//void fun2(int a,char ch,char buf[100]))
void fun1(int a,char ch,char buf[100])
{
    printf("a=%d\n",a);
}

int main(int argc,char *argv[])
{
    int a=10;
    //有参无返回值函数的调用
    //如果函数定义是有参数，调用时必须传参
    //fun1();//err
    //有参数函数调用形式:函数名字（匹配类型参数）
    //匹配类型参数可以是变量、常量、表达式
    //函数调用时传的参数，叫实参
    //只能把实参的值传递给形参，不能反过来，单向传递
   //函数的形参有多个，传参也用逗号隔开
    fun1(10);//
}
    

（3）无参有返回值的使用

//无参有返回值的函数的定义
//第一个int代表函数的返回类型，函数内部通过return返回
//返回值可以是变量，常量，表达式
//函数返回值只能返回一个
//如果return的类型与返回类型不一致，以函数返回类型为准
int fun()
{
    return 10;//返回常量
}

int fun1()
{
    int a=11;
    int b=20;
    return a>b?a:b;//返回表达式
}

int fun3()
{
    return 10.11;//把10.11转换为int后再返回
}

int main(int argc,chat *argv[])
{
    //如果函数有返回值，这个函数的返回值可以不用
    fun()//ok这个函数的返回值可以不用
    //如果使用返回值，最好要定义匹配类型的变量来接收
    int a=fun();
    printf("a=%d\n",a);
    
    int b;
    b=fun();
    printf("b=%d\n",b);
    
    printf("tmp=%d\n",fun());
}