函数的奇妙世界

函数的声明和定义

函数的定义

c语言通过函数实现模块化程序设计，除了main()函数之外的还有两种函数

函数又分为库函数和自定义函数

库函数(标准函数)：由c语言系统提供的。程序员可以直接调用的函数

例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[] = "hello world!";
    memset(arr,'*',5);
    printf("%s\n",arr);
    return 0;
} 

自定义函数：程序员把自己编写的一个过程、功能和算法定义为一个函数。如果函数不需要返回一个值，那么返回值类型写void。有时函数需要任何形参，则（）为空，或者写（void），但是（）绝对不能省略。

函数形式：
返回值类型 函数名(类型1 形参变量1,类型2 形参变量2,...类型n 形参变量n)
{
语句；
return 返回值；//将结果返回给调用的位置
}

例如：计算两数相加的和

#include <stdio.h>
int add(int x,int y){
    int z = 0;
    z = x+y;
    return z;
}

int main()
{
    int a =10;
    int b = 20;
   int sum = add(a,b);
   printf("%d\n",sum);
    return 0;
}

函数的声明

最好不要省略，有时可以推断函数的作用和参数的意义

int Add(int x,int y);
//这里也可以这样写 int Add(int ,int );

函数的调用和链式访问

函数的调用

函数之间是可以相互调用的，函数调用要注意几个点：

1、如果函数定义中没有形参，则调用函数（）为空，但是（）不能省略
2、调用函数时相当于对应的实参给形参赋值，所以函数调用中实参必须是确定的值，实参和形参在数和顺序上必须完全一致，且实参和形参兼容
3、除了将函数调用单独作为一条语句，对于有返回值的函数，整个函数的结果就是函数的返回值，所以可以将函数调用作为一个”数值“使用

int a = gcd(4，6)；//调用结果赋值给a
int b = gcd(4,6)+5；//调用结果参与其他运算
int c  = gcd(8,gcd(4，6))；//调用结果作为函数调用的实参

4、函数可以嵌套调用

void f2()
{
}
void f1()
{
f2();
}
int main()
{
f1();
return 0；
}

函数的链式访问

#include <stdio.h>
#include <string.h>
int main()
{   //1、平时写的
    int len  = 0;
    len = strlen("abc");
    printf("%d\n",len);
    //链式访问
    printf("%lu\n",strlen("abc"));//结果为：3
    //有趣的链式访问，
    //解读：printf()函数的返回值为该函数的打印的字符数，从里往外输出
    //第一次：最里面的打印了43
    //第二次：中间的则打印了4和3的个数为：2
    //第三次：最外面的则打印了2的个数为：1
    printf("%d",printf("%d",printf("%d",43)));//结果为：4321

    return 0;

}

函数参数-举例说明

例题：交换两个数的值

// 方法一：x，y 和 a,b都是自己独立的一块地址不是一样的，两个并没有关系，所以最后是没有交换成功的
#include <stdio.h>

void  swap1(int x,int y){
    int temp = 0;
    temp = x;
    x = y;
    y = temp;

}
int main(){
    int a =10;
    int b =20;
    printf("a = %d,b= %d\n",a,b);
    swap1(a,b);
    printf("a = %d,b= %d\n",a,b);
    return 0;
} 

方法一总结，当时实参传给形参的时候，形参其实是实参的一份临时拷贝，对形参的修改是不会改变实参的（传值调用）

//方法二：
#include <stdio.h>
void swap2(int * pa,int *pb){//指针
    int temp = 0;
    temp  = *pa;//解引用符
    *pa = *pb;
    *pb = temp;

}
int main(){
    int a =10;
    int b =20;
    printf("a = %d,b= %d\n",a,b);
    //调用函数
    swap2(&a,&b);
    printf("a = %d,b= %d\n",a,b);
    return 0;
} 

方法二总结：是把地址传过去了，通过地址可以直接的找回来a和b（传址调用）

例题 1、判断100-200之间的数是否为素数

#include <stdio.h>
#include <math.h>
int is_prime(int n){
   int j = 2;
   //产生2~n-1的数字
        for(j = 2;j <= sqrt(n);j++){
            if(n % j == 0) {
                return 0;
            }
        }    
       return 1;  
}

int main()
{
    int i = 0;
    //要判断的范围
    for(i = 100;i <= 200;i++){
        //判断是否为素数，调用函数is_prime
        if(is_prime(i) == 1){
            printf("%d\t",i);
        }
    }
    return 0;
}

例题2、判断1000-2000年间的闰年

#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 i = 1;
    for(i = 1000;i<=2000;i++){
        //判断year是否为润年
       if (is_leap_year(i) == 1 ){
           printf("%d \n",i);
       }
    }
    return 0;
}

