学习C的每一天--这是我的函数

我们从小到大在接触函数的过程中，或多或少的接触的就是和函数相关的内容。

一次函数，幂次函数，三角函数，双曲函数，指对数函数，隐函数等等一系列。和 函数概念含有三个要素：定义域A、值域B和对应法则f。

而在计算机语言中函数的定义：是一个固定的一个程序段，或称其为一个子程序

函数在使用时必须带上括号，必要时还要传递参数，函数的执行结果也可以赋值给其它变量。

一、什么是函数：

解释：

Function在计算机语言中多以“功能”称之，在语言学习中有着必不可少的直观重要的作用

库函数 与 自定义函数：

（1）库函数【Library function】：各种里的带有某种“功能”的封装好的函数

例如：引用#include<math.h>中的sqrt就可以开平方；同样的引用pow就是幂次。

#include<stdio.h>
#include<math.h>
int main(){
   int n,m;
   scanf("%d%d",&n,&m);
   printf("%.0f",pow(n,m));
   return 0;
}

在这里pow属于是已经被封装好的库函数。而在我们学习过程中：

不管是库函数还是自定义函数都需要 注意其函数原型及其返回值。

pow的函数原型： | pow的函数返回值
double pow（double x，double y） | x^y

（2）自定义函数【Custom function】：需要用户自己手动写出来的一类对程序功能有益的函数。

判断是不是素数

#include <stdio.h>
#include <math.h>
    //是素数返回1  不是素数返回0
    int  is_prime(int n){
        int j;
        for(j=2;j<=sqrt(n);j++){
            if(n%j==0) return 0;
        }return 1;
    }

    int main(){
        int i=0;
        scanf("%d",&i);
            if(is_prime(i)==1)
               printf("yes");
            else printf("no");
    }

（3）对比：

库函数:

优点：

1）拥有库函数的比自定义的函数代码量少，简洁；

如：我们常用的排序算法就是快排，在快排手打的过程中有许多要注意的地方，而我们利用#include<stdlib.h>里的qsort就几行就结束了。

2）方便代码的维护；

3）只需要注意返回值是什么就好了

缺点

但对于没有见过函数原型的程序员来说是不懂的。

自定义函数

优点：

可以补充库函数中没有的，在以后工作的时候，公司会有有自己的一套函数，去封装我们这是就可以写一段去扩充不足的库。

缺点：

如果程序崩溃是难以找见在那个地方的，还得具备多个地方的注释。

我在这之前见到的一个表情包最好解释了：

---

二、声明与定义

声明：

为了使得编译器知道如何对调函数，这样使用函数。写成下面这样式

type function_name( parameter list );

type 是函数返回的值的数据类型。有些情况下写成void就不需要在最后写return了
function_name 函数名称要和main函数里调用的名称一样

针对max的函数

int max(int n,int m);

定义：

type function_name( parameter list )
{
   body of the function
}

函数类型【type】 是函数返回的值的数据类型。有些情况下写成void就不需要在最后写return了
函数名 【fuction_name】： 函数名称要和main函数里调用的名称一样
函数主体【body of the function】：函数主体包含一组定义函数执行任务的语句。
返回值 【return type 】如果有返回值，在函数体中使用 return 语句返回。return 出来的数据的类型要和 type 一样。

针对max的函数

int max(int n,int m){
  return n>m?n:m;
}

调用函数【两种写法】：

第一种：

#include<stdio.h>
int max(int n,int m);//函数声明
int main(){
  int n,m;
  scanf("%d%d",&n,&m);
  printf("%d",max(n,m));//调用函数
}
int max(int n,int m){//定义了函数的样子
  return n>m?n:m;
}

第二种：

#include<stdio.h>
int max(int n,int m){//定义了函数的样子
  return n>m?n:m;
}
int main(){
  int n,m;
  scanf("%d%d",&n,&m);
  printf("%d",max(n,m));//调用函数
}

我更喜欢第二种写法，直接将main主函数写在下面，剩下的自定义函数就写在上面就好了。

值得注意的是：

如果不是声明函数（想第二种写法）我们一定要注意到的是，如同C语言的关键字一样的，定义了就不要再用这个名字去做别的事情了

三、作用域（生命周期）：

1.>全局变量：

