第五章函数的秘密

最新推荐文章于 2021-05-22 07:16:13 发布

翻译最新推荐文章于 2021-05-22 07:16:13 发布 · 791 阅读

文章标签：

#形参 #形参-实参 #有参无参 #局部全局

慕课C语言学习专栏收录该内容

9 篇文章

订阅专栏

C语言提供了大量的库函数

自定义函数的一般形式：

[数据类型]函数名称（[参数]）
{
    执行代码块；
    return（表达式）;
}

注意：
[]包含的内容可以省略，数据类型说明省略，默认的是int类型函数；
1、参数省略表示该数是无参数的函数，参数不省略表示该函数是有参函数；
2、函数名称遵循标识符命名规范
3、自定义函数尽量放在main()函数之前，
4、如果要放在main()函数后面的话，需要在main()函数之前先声明自定义函数，

声明格式为：[数据类型说明]函数名称（[参数]）；

#include <stdio.h>

int sayhello()
{
    printf("%s\n","慕课网的小伙伴，大家好");
    return 0;
}
int main()
{
    return 0;
}

函数的调用

在C语言中，函数调用的一般形式：

函数名（[参数]）

注意：
1、对无参数的调用的时候可以将[]包含的省略
2、[]中可以是常数，变量或其他构造类型数据及表达式，各个参数之间用逗号分开。

#include <stdio.h>
//自定义函数，sayhello()
int sayhello()
{
    printf("%s\n","慕课网的小伙伴们，大家好");
    return 0;
}
//主函数
int main()
{
    sayhello();
    return 0;
}

有参与无参数

无参数函数：在函数中不需要函数参数

有参函数：在函数中需要参数

有参函数的一般形式

[数据类型]函数名称（参数列表）
{
    执行代码块；
    return 表达式；
}

[数据类型]函数名称（）
{
    执行代码块；
    return 0；
}

有参函数与无参函数的唯一的区别是：函数（）中多了一个参数列表。

无参数函数
#include <stdio.h>

int Matrix()
{
    int i, j;
    for (i = 1; i <= 3; i++)
    {
        for (j = 1; j <= 3; j++)
        {
            printf(" * ");
        }
        printf("\n");
    }
    return 0;
}
int main()
{
    Matrix();
    return 0;
}

#include <stdio.h>

int Matrix(int n)
{
    int i, j;
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            printf("* ");
        }
        printf("\n");
    }
    return 0;
}
int main()
{
    Matrix(5);
    return 0;
}

对比两个例子，不难发现有参函数更为灵活，输出的图形可以随着n 的改变而随意改变，只要在main()函数中传递一个参数就可以了；
而在无参函数中输出的相对就比较固定，当需要改动的时候还需要到自定义的方法内改变循环变量的值。

形参与实参

函数的参数分为形参和实参两种。

形参是在定义函数名的时候使用的参数。目的是用来接收调用该函数时传入的参数。
实参是在调用时传递该函数的参数。

（一）函数的形参和实参具有以下的特点：
形参只有在被调用时分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此形参只有在函数的内部有效。函数调用结束返回主调用函数名后则不能再使用该形参变量
实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，
在参数传递时，实参和行参在数量上，类型上，顺序上应严格一致，否则会发生类型不匹配的错位

#include <stdio.h>

int MultiDouble(int x)//这里的x是形参
{
    return x * 2;
}

int main()
{
    int x = 10;
    //下面的x是实参，他其实就是main()函数中定义的变量x
    printf("%d\n",MultiDouble(x));
    return 0;
}

求三角形的周长

#include <stdio.h>

int getGirth(int a, int b, int c)
{
    if ((a + b) <= c || (a + c) <= b || ((b + c) <= a))
    {
        printf("不构成三角形\n");
        return 0;
    }
    else
    {
        int cirf = a + b + c;
        return cirf;
    }
}
int main()
{
    int a, b, c;
    a = 3;
    b = 4;
    c = 5;
    printf("三角形的周长是：%d\n",getGirth(a,b,c));
}

函数的返回值

函数的返回值是指函数被调用之后，执行函数体中的程序段所取得的并返回给主调函数的值。

1、函数的值只能通过return语句返回主调函数。

return语句的一般形式为：

return 表达式               return （表达式）；

2、函数值的类型和函数定中函数的类型应保持一致。如果两者不一致，则以函数返回类型为准，自动进行类型转换。

int number()
{
    return 100;
}

