函数的传参、递归函数、预处理命令

一、函数的传参

1.值传递

        实参将值传递给形参

        函数体内部想使用函数体外部变量值的时候，使用值传递

        形参是实参的副本，形参的变化不会影响实参的变化

2.整形数组的传递   

int fun(int array[], int len);


注意:
1.array后面加[]，表示传入的为整形数组名，而不是整数类型
2.函数内部的array和外部的数组名为同一数组，里面数据的变化会影响外面数组中值的
变化

 二、递归函数

        函数定义时调用 函数体本身

                1.递归一定要有结束条件

                2.避免深层次的递归

三、预处理命令

1.与#相关的代码

2.三类与#号相关的代码

        1.#include包含头文件：

                #include

                #include

                #include

                #include

                #include

                #include "head.h"

注意：

#include                 到系统路径下找filename.h头文件

#include "filename.h"                   在当前目录下找filename.h 头文件，如果当前目录找不到再到系统路径下查找filename.h

2.#define

        1.不带参宏

                #define  N      M+M

 注意：

1.宏只是代码的替换，中间不进行任何数据计算的操作

2.宏定义使用时，能加括号就加括号，不要吝啬括号

         2.带参宏（宏函数）

                #define  MAXNUM(x,y)     ((x)>(y) ? (x) : (y))

带参宏与函数的区别：

        1.带参宏是代码的替换，没有函数调用，传参的过程

        2.带参宏没有参数类型、返回值类型的概念

        3.带参宏会让代码体积变大

        4.函数是在程序运行时加载到程序中

        5.带参宏是在程序编译的时候加载到程序中

        6.带参宏是代码的替换，没有调用传参，返回的过程，执行效率更高

        7.函数有调用、传参、返回的过程，资源开销大

        8.模块化代码简短使用带参宏

3.条件编译

        

        #if 0

        #endif

        #ifdef

        #ifndef

        #elif

        根据条件 件将代码加入到编译中或从编译中去除

4.gcc的四个编译流程步骤

        

         1. 预处理： 处理和 # 号相关的代码，将代码展开

        2. 编译 ： 将 C 语言代码编译成汇编代码

        3. 汇编 ：将汇编代码编译成可执行程序

        4. 链接 ：将C 语言代码与库函数链接成可执行程序

5.gcc 的编译选项

1.  -o     指定生成代码的文件名
2.  -E     将代码只执行预处理编译
3.  -s     将代码执行预处理、编译两个步骤
4.  -c     将代码执行预处理、编译、汇编三个步骤
5.  -l     指定链接库的名称
6.  -I     指定头文件的路径
7.  -L     指定库文件的路径
8.  -wall  显示所有的告警信息

四、作业

1.从终端接收一个数，封装一个函数实现，统计这个数每位上的和值

#include

int Wei(int num)
{
    int i = 0;
    while(num != 0)
    {
        num /= 10;
        i++;
    }
    return i;
}

int He(int num)
{
    int sum = 0;
    while(num != 0)
    {
        sum += num % 10;
        num /= 10;
    }
    return sum;
}

int main(void)
{
    int a = 0;
    int tmp = 0;
    int ret = 0;

    scanf("%d", &a);
    tmp = Wei(a);
    ret = He(a);

    printf("位数:%d\n",tmp);
    printf("和值:%d\n",ret);

    return 0;
}

2.从终端输入一个a和n，封装一个函数传入a和n，获得a + aa + aaa + ... +aaaa(n个a)的和值

#include

int fun(int a, int n)
{
    int i = 0;
    int tmp = 0;
    int sum = 0;

    while(i < n)
    {
        if(n == 1)
        {
            return a;
        }
        else
        {
            tmp = tmp * 10 + a;
            sum += tmp;
            i++;
            printf("%d\n",tmp);
        }
    }
    return sum;
}

int main(void)
{
    int a = 0;
    int n = 0;
    int ret = 0;

    scanf("%d%d",&a,&n);

    ret = fun(a,n);
    printf("sum = %d\n", ret);

    return 0;
}

3.编写程序从终端接收年、月、日

封装函数实现判断该年是否为闰年？

封装函数获得该天为该年的第几天？

封装函数获得该年剩余多少天？

#include

int IsLeepYear(int year)
{
    if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int GetDayOfYear(int year, int month, int day)
{
    int days[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    if(IsLeepYear(year))
    {
        days[2] = 29;
    }

    int sum = 0;
    for(int i = 1; i < month; i++)
    {
        sum += days[i];
    }
    sum += day;

    return sum;
}

int GetLeftDayOfYear(int year, int month, int day)
{
    int all = 0;
    if(IsLeepYear(year))
    {
        all = 366;
    }
    else
    {
        all = 365;
    }

    int now = GetDayOfYear(year, month, day);

    return all - now;
}

int main(void)
{
    int year = 0;
    int month = 0;
    int day = 0;
    int ret1 = 0;
    int ret2 = 0;
    int ret3 = 0;

    scanf("%d%d%d", &year, &month, &day);

    ret1 = IsLeepYear(year);
    if(ret1)
    {
        printf("%d年为闰年!\n", year);
    }
    else
    {
        printf("%d年为平年!\n", year);
    }

    ret2 = GetDayOfYear(year, month, day);
    printf("该天为该年的第%d天!\n",ret2);

    ret3 = GetLeftDayOfYear(year, month, day);
    printf("该年还剩余%d天!\n",ret3);

    return 0;
}