函数
函数的定义
在使用函数前必须定义或者声明函数
double circle(double r);
int main(){
double length = circle(10);
printf("length = %f\n", length);
return 0;
}
double circle(double r)
{
return 2 * 3.14 * r;
}
函数的具体形式:
返回值类型 函数名([[参数类型 参数名1],[参数类型 参数名2],……,[参数类型 参数n]])
{
执行语句
………
return 返回值;
}
/*
返回值类型：用于限定函数返回值的数据类型；
函数名：表示函数的名称，该名称可以根据标识符命名规范来定义；
参数类型：用于限定调用方法时传入参数的数据类型；
参数名：用于接收调用方法时传入的数据；
return关键字：用于结束函数，并返回函数指定类型的值；
返回值：被return语句返回的值，该值会返回给调用者。如果函数没有返回值，则返回值类型要声明为void，此时，函数体中的return语句可以省略不写。
*/
在上面的语法格式中，函数中的“[[参数类型 参数名1],[参数类型 参数名2],…,[参数类型 参数n]]”被称作参数列表，它用于描述函数在被调用时需要接收的参数。如果函数不需要接收任何参数，则参数列表为空，这样的函数被称为无参函数。相反地，参数列表不为空的函数就是有参函数。接下来分别讲解这两种函数。
在定义函数时函数名后面括弧中的变量名称为“形式参数”，简称形参。在调用函数时，函数名后面括号中的变量或表达式称为“实际参数”，简称实参。
在调用函数的时候，函数大多数都有参数，主调函数和被调用函数之间需要传递数据。
1.形参在未出现函数调用时，他们并不占用内存单元，只有在发生函数调用的时候形参才被分配内存，函数调用完成后，形参所占的内存被释放
2.实参可以是变量，常量或者表达式
3.在定义函数时，一定要指定形参的数据类型
4.形参与实参的数据类型一定要可兼容
5.在C语言中，实参与形参的数据传递是“值传递”，即单向传递，只由实参传递给形参，而不能由形参传递给实参。
如果函数的参数是个数组，那么是可以通过形参修改实参的值的
1、无参函数
在C语言中，无参函数的定义很简单，先来看一个定义无参函数的示例代码，具体如下：
void func()
{
printf("这是我的第一个函数！\n");
}
上述示例代码中，func()函数就是一个无参函数，在定义时参数列表为空。要想执行这个函数，需要在main()函数中调用它，接下来通过一个案例来演示
例4-1
#include <stdio.h>
void func()
{
printf("这是我的第一个函数！\n");
}
void main()
{
func();
}
从上面看出func()函数被成功调用了。在程序中，第2行代码定义了一个无参函数func()，第4行代码将字符串打印到控制台，第8行代码在main()函数中调用该无参函数。
2.有参函数
与无参函数相比，有参函数需要在函数定义时，在函数名称后面的括号中填写参数。所谓的参数是一个变量，用于接收调用函数传入的数据。定义有参函数的示例代码如下：
void func(int x,int y)
{
int sum=x+y;
printf("x+y=%d\n",sum);
}
上述代码中，定义了一个实现加法运算的函数func()，并指定了两个int类型的参数。为了让读者更好地掌握有参函数的用法，接下来在main()函数中调用func(int x,int y)函数，
例4-2
#include <stdio.h>
void func(int x, int y)
{
int sum = x + y;
printf("x+y=%d\n", sum);
}
void main()
{
func(3, 5);
}
在例4-2中，第2~6行代码定义了一个函数func()，该函数包含两个参数，分别是x和y。当在main()函数中调用func()函数时，由于传入的参数是3和5，因此，程序打印的结果为“x+y=8”。
有参函数和无参函数的调用过程类似，只不过在调用有参函数时，需要传入实参，并将传入的实参赋值给形参，然后在函数体中执行x+y操作，最终将结果输出到控制台。
值得一提的是，在定义有参函数时指定的参数x和y是形式参数，简称形参，它们只在形式上存在，并不是真正存在的参数。调用函数时传入的参数（如案例中的3和5）是实际参数，简称实参，与形参相对，实参则是指实际存在的参数。
函数的声明
函数的声明涉及到四种函数
1.无类型（返回值），无参数
#include <stdio.h>
void Speak()//函数的声明（在main()函数之前）：无类型 无参数
{
printf("今天天气很好\n");
}
int main()
{
Speak();//调用函数
return 0;
}//运行结果：今天天气很好
2.有类型（返回值），无参数
#include <stdio.h>
#include <stdlib.h>//随机数生成有关的两个头文件
#include <time.h>
//有类型，无参数 函数的第二种写法，不声明，直接写在main函数前面
int R(){//产生一个随机数
srand((unsigned int)time(NULL));//随机数
return rand()%46;//随机返回一个0-45之间的数据
}
int main()
{
char arr[46][115] = {
"老龙老师","清欢老师","丸子老师","可达老师","李晓奕","洪加庆","蔡科","曹昊明","曹燕妮",
"曹鹏宇","陈鹏宇","陈思静","党尉铭","冯春林","甘福良","高洪权","桂宗庄","郭华强",
"胡晋","胡秋妹","胡伊君","胡智钦","黄晓东","贾耀文","蒋涵" ,"江涛","王虎","齐正军",
"王政和","白玲","刘洪","张扬铭","徐宇","肖家新","刘偲","汪瑞","王鹏","张凯欣",
"龙万海","王雷雨","谢玉鹏","吴长春","李广楠","李文庆","谭亚东","杨江涛"};
printf("%s\n",arr[R()]);//调用函数
return 0;
}
3.无类型（返回值），有参数
#include <stdio.h>
#include <stdlib.h>//随机数生成有关的两个头文件
#include <time.h>
//有类型，无参数 函数的第二种写法，不声明，直接写在main函数前面
int R(){//产生一个随机数
srand((unsigned int)time(NULL));//随机数
return rand()%46;//随机返回一个0-45之间的数据
}
void Print(int data)//无类型，有参数
{
char arr[46][115] = {
"老龙老师","清欢老师","丸子老师","可达老师","李晓奕","洪加庆","蔡科","曹昊明","曹燕妮",
"曹鹏宇","陈鹏宇","陈思静","党尉铭","冯春林","甘福良","高洪权","桂宗庄","郭华强",
"胡晋","胡秋妹","胡伊君","胡智钦","黄晓东","贾耀文","蒋涵" ,"江涛","王虎","齐正军",
"王政和","白玲","刘洪","张扬铭","徐宇","肖家新","刘偲","汪瑞","王鹏","张凯欣",
"龙万海","王雷雨","谢玉鹏","吴长春","李广楠","李文庆","谭亚东","杨江涛"};
printf("%s\n", arr[R()]);
}
int main()
{
Print(R());//产生返回一个数据，print(随机数据)
getchar();
return 0;
}
4.有类型（返回值），有参数
#include <stdio.h>
//有返回值，有参数 函数的形参与实参
int Add(int x, int y)
{
return x + y;
}
int main()
{
int x,y;//形参
scanf("%d",&x);
scanf("%d",&y);
printf("%d\n",Add(x,y));
return 0;
}
函数的调用
函数是C语言的基本组成元素，要想实现函数的功能，必须学会正确调用函数。在C语言中，调用函数的具体语法格式如下：
函数名([[实参列表1],[实参列表2],...])
从上面的语法格式可以看出，当调用一个函数时，需要明确函数名和实参列表。实参列表中的参数可以是常量、变量、表达式或者空，各参数之间使用英文逗号分隔。
根据函数在程序中出现的位置，可以有下列三种函数调用方式：
1.将函数作为表达式调用
将函数作为表达式调用时，函数的返回值参与表达式的运算，此时要求函数必须有返回值。示例代码如下所示：
int ret1 = max(100, 150)；
2.将函数作为语句调用
函数以语句的形式出现时，可以将函数作为一条语句进行调用。示例代码如下所示：
printf("Hello, world!\n");
3.将函数作为实参调用
将函数作为另一个函数的实参时，要求该函数有返回值。示例代码如下所示：
printf("%d\n", max(100, 150));
在上面的语句中，将函数max()的返回值作为printf()函数的实参来使用。
嵌套调用
C语言中函数的定义是独立的，即一个函数不能定义在另一个函数内部。但在调用函数时，可以在一个函数中调用另一个函数，这就是函数的嵌套调用。接下来通过一个案例来演示函数的嵌套调用，如例4-6所示。
例4-6
#include <stdio.h>
int max2(int a, int b) // 用于比较两个整数大小的函数
{
if (a > b){
return a;
}
else
{
return b;
}
}
int max4(int a, int b, int c, int d) // 用于比较四个整数大小的函数
{
int res;
res = max2(a, b);
res = max2(res, c);
res = max2(res, d);
return res;
}
void main()
{
int a, b, c, d, max;
printf("请输入四个整数：");
scanf("%d %d %d %d", &a, &b, &c, &d);
max = max4(a, b, c, d);
printf("max=%d \n", max);
}
在例4-6中，main()函数中调用了max4()函数，max4()函数中又调用了max2()函数。
递归调用
在数学运算中，会遇到计算多个连续自然数之间的和的情况。例如要计算1n之间自然数之和，就需要先计算1加2的结果，用这个结果加3再得到一个结果，用新得到的结果加4，以此类推，直到用1(n-1)之间所有数的和加n。
在程序开发中，要想完成上述功能，就需要使用函数的递归调用，所谓的递归调用就是函数内部调用自身的过程。需要注意的是，递归必须要求有结束条件，不然就会陷入无限递归的状态，永远无法结束调用。接下来通过一个计算自然数之和的案例来学习递归调用，具体如例4-7所示。
例4-7
#include <stdio.h>
//下面的函数使用递归实现 求1~n的和
int getsum(int n)
{
if (n == 1)
{
return 1; //满足条件，递归结束
}
int temp = getsum(n - 1); //在函数体中调用自身
return temp + n;
}
void main()
{
int sum = getsum(4); //调用递归函数，获得1~4的和
printf("sum = %d\n",sum); //打印结果
}
例4-7中，定义了一个getsum()函数用于计算1~n之间自然数之和。案例中的第9行代码相当于在getsum()函数的内部调用了自身，这就是函数的递归，整个递归过程在n==1时结束。
函数的返回类型与返回值
函数的返回值是指函数被调用之后，返回给调用者的值。函数返回值的具体语法格式如下：
return 表达式;
对于返回值为空的函数，可以直接在return语句后面加分号，具体语法格式如下：
return;
为了让读者更好的学习如何使用return语句，接下来对例4-2进行改写，使func(int x, int y)函数能够返回求和计算的结果，修改后的具体代码如例4-3所示。
例4-3
#include <stdio.h>
int func(int x, int y)
{
int sum = x + y;
return sum;
}
void main()
{
int sum = func(3, 5);
printf("x+y=%d\n", sum);
}
在程序运行期间，参数x和y相当于在内存中定义的两个变量。当调用func(int x,int y)函数时，传入的参数3和5分别赋值给变量x和y，并将x+y的结果通过return语句返回，整个方法的调用过程结束，变量x和y被释放。
需要注意的是，return后面表达式的类型和函数定义返回值的类型应保持一致。如果不一致，就有可能会报错。如果函数没有返回值，返回值类型要声明为void。为保证程序的可读性和逻辑性，没有返回值的函数都应定义为void。
注释：
1函数的返回值通过函数中的return获得，如果函数的返回值为void可以不需要return语句。
2函数return语句中的返回值数据类型应该与函数定义时相同。
3如果函数中没有return语句，那么函数将返回一个不确定的值。
main函数与exit函数与函数的return语句
int test1(){
printf("111111\n"); //return 0; exit(0);//在子函数中调用exit同样代表程序终止，但在子函数中调用return只是子函数终止，程序正常执行
printf("222222\n");
}
int main(){
test1();
printf("AAAAAA\n");
exit(100);//exit是C语言的库函数，调用exit的结果就是程序终止
return 100;//在main函数中调用exit与调用return是一样的
printf("CCCCCCC\n"); return 0;//main函数return代表程序终止
printf("BBBBBB\n");
}
printf()函数和scanf()函数
在C语言开发中，经常会进行一些输入输出操作，为此，C语言提供了printf()和scanf()函数，其中，printf()函数用于向控制台输出字符，scanf()函数用于读取用户的输入，下列将分别讲解这两个函数的用法。
1.printf()函数
在前面的章节中，经常使用printf()函数输出数据，它可以通过格式控制字符输出多个任意类型的数据。以下列举了printf()函数中常用的格式控制字符，使用这些格式控制符可以让printf()输出指定类型的数据。
常用格式字符 含义
%s 输出一个字符串
%c 输出一个字符
%d 以十进制输出一个有符号整型
%u 以十进制输出一个无符号整型
%o 以八进制输出一个整数
%x 以十六进制输出一个小写整数
%X 以十六进制输出一个大写整数
%f 以十进制输出一个浮点数
%e 以科学计数法输出一个小写浮点数
%E 以科学计数法输出一个大写浮点数
接下来通过一个具体的案例来演示这些格式控制符的使用：
例4-4
#include <stdio.h>
void main()
{
printf("%c %c", 'H', '\n');
printf("%s", "Hello, world!\n");
printf("%d %d %d \n", 1, 2, 3);
printf("%f %f \n", 2.1, 2.2);
}
在例4-4的printf()函数中，通过格式控制字符“%c”、“%s”、“%d”、“%f”，分别输出了字符、字符串、整数、浮点数。
2.scnaf()函数
scanf()函数负责从控制台上接收用户的输入，它可以灵活接收各种类型的数据，如字符串、字符、整型、浮点数等，scanf()函数也可以通过格式控制字符控制用户的输入，其用法与printf()函数一样。接下来，通过一个获取字符串的案例讲解scanf()函数的用法，如例4-5所示。
例4-5
#include <stdio.h>
void main()
{
char str[256]; // 字符数组保存得到的字符串
scanf("%s", str);
printf("%s\n", str);
}
在例4-5中，首先定义了一个长度为256的字符数组str，然后利用scanf()函数获得用户从控制台输入的字符，最后使用printf()函数将得到的字符串打印在控制台上。若用户从控制台上输入了Helloworld，并按回车符，此时scanf()函数会把回车符看做是字符串终止的标志（也称为终止符），将整个Helloworld读取到str字符数组中。
注释：C语言中的终止符
在使用scanf()函数获取用户输入的信息时，如果输入的信息中包含某个终止符，scanf()函数就认为输入结束，接下来就列举一些常见的终止符：
scanf（）输入字符串的中终止符
字符 含义
0x20 空格
\t 水平制表符（tab键）
\n 换行
\v 垂直制表符
\f 换页
\r 回车
以例4-5为例，当程序运行后，如果输入的字符串包含空格，例如“Hello world”，但是尽管输入的字符串是Hello world，但是程序只打印了Hello，这是因为Hello world中包含一个空格，空格也是一个终止符，因此scanf()只能读到空格之前的内容。
外部函数与内部函数
前面关于函数的调用都是针对同一个源文件中其他函数进行调用的，在有些情况下，函数也可能对另外一个源文件中函数进行调用。当一个程序由多个源文件组成时，根据函数能否被其他源文件调用，将函数分为内部函数和外部函数。
外部函数
开发大型项目时，为了便于团队的协同工作，需要把一个项目拆分成很多源文件来分别实现，最终再把它们整合在一起。为了减少重复代码，一个源文件有时需要调用其他源文件中定义的函数。在C语言中，可以被其他源文件调用的函数称为外部函数，在调用外部函数之前，需要在当前源文件中定义外部函数。定义外部函数的方式是在函数的返回值类型前面添加extern关键字，示例代码如下：
extern int add(int x,int y);
在上述示例代码中，编译器会通过extern关键字知道add()函数是定义在其他文件中的外部函数。
为了帮助大家掌握外部函数的用法，接下来，在first.c文件中定义一个add()函数，然后在second.c文件中使用first.c文件中定义的add()函数，first.c和second.c的代码如例4-8、例4-9所示。
例4-8 first.c
int add(int x,int y)
{
return x+y;
}
例4-9 second.c
#include<stdio.h>
extern int add(int x,int y);
void main()
{
printf("%d",add(1,2));
}
在例4-9中，second.c文件通过调用first.c中定义的add()函数计算出1加2的结果。second.c文件中的外部函数add()是在first.c文件中实现的，编译器从first.c中找到了该函数，并将它的作用域扩大到second.c文件中，于是second.c文件中也可以调用这个first.c中定义的add()函数，从而完成计算。
为简化编程，C语言中允许在定义外部函数时省略关键字extern。例4-8中定义的外部函数add()也可以修改为下面的代码：
int add(int x,int y);
上述代码由函数的返回类型、函数名和参数列表组成，这类格式的代码被称为函数原型。当代码中包含函数原型时，可能会有下列两种情况：
1、程序员希望编译器自动从其他文件中查找该函数的定义。
2、程序员先定义未实现的空函数，然后在其他文件中具体实现。
接下来就来看一下printf()函数的原型写法，具体代码如下：
int printf(const char *,…);
当在main()函数中定义了printf()函数的原型后再调用时就可以不用包含头文件<stdio.h>，如例4-10所示。
例4-10
int printf(const char *,…);
void main()
{
printf("调用printf()函数\n");
}
在例4-10中，并没有包含头文件stdio.h，但是在代码第1行中声明了printf()函数的原型，那么编译器将会根据该原型自动从其他文件中查找该函数的定义，并将该函数的作用域扩展到原型所在的文件中，因此在本文件中就可以调用printf()函数。
需要注意的是，在声明外部函数时，无论有或没有关键字extern，外部函数与原函数定义的返回值类型、函数名称和参数列表必须一致。
内部函数
由上小节讲解的外部函数可知，只要声明一个函数原型就能够调用其他源文件中的函数。但是当多人参与开发一个项目时，很有可能会出现函数重名的情况，这样，不同源文件中重名的函数就会互相干扰。此时，就需要一些特殊函数，这些函数只在它的定义文件中有效，该类函数称为内部函数。
在定义内部函数时，需要在函数的返回值类型前面添加static关键字（又称为静态函数），示例代码如下：
static void show(int x)
{
printf("%d",x);
}
为了让读者熟悉内部函数的作用，接下来通过在两个源文件中定义同名的内部函数来演示内部函数的用法，具体如例4-11和例4-12所示。
例4-11first.c
#include<stdio.h>
void show()
{
printf("%s \n","first.c" );
}
例4-12second.c
#include<stdio.h>
static void show()
{
printf("%s \n","second.c");
}
void main()
{
show();
}
在例4-11和例4-12中，都定义了一个函数show()，second.c文件中的函数是内部函数。
局部变量和全局变量
局部变量就是在函数内部声明的变量，它只在本函数内有效，也就是说，只能在本函数内使用它。此外，局部变量只有当它所在的函数被调用时才会被使用，而当函数调用结束时局部变量就会失去作用。接下来通过一个案例来演示，如例4-13所示。
例4-13
#include<stdio.h>
void show()
{
int x = 0;
}
void main()
{
printf("x的值为：%d\n", x);
}
上述编码编译时会出现错误。
例4-13中，在show()函数内部定义了一个变量x，这个变量是个局部变量，它只在show()函数中有效。第8行，main()函数试图输出x的值，由于x只在show()函数中有效，在main()函数中无效，所以编译器报告一条错误。
全局变量
在所有函数外部定义的变量称为全局变量(包括main()函数)，它不属于哪一个函数，而是属于源程序。因此全局变量可以为程序中的所有函数所共用。它的有效范围从定义处开始到源程序结束，如例4-14所示。
例4-14
#include <stdio.h>
int x = 123;
void show()
{
printf("show()函数中,x的值为：%d\n",x);
}
void main()
{
show();
printf("main()函数中，x的值为:%d\n", x);
}
在例4-14中，定义了一个变量x，它是在所有函数的外部定义的，所以是全局变量。然后调用show()函数，输出全局变量x的值，由于全局变量可以为程序中的所有函数所共用。所以show()函数成功地输出了变量x的值123。当程序结束时，全局变量x也随之结束，系统释放掉它所占用的内存。
从上面的例子可以看出，全局变量不像局部变量那样属于某个函数的，而是属于整个程序，那么假如局部变量与全局变量的名字相同，会发生什么情况呢?接下来通过一个案例来演示，如例4-15所示。
例4-15
#include<stdio.h>
int x = 789;
void main()
{
int x = 123;
printf("x的值为：%d\n", x);
}
例4-15中，第5行代码定义了一个局部变量x屏蔽掉了第2行的全局变量x，因此输出的结果为123，而不是789。需要注意的是，当局部变量与全局变量重名时，全局变量会被屏蔽。
变量的作用域
前面介绍过变量需要先定义后使用，但这并不意味着在变量定义之后的语句中一定可以使用该变量。变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。接下来通过一个案例来演示变量的作用域，如例4-16所示。
例4-16
#include<stdio.h>
int x=10;
void show()
{
int x=20;
printf("show()函数中，x的值为：%d\n",x);
}
void main()
{
int x=30;
printf("main()函数中，x的值为：%d\n",x);
show();
}
在例4-16中，首先定义一个全局变量x，值初始为10，作用域是代码第2行到第14行。然后定义了一个局部变量x，初始为20，作用域是代码第5行到第7行。最后定义了一个局部变量x，值初始为30，作用域是代码第10行到第14行。
运行结果可以得出，main()函数输出x的值为30，说明在main()函数中屏蔽掉了全局变量x。show()函数输出x的值为20，说明在show()函数中屏蔽掉了全局变量x。
多个源代码文件程序的编译
头文件的使用
如果把main函数放在第一个文件中，而把自定义函数放在第二个文件中，那么就需要在第一个文件中声明函数原型。
如果把函数原型包含在一个头文件里，那么就不必每次使用函数的时候都声明其原型了。把函数声明放入头文件是很好的习惯。
#include与#define的意义
#include就是简单的文件内容替换
#define就是简单的文本替换而已
#ifndef与#endif
#ifndef的意思就是条件预编译,如果#ifndef 后面的条件成立，那么就预编译从#ifndef开始到#endif之间的代码，否则不会去预编译这段代码
函数的递归
函数可以调用自己，这就叫函数的递归
void recurse(int i){
if (i > 0) {
recurse(i - 1);
}
printf("i = %d\n", i);
}
int main(){
recurse(10);
return 0;
}
递归的过程分析
void up_down(int n){
printf("in %d, location %p\n", n, &n);
if (n < 4)
up_down((n + 1));
printf("out %d, location %p\n", n, &n);
}
int main(){
up_down(1);
return 0;
}
有n个人排成一队，问第n个人多少岁，他回答比前面一个人大2岁，再问前面一个人多少岁，他回答比前面一个人大2岁，一直问到最后问第一个人，他回答10岁
int age(int n)
{
int i;
if (n == 1)
i = 10;
else
i = age(n - 1) + 2;
return i;
}
将10进制数转化为二进制数的例子
234在十进制下为2 * 10的2次方 + 3 * 10的1次方 + 4*10的0次方。
奇数的二进制最后一位一定是1，偶数的二进制最后一位一定是0。
可以通过 number % 2 得到二进制形式的最后一位，如果要将一个完整的整数转化为二进制就需要用到递归函数。
在递归调用之前，计算 number % 2的值，然后在递归调用语句之后进行输出，这样计算出的第一个数值反而在最后一个输出。
为了得出下一个数，需要把原数除以2，这种计算相当于十进制下把小数点左移一位，如果此时得出的数是偶数，，则下一个二进制的数值是0，如果得出的是奇数，那么下一个二进制数为1。
直到被2除的结果小于2，就停止递归。
void to_binary(unsigned int n)
{
unsigned int i = n % 2;
if (n >= 2)
to_binary(n / 2);
printf("%c", i + 0x30);
}
斐波那契数列例子
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...
第0项是0，第1项是第一个1。
这个数列从第2项开始，每一项都等于前两项之和。
int fib(int n)
{
if (n == 0)
return 0;
if (n == 1)
return 1;
if (n > 1)
return fib(n - 1) + fib(n - 2);
}
递归的优点
递归给某些编程问题提供了最简单的方法
递归的缺点：
一个有缺陷的递归会很快耗尽计算机的资源，递归的程序难以理解和维护。
浙公网安备 33010602011771号