void noResult()
{

}

注意：
void函数中可以有执行代码块，但是不能有返回值，令void函数中如果有return语句，该语句只能有起到结束函数运行的功能。

其格式为： return ；

没有答案的

#include <stdio.h>
/* Jone算出结果应该怎么写函数？ */
 ？  joneResult(int x, int y, int z)
{
   int sum = x+y+z;
   ？          //这里是不是应该将sum返回呢？
}
/* Jack没有算出结果只说了一句话是不是应该用无返回值函数？ */
 ？ jackResult(int x, int y, int z)
{
    printf("我算不出来\n");
}
int main()
{
    int a, b, c;
    a = 10;
    b = 20;
    c = 30;
    //Jone的返回值类型是什么？
         jR = joneResult(a, b, c); 
    printf("Jone运算结果是：%d\n", jR);
    printf("Jack运算结果是：");
    //Jack没有算出结果只说了句话，是不是直接调用函数就可以了？
    ？
    return 0;
}

递归

#include <stdio.h>
/* Jone算出结果应该怎么写函数？ */
 ？  joneResult(int x, int y, int z)
{
   int sum = x+y+z;
   ？          //这里是不是应该将sum返回呢？
}
/* Jack没有算出结果只说了一句话是不是应该用无返回值函数？ */
 ？ jackResult(int x, int y, int z)
{
    printf("我算不出来\n");
}
int main()
{
    int a, b, c;
    a = 10;
    b = 20;
    c = 30;
    //Jone的返回值类型是什么？
         jR = joneResult(a, b, c); 
    printf("Jone运算结果是：%d\n", jR);
    printf("Jack运算结果是：");
    //Jack没有算出结果只说了句话，是不是直接调用函数就可以了？
    ？
    return 0;
}

计算n的阶乘可以使用以下代码

#include <stdio.h>
int factorial(int n)
{
    int result;
    if (n < 0)
    {
        printf("输入错误！\n");
        return 0;
    }
    else if (n == 0 || n == 1)
    {
        result = 1;
    }
    else
    {
        result = factorial(n - 1)*n;
    }
    return result;
}

int main()
{ 
    int n = 5;
    printf("%d的阶乘=%d",n,factorial(n));
    return 0;
}

递归就是一个函数在它的函数体内调用它自身

#include <stdio.h>

int getwordNumber(int n)
{
    if (n == 1)
    {
        return 1; 
    }
    else
    {
        return getwordNumber (n - 1) + n;
    }
}

int main()
{
    int num = getwordNumber(10);
    printf("小明第10天记了：%d个单词。",num);
}

递归函数的特点：

每一级函数调用都有自己的变量，但是函数代码并不会得到复制，
每次调用都会有一次返回
递归函数中，位于递归调用前的语句和各级被调用函数具有相同的执行顺序，
递归函数中，位于递归调用钱的语句和各级被调用函数具有相同的执行顺序；
递归函数中，位于递归调用的后的语句的执行顺序和各个被调用函数的顺序相反；
递归函数中必须有终止语句。
一句话总结递归：自我调用且具有完成状态。

#include <stdio.h>

int getPeachNumber(int n)
{
    int num;
    if (n==10)
    {
        return 1;
    }
    else
    {
        num = (getPeachNumber(n + 1) + 1) * 2;
        printf("第%d天所剩桃子%d多个\n",n,num);
    }
    return num;
}
int main()
{
    int num = getPeachNumber(1);
    printf("猴子第一天摘了：%d个桃子。\n",num);
    return 0;
}

递归练习：

有5个人坐在一起，问第5个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第3个人，又说比第2人大两岁。问第2个人，说比第1个人大两岁。最后问第1个人，他说是10岁。请问第5个人多大？

程序分析：

利用递归的方法，递归分为回推和递推两个阶段。要想知道第5个人岁数，需知道第4人的岁数，依次类推，推到第1人（10岁），再往回推。

#include <stdio.h>

int getAge(int numPeople)
{
    int age;
    if (numPeople == 1)
        age = 10;
    else
        age = getAge(numPeople - 1) + 2;
    return age;
}

int main()
{
    int fifthAge = getAge(5);
    printf("第5个人的年龄是%d岁",fifthAge);
    return 0;
}

局部和全局

C语言中变量，按作用域范围分为两种，即局部变量和全局变量。