1）使用全局变量会占用更多的内存（因为其生命期长）。
2）整个程序都可以用到。
3）使用全局变量程序速度更快一些（因为内存不需要再分配），同样也快不了多少。
4）当全局变量与局部变量重名的时候，起作用的是局部变量，全局变量被屏蔽掉。

#include<stdio.h>
int a=10;//全局变量
int main(){
  int b=20;//相对于a来说是局部变量
  while（1）{
     int t;//这是在main主函数里的局部变量}
}

2.>局部变量：

1)也称内部变量，是指在一个函数内部或复合语句内部定义的变量。
2)局部变量的生存期：从函数被调用的时刻算起到函数返回调用处的时刻结束。
3)局部变量可以和全局变量重名，但是局部变量会屏蔽全局变量。：

#include<stdio.h>
int a=10;
int main(){
   int a=20;
   printf("%d",a);//20
return 0;
}

四、传值调用 VS 引用调用

1）是选择形参?还是选择实参?

#include <stdio.h>
//这个是形参  交换 实参不换
//传值调用
void  swap1(int x,int y){
    int tmp;
    tmp=x;
    x=y;
    y=tmp;
   printf("ax=%d,by=%d\n",x,y);//ax=20,by=10
}
//传址调用(对内部操作)
void swap2(int *pa,int *pb){
    int tmp;
    tmp=*pa;
    *pa=*pb;
    *pb=tmp;
}
int main(){
    int  a=10,b=20;
    printf("a=%d  b=%d\n",a,b);//a=10,b=20

    swap1(a,b);
    printf("a=%d  b=%d\n",a,b);//a=10,b=20;

    swap2(&a,&b);
    printf("a=%d  b=%d ",a,b);//a=20,b=10'
    }

形参是改变自己内部的，不改变实际地址的内容，当形参这一段代码执行完毕，就自动销毁，并释放空间。

实参能够改变实际地址的内容

2）传值调用：

#include <stdio.h>
int is_leap_year(int y){
    if((y%4==0&&y%100!=0)||(y%400==0))
           return 1;
           //在这里
    else
            return 0;
}
int main(){
    int year=0;
    int count=0;
    //如果初试的year是4的倍数的话year++可以替换为year+=4
    for(year=1000;year<=2000;year++){
        //判断year是否为闰年
        if(is_leap_year(year)==1){
            count++;
            printf("%d\n",year);
            printf("%d",count);
        }
    }
    return 0;
}

3）引用调用

//每次用一次函数num增加1
//暂时没有返回值时用void
#include <stdio.h>
void add(int *c){
    (*c)++;//    如果形式是*c++   的话  因为++的优先级比*高
                //所以要先将*c放进括号里
}

int main(){
    int num=0;
    //函数执行一次就+1.函数内部改变num  因此利用传址
    add(&num);
    printf("%d",num);
}

五、结构体传参

#include <stdio.h>
typedef struct stu{
    char name[20];
    int age;
    char tele[112];
    char sex[5];
}stu;

void printg1(stu tmp){//传什么类型的参数，形参就是什么类型
    printf("name:%s\n",tmp.name);
    printf("age:%d\n",tmp.age);
    printf("tlele:%s\n",tmp.tele);
    printf("sex:%s\n\n",tmp.sex);
}


void printg2(stu* ps){//由于重命名产生的stu   如果没有typedef的话里面需要写的是struct    stu*
     printf("name:%s\n",ps->name);
    printf("age:%d\n",ps->age);
    printf("tlele:%s\n",ps->tele);
    printf("sex:%s\n\n",ps->sex);
}

//一定要在结构体传参（传结构体地址）的时候选择指针
int main(){
 stu s={"li",32,"123","qe"};
     //打印结构体数据
     printg1(s);
     //形参和实参都要战空间和时间
     printg2(&s);
     //传参压栈，结构体过大，性能会下降
}

六、自写

写strcpy

#include <stdio.h>
void my_strcpy(char *dest,char* src){
    while(*src!='\0'){
        *dest=*src;
        src++;
        dest++;
    }*dest=*src;   //这一步是拷贝‘\0’
}
int main(){
    //strcpy
    char arr1[]="########";
    char arr2[]="bit";
    //后面隐藏了“\0”
    my_strcpy(arr1,arr2);
    printf("%s\n",arr1);
}