C语言函数

1.函数的概念

函数是 c 语言的功能单位， 实现一个功能可以封装一个函数来实现。

定义函数的时候一切以功能为目的， 根据功能去定函数的参数和返回值。

2.函数的分类

2.1从定义角度分类（即函数是谁实现的）

1.库函数 (c 库实现的)

2.自定义函数 （程序员自己实现的函数）

3.系统调用 (操作系统实现的函数)

2.2从参数角度分类

1.有参函数：函数有形参， 可以是一个， 或者多个， 参数的类型完全取决于函数的功能

int fun(int a,float b,double c)
{ } 
int max(int x,int y)
{ }

2.无参函数：函数没有参数,在形参列表的位置写个 void 或什么都不写

int fun(void)
{ } 
int fun()
{ }

2.3从返回值角度分类

(1).带返回值的函数

在定义函数的时候， 必须带着返回值类型， 在函数体里， 必须有 return

如果没有返回值类型， 默认返回整型。

例 1：

char fun()//定义了一个返回字符数据的函数
{
    char b='a';
    return b;
} 

例2：

fun()
{
    return 1;
}
//如果把函数的返回值类型省略了， 默认返回整型

注： 在定义函数的时候， 函数的返回值类型， 到底是什么类型的， 取决于函数的功能。

(2).没返回值的函数

在定义函数的时候， 函数名字前面加 void

void fun(形参表)
{
    ; 
    ; 
    return ;
    ;
} 
//在函数里不需要 return
//如果想结束函数， 返回到被调用的地方， return ;什么都不返回就可以了

例 3：

#include <stdio.h>
int max(int x,int y)
{
    int z;
    if(x>y)
        z=x;
    else
        z=y;
    return z;
} 
void help(void)
{
    printf("*********************\n");
    printf("********帮助信息*****\n");
    printf("*********************\n");
} 
int main(int argc, char *argv[])
{
    int num;
    help();
    num = max(10,10+5);
    printf("num=%d\n",num);
    return 0;
}

3. 函数的定义

即函数的实现

3.1函数的定义方法

返回值类型 函数名字(形参列表)
{
    //函数体， 函数的功能在函数体里实现
}

例 4：

int max(int x, int y)
{
    int z;
    if(x>y)
        z=x;
    else
        z=y;
    return z;
}

注： 形参必须带类型， 而且以逗号分隔

函数的定义不能嵌套， 即不能在一个函数体内定义另外一个函数，

所有的函数的定义是平行的。

例 5：

void fun(void)
{
    ; 
    ; 
    ;
    void fun2(void)
    {
        ;
    }
} 
//这个程序是错误的， 不能再 fun 的函数体中， 定义 fun2 函数。

例 6：

void fun(void)
{
    ; 
    ; 
    ;
}
void fun2(void)
{
    ;
}
//这个程序是正确的， fun 和 fun2 是平行结构

注： 在一个程序中， 函数只能定义一次,给函数起名字的时候， 尽量的见名知意， 符合 c 语言的命名规则

4. 函数的声明

4.1概念

对已经定义的函数， 进行说明

函数的声明可以声明多次。

4.2为什么要声明

有些情况下， 如果不对函数进行声明， 编译器在编译的时候， 可能不认识这个函数，

因为编译器在编译 c 程序的时候， 从上往下编译的。

4.3声明的方法

4.3.1 主调函数和被调函数在同一个.c 文件中的时候

1] 被调函数在上， 主调函数在下,这种情况下不需要声明

例 7：

void fun(void)
{
    printf("hello world\n");
} 
int main()
{
    fun();
} 

2] 被调函数在下， 主调函数在上

编译器从上往下编译， 在 main 函数（主调函数） ， 不认识 fun， 需要声明

例 8：

int main()
{
    fun();
} 
void fun(void)
{
    printf("hello world\n");
} 

1）直接声明法

将被调用的函数的第一行拷贝过去， 后面加分号

例 9：

void fun(void);
int main()
{
    fun();
} 
void fun(void)
{
    printf("hello world\n");
}

2）间接声明法

将函数的声明放在头文件中， .c 程序包含头文件即可

例 10：

a.c
#include” a.h”
int main()
{
    fun();
} 
void fun(void)
{
    printf("hello world\n");
}

a.h
extern void fun(void);

4.3.2主调函数和被调函数不在同一个.c 文件中的时候

一定要声明

直接声明法

将被调用的函数的第一行拷贝过去， 后面加分号， 前面加 extern

间接声明法

将函数的声明放在头文件中， .c 程序包含头文件即可

5. 函数的调用

5.1函数的调用方法

//带返回值的
函数名(实参列表);//不带返回值的

5.1.1有返回值的

根据返回值的类型， 需要在主调函数中定义一个对应类型的变量， 接返回值

变量= 函数名(实参列表);

例 11：

int max(int x,int y)// x、 y 形参， 是个变量
{ } 
int main()
{
    int num;//需要定义一个 num 接收 max 函数的返回值
    num=max(4,8);//4 和 8 就是实参
}

5.1.2没有返回值的函数

不需要接收返回值。

例 12：

void fun(void)
{
    printf("hello world\n");
}

int main()
{
    fun();
}

5.1.3有无形参

函数名(实参列表);//带形参的
函数名();//没有形参的

注意： 实参， 可以常量， 可以是变量， 或者是表达式
形参是变量， 是被调函数的局部变量。

6.递归

递归指的是在函数的定义中使用函数自身的方法。

举个例子：
从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？"从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？'从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？……'"

语法格式如下：

void recursion()
{
   statements;
   ... ... ...
   recursion();
 /* 函数调用自身 */   ... ... ...
} 
int main()
{
   recursion();
}

流程图：

C 语言支持递归，即一个函数可以调用其自身。但在使用递归时，程序员需要注意定义一个从函数退出的条件，否则会进入死循环。

递归函数在解决许多数学问题上起了至关重要的作用，比如计算一个数的阶乘、生成斐波那契数列，等等。

数的阶乘

下面的实例使用递归函数计算一个给定的数的阶乘：

//实例
#include <stdio.h> 
double factorial(unsigned int i)
{
   if(i <= 1)
   {
      return 1;
   }
   return i * factorial(i - 1);
}
int  main()
{
    int i = 15;
    printf("%d 的阶乘为 %f\n", i, factorial(i));
    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

15 的阶乘为 1307674368000.000000

斐波那契数列

下面的实例使用递归函数生成一个给定的数的斐波那契数列：

实例

#include <stdio.h> 
int fibonaci(int i)
{
   if(i == 0)
   {
      return 0;
   }
   if(i == 1)
   {
      return 1;
   }
   return fibonaci(i-1) + fibonaci(i-2);
} 
int  main(){
    int i;
    for (i = 0; i < 10; i++)
    {
       printf("%d\t\n", fibonaci(i));
    }
    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

0    
1    
1    
2    
3    
5    
8    
13    
21    
34