数组名做函数参数

数组作用函数参数有两种形式：一种是把数组元素（下标变量）作函数参数；另一种是把数组名作为函数的形参和实参使用。

1、数组元素做函数参数：数组中的每个元素都是带下标的变量，和普通的变量并没有差别，
例如：求函数的最大公约数中的一部分
int a[2] = [4,6];
int b = gcd(a[0],a[1]);

2、数组名做函数参数：数组名就是数组的首地址值，也就是把数组的首地址值作为实参传给了形参
说明：
（1）数组名做函数参数，应该在调用函数和被调用函数中分别定义数组，且数据类型必须一致。
（2）地址传递方式，实参与形参共用地址，相当于对同一数组的两个不同名字。C语言编译系统对形参数组大小不作检查，所以形参数组可以不指定大小。

例题：二分法查找，在一个数组中查找某个数

#include <stdio.h>
#include <string.h>
int binary_search(int arr[],int k,int sz)
{
    //算法实现
    int left = 0;//左下标
    //int sz = sizeof(arr)/sizeof(arr[0]);//本质上arr是一个指针
    int right = sz - 1;//右下标
    
    if(left <= right){//一定要写=，当左右下标相等的时候的时候有=的情况
        int mid = (left+right)/2; //中间元素下标,必须写在循环里面
        if(arr[mid] < k){
            left = mid + 1;
            }
        else if(arr[mid] > k){
            right = mid -1;
        }else
         return mid;
    }
        return -1;
    }
int main()
{   //找到了返回数组的下标，没找到返回-1
    int arr[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14}; 
    int k = 17;
    int sz = sizeof(arr)/sizeof(arr[0]);
    int ret = binary_search(arr,k,sz);//传递过去的是数组arr首元素的地址
    if(ret == -1){
        printf("未找到指定的数字\n");
    }
    else
    printf("找到了,下标是：%d\n",ret);
    
    return 0;
}

函数递归

例题1、递归：输入12345 输出1 2 3 4 5

#include <stdio.h>
void print(int n)
{
    if(n>9){     //条件很重要：不会栈溢出 重要
        print(n/10);
    }
    printf("%d ",n%10); //重要：每次递归之后，越来越接近限制条件
}
int main()
{
    int num = 0;
    printf("请输入一个数字:");
    scanf("%d",&num);
    print(num);
    
    return 0;
}

例题2、自己设计函数，不创建临时变量（递归），求字符长度

//自己设计函数，不创建临时变量（递归），求字符长度
#include <stdio.h>
int my_strlen2(char *str)
{
    if(*str != '\0'){
        return 1 + my_strlen2( str + 1);
    }else{
        return 0;
    }
    
}

//求字符串长度(自己设计函数)
int my_strlen1( char* str){
    //创建了临时变量
    int count = 0 ;
    while(*str !=  '\0'){
        count ++;
        str ++;
    }
    return count;
}

int main()
{   
    char arr[] = "bit";
    int len = my_strlen2(arr);//arr是数组数，数组传参，传过去的不是整个数组，而是第一个元素的地址
    printf("len = %d\n",len);
    return 0;
} 

例题3、迭代：求n的阶乘

#include <stdio.h>
int Fac( int n)
{   if( n <= 1)    //阶乘是没有负数的
        return 1;
    else
    return  n*Fac(n-1);
}
int main()
{
    int i = 0;
    int ret = 0;
    printf("请输入一个数字:");
    scanf("%d",&i);
    ret = Fac(i);
    printf(" ret = %d\n",ret);
    return 0;
}

例题4、斐波那契数列

1 1 2 3 5 8 13 21 34 55(前两个数等于第三个)
有递归（慢）和循环（快）的比较

#include <stdio.h>
 int Fib2(int n)
{
    int a  = 1;
    int b = 1;
    int c = 1;
    while(n > 2){
        c = a+b;
        a = b;
        b = c;
        n--;
    }
    return c;
}

//Fib(算的效率太低)
int count  = 0;
int Fib(int n)
{   
    if( n == 3){
        count++;//测试这种方法算的时候，会调用多少次n == 3
    }
    if(n <= 2){
        return 1;
    }else{
        return Fib(n-1)+Fib(n-2);
    }
}

int main()
{
    int i = 0;
    int ret = 0;
    printf("请输入一个数字：");
    scanf("%d",&i);
    ret = Fib2(i);
    printf("ret = %d\n",ret);
    //printf("count=%d\n",count);
    return 0;
}

递归总结：
当递归的两个条件都满足的时候是不是就不会溢出？
答案：会
例如：

#include <stdo.h>
void test(int n)
{
    if(n<10000){
        test(n+1);
    }
}
int main(){
    test(1);
    return 0;
}