局部变量也称为内部变量，局部变量是在函数内作定义说明的。其作用域仅限于函数内
全局变量也称为外部变量，全局变量是在函数外部定义的的变量，全局变量不属于哪一个函数，全局变量属于一个源程序文件，其作用是整个源程序

#include <stdio.h>
int x = 1;
int fn1(int x)
{
    int y, z;
    z = 2;
    y = x + z;
    printf("y=%d\n",y);
    return 0;
}

int main()
{
    fn1(2);
    int y = 10;

    printf("x+y=%d",y+x);
    return 0;
}

内部函数与外部函数

在C语言中不能被其他的源文件调用的函数称为内部函数，内部函数由static关键字来定义因此又被称为静态函数，

stctic [数据类型]函数名（[参数]）

static()是对函数的作用范围的一个限定，限定该函数只能在其所处的源文件中使用，因此在不同的文件中出现相同的函数名称的内部函数是没有问题。

在C语言中能被其他源文件调用的函数称为外部函数，外部函数由extern关键字

extern[数据类型]函数名（[参数]）

C语言规定，在没有指定函数的作用范围时，系统会默认认为是外部函数，因此当需要定义外部函数时extern可以省略
额

A、C程序函数中定义的赋有初值的静态变量，每调用一次函数，赋一次初值
B、在C程序的同一函数中，各复合语句内可以定义变量，其作用域仅限本复合语句
C、C程序函数定义的自动变量，系统不自动赋确定的初值
D、C程序函数的形式参数不可以说明为static型变量

北京市出租车打车计费规则如下：
1. 每公里单价计费2.3元
2. 起步价13元(包含3公里)
3. 晚上23点(含)至次日凌晨5点(不含)打车，每公里单价计费加收20%。
4. 每次乘车加收1元钱的燃油附加税。
小明每天上下班都要打车，公司和家的距离为12公里，上午上班时间为9点，下午下班时间为6点。
请编写一个小程序计算小明每天打车的总费用。

变量存储的类别

C语言根据变量的生存周期来划分，可以划分为静态存储方式和动态存储方式

静态存储方式：是指在程序的运行期间分配固定的存储空间的方式。静态存储区中存储放了在整个程序执行过程中都存在的变量，如全局变量

动态存储方式：是指在程序运行期间根据需要进行动态的分配存储空间的方式。动态存储区中存放的变量是根据程序运行需要而进行的需要而建立和释放的。通常包括： 1. 函数形式参数；2. 自动变量；3. 函数调用时的现场保护、4. 和返回值地址等。

C语言中的存储类别又分为4类：
自动（auto）、
静态（static）、
动态（extern）
寄存器（register）

-1、用关键字auto定义的变量为自动变量，auto可以省略，auto不写则隐含定为”自动存储类别“，属于动态存储方式。

int fn(int a)//定义f函数,a为参数
{
//定义b，c为自动变量
    auto  int b,c;
}

2、用static修饰的为静态变量，
如果定义在函数内部，称之为静态局部变量；
如果定义在函数外部，称之为静态外部变量，

#include <stdio.h>

void fn()
{
    static int x =0;
    x++;
    printf("fn: x=%d\n",x);
}
int main()
{
    int i;
    for(i=0;j<10;i++)
    {
        fn();
    }
    return 0;
}

注意：
静态局部变量属于静态存储类别，在静态存储区内分配存储单元，在程序整个运行期间都不释放；
静态局部变量在编译时赋初值，即只赋初值一次；如果在定义局部变量时，不赋初值的话，则对静态局部变量来说，编译时自动赋初值0.（对数值型变量）或空字符（对字符变量）。

3、为了提高效率，C语言允许将局部变量得值放在CPU中的寄存器中，这种变量叫”寄存器变量“，用关键字register做声明

void fn()
{
    register int i;
}

注意：只有局部自动变量和形式参数可以作为寄存器变量；一个计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量
局部静态变量不能定义为寄存器变量。

4、用extern声明的变量是外部变量，外部变量的意义是某函数可以调用在该函数之后定义的变量

#include <stdio.h>
int main()
{
    extern int x;//这里声明的是外部局部变量
    printf("extern x=%d\n",x);
}
int x=100;

任务：

#include <stdio.h>
void fn()
{
    static int x = 1;
    x *= 2;
    printf("x=%d\n",x);
}
int main()
{
    int i;
    for(i=0;i<5;i++)
    {
        fn();
    }
    extern int x;
    printf("x=%d\n",x);
    return 0;
}
int x = 100;