1.函数的概念

函数：founction

c语言的程序代码都是函数组成的

c语言中的函数就是一个完成某项特定的任务的一段代码，这段代码有特殊的写法和调用方法

c语言中我们一般见到两种函数：

.库函数

.自定义函数

2.库函数

有对应的头文件

#include <math.h>
int main()
{
    double r = sqrt(16);
    printf("%lf\n", r);


    return 0;
}

用sqrt求平方根一定要添加头文件#include <math.h>

3.自定义函数

ret_type是用来表示函数计算结果的类型，

函数的参数可以是void，明确表示函数没有参数

//函数的定义
int Add(int x, int y)
{
    int z = 0;
    z = x + y;
    return z;// return z把z的值返回到c里面
}

int main()
{
    int a = 0;
    int b = 0;
    //输入
    scanf("%d %d", &a, &b);
    //计算
    //int c = a + b;
    int c = Add(a, b);//使用函数，调用函数，调用函数就跑到1~7行调用函数了，把a传给x,b传给y
    //输出
    printf("%d", c);

    return 0;
}

还有种更加简介的写法：
int Add(int x, int y)
{

    return x + y;// return z把z的值返回到c里面
}
直接返回x+y




void print(void)   //无参数、无返回值   ,前面的是没有返回值，后面的是不需要参数
{
    printf("hello world");
}
int main()
{
    print();//直接调用
    return 0;
}

返回类型的地方的void表示函数没有返回值
参数部分的void表示函数不需要参数

4.形参和实参

在函数的使用过程中，把函数分为形参和实参

int Add(int x, int y)   // 形参，形式上的存在
{

    return x+y;
}

int main()
{
    int a = 0;
    int b = 0;
    //输入
    scanf("%d %d", &a, &b);
    //计算
    //int c = a + b;
    int c = Add(a, b);//使用函数，调用函数
    //输出
    printf("%d", c);

    return 0;
}
在调用函数的时候，真实传递给函数额参数叫；实际参数，简称实参，
在这个代码里面，我们把第15行的a和b叫做实参
在函数定义部分，函数名后面的参数叫；形式参数，就是本代码里面的x和y
形参其实是实参的临时拷贝

5.return语句

return后面可以是一个数值，也可以是一个表达式，如果是表达式就先执行表达式，再返回表达式的结果

举个例子：return x + y;//令x=10,y=20,只有算完x+y才会返回值

int test()
{
    int a = 0;
    scanf("%d", &a);
    if (a > 0)
        return 1;
    else
        return -1;
}
int main()
{
    int ret = test();
    printf("%d\n", ret);
    return 0;
}


return 语句执行后，函数彻底返回，后面的代码不再执行

void test()
{
    printf("hehe\n");
    if (1)//条件为真
        return;//直接返回，
    printf("haha\n");//被跳过
}
int main()
{
    test();
    return 0;
}



返回值和返回类型不同会出现数据丢失

int test()
{
    return 3.14;//返回的是浮点数，但被转换成整型了，如果返回值和返回类型不统一则会出现数据丢失
}
int main()
{
    int r = test();
    printf("%d\n", r);
    return 0;
}

如果不想出现数据丢失，可以想强制将3.14改变成整型
return (int)3.14;



如果函数中存在if等分支的语句，则要保证每种情况下都有return返回，否则会出现编译错误
函数不写返回类型，默认返回的是整型
int test()
test()


函数的返回值没写的话，编译器会认为返回的是int类型的值
如果函数要求返回值，但是函数中没有使用return返回值吗，那具体返回什么就不确定了

6.数组做函数参数

void set_arr(int arr[10],int sz)//不需要返回值，所以加一个void，这里之所以用arr[10]是因为，下面把数组传过来了，我们要创建一个数组用来接受，sz也一样，同样需要一个形参去接受
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        arr[i] = -1;
    }
}




int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    //写一个函数将一个整型数组的内容，全部置为-1，
    int sz = sizeof(arr) / sizeof(arr[0]);   //算出数组元素的个数
    set_arr(arr,sz);//传数组    //set_arr设置数组，把arr数组中的sz个数组设置一下,这里不能写arr[10]，因为arr[10]是数组中下标为10的那个数，如果要传数组的话，传数组名就行了



    return 0;
}




改变：你想赋什么就赋什么，在46行括号内加上你想要赋的值，然后传到函数里面的set,然后通过34行就可以实现了
void set_arr(int arr[10],int sz,int set)//不需要返回值，所以加一个void，这里之所以用arr[10]是因为，下面把数组传过来了，我们要创建一个数组用来接受，sz也一样，同样需要一个形参去接受
{
    int i = 0;
    for (i = 0; i < sz; i++)//通过循环使每一个值都赋上值
    {
        arr[i] = set;
    }
}
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    //写一个函数将一个整型数组的内容，全部置为-1，
    int sz = sizeof(arr) / sizeof(arr[0]);   //算出数组元素的个数
    set_arr(arr,sz,-1);//传数组    //set_arr设置数组，把arr数组中的sz个数组设置一下,这里不能写arr[10]，因为arr[10]是数组中下标为10的那个数，如果要传数组的话，传数组名就行了



    return 0;
}










void set_arr(int arr[10],int sz,int set)//不需要返回值，所以加一个void，这里之所以用arr[10]是因为，下面把数组传过来了，我们要创建一个数组用来接受，sz也一样，同样需要一个形参去接受
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        arr[i] = set;
    }
}
void print_arr(int arr[10],int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)//sz=10,i<sz就是<=9，也就是标号为9的数字，也就是最后一位数字
    {
        printf("%d", arr[i]);
    }
    printf("\n");
}

int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    //写一个函数将一个整型数组的内容，全部置为-1，
    int sz = sizeof(arr) / sizeof(arr[0]);   //算出数组元素的个数
    print_arr(arr, sz);//设置之前数组内数字的大小没有变化
    set_arr(arr,sz,-1);//传数组    //set_arr设置数组，把arr数组中的sz个数组设置一下,这里不能写arr[10]，因为arr[10]是数组中下标为10的那个数，如果要传数组的话，传数组名就行了

    //打印数组的函数
    print_arr(arr, sz);


    return 0;
}

输出结果为：
12345678910   //改变前
-1-1-1-1-1-1-1-1-1-1    //改变后

数组在传参的时候，实参就写数组名，形参也是数组的形式

实参和形参的名字是可以一样的

函数在设计的时候，一定要功能单一，不要要过于复杂

数组在传参的时候，形参的数组和是实参的数组是同一个数组

形参如果是一维数组，数组大小可以省略不写

形参如果是二维数组，行可以省略，但是列不能省略

//二维数组的案例
void print(int arr[3][5], int r, int c)//这里的3可以省略，但是5不能省略
//这里的r和c是元素个数  
{
    int i = 0;
    for (i = 0; i < r; i++)//几行//这里的r和c是元素个数，这是个循环
    {
        int j = 0;
        for (j = 0; j < c; j++)//一行有几列
        {
            printf("%d ",arr[i][j]);//这里就要用下标访问了，这里的i和j 就是下标，下标的大小要比元素的数小1
        }
        printf("\n");
    }
}



int main()
{
    int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };//定义时是3行5列，这里是元素个数
    //打印二维数组的内容
    print(arr, 3, 5);

    return 0;
}

7.嵌套调用和链式访问

//假设我们某年某月有多少天
//只有闰年的2月有29天，需要对y判断是否是闰年

//函数只有两种返回
//是闰年
//不是闰年
int  is_leap_year(int y)
{
    if(((y%4==0)&&(y%100!=0)||(y%400==0)))//闰年的判断，
        return 1;//如果是闰年就返回1
    else
        return 0;//不是闰年就返回0
}


int get_days_of_month(int y ,int m)//接受年和月//这里我们需要返回一个整型
{
    int days[] = {0,  31,28,31,30,31,30,31,31,30,31,30,31 };
    //             0  1  2  3  4  5  6  7  8  9  10  11      下标
    int day = days[m];
    if (is_leap_year(y) == 1 && m==2)//如果是闰年就返回一，表示为真的,并且m是二月
    {
        day++;//闰年二月的时候，天数+1，为29天
    }
    return day;//如果不是二月就返回day


}



int main()
{
    int month = 0;
    int year = 0;
    scanf("%d %d", &year, & month);
    //计算某年某月有多少天
    int day =get_days_of_month(year, month);//这个函数传了年和月
    printf("%d\n", day);
    return 0;
}



//main函数调用get_days_of_month去计算某年某月有多少天
//get_days_of_month这个函数内部又要通过is_leap_year判断输入的数是否是闰年
//17行的==1可以不写





做出改变，用布尔类型来做：
bool  is_leap_year(int y)    //布尔类型，判断真假
{
    if (((y % 4 == 0) && (y % 100 != 0) || (y % 400 == 0)))//闰年的判断，
        return true;//如果是闰年就返回true
    else
        return false;//不是闰年就返回false
}

所谓链式访问就是将一个函数的返回值作为另一个函数的参数，像链条一样将函数串起来就是函数的链式访问

int main()
{
    //printf("%d", printf("%d", printf("%d ", 43)));//输出结果是4321
    /*int r = printf("hehe");
    printf("%d\n", r);*///输出结果是hehe4，返回的是4个字符

    printf("%d", printf("%d ", printf("%d ", 43)));
    //printf("%d", 43)这个打印出来的是43，打印两个字符返回值是2
    //printf("%d", printf("%d", 2));
    //printf("%d", 2)   再屏幕上打印2，打印一个字符返回值是1
    //printf("%d", 1);打印就是1
    //所以最终的结果是4321
    /*先打印43，再打印2，最后打印1*/
    //如果在中间和后面的两个printf里面的%d后面添加一个空格，输出结果就不一样了，变为43 3 2
    //这种情况的话最先的打印是43加一个空格，返回3个字符
    //然后第二次打印就是打印3和一个空格，返回2个字符
    //然后就变成了printf("%d",2),打印2
    //最终结果就变成43 3 2
    return 0;
}

8.函数的声明和定义

函数或者变量都要满足，先声明后使用

声明后面要加分号，定义后面不用加分号

//函数的定义是一种特殊的声明
/*int  is_leap_year(int y);*///函数的声明，只要函数提前声明了，不管函数定义在前面还是后面，都能使用
int  is_leap_year(int );//函数声明的另一种写法,在声明内容中形参的名字是可以不用写的
 int main()
 {
     int year = 0;
     scanf("%d", year);
     if (is_leap_year(year)==true)//函数的调用
     {
         printf("%d 是闰年", year);
     }
     else
     {
         printf("%d 不是闰年", year);
     }



     return 0;
}

 //函数的定义
 int  is_leap_year(int y)    //布尔类型，判断真假
 {
     if (((y % 4 == 0) && (y % 100 != 0) || (y % 400 == 0)))//闰年的判断，
         return 1;//如果是闰年就返回true
     else
         return 0;//不是闰年就返回false
 }

新创建一个源文件add.c
新创建一个头文件add.h
源文件add.c放函数的定义实现
头文件add.h放函数的声明
如果要使用的话，就写出头文件打代码
#include "add.h"
写出这行代码，头文件就能正常使用了

这样就把函数的声明和定义拆散了，函数定义放在.c文件
函数声明放在头文件

我们要把add.h和add.c当做一个模块，只要想使用这个模块，包含头文件即可

 

把大型复杂的程序，拆分成多个文件的好处

1.团队协作

2.代码模块化，逻辑更加清晰

3.代码的隐藏

局部变量的作用域就是变量所在的局部范围



//int main()
//{
//    {
//        int a = 100;//定义的a只在这个括号内使用，出了这个括号就用不了了 
//        printf("1 a=%d\n", a);
//    }
//    //printf("2 a=%d\n", a);
//
//
//    return 0;
//}
int main()
{
    int a = 100;//把a的定义放在外围的括号内处于这个括号的打印都能用
    {
        //定义的a只在这个括号内使用，出了这个括号就用不了了 
        printf("1 a=%d\n", a);
    }
    printf("2 a=%d\n", a);


    return 0;
}

全局变量的作用域是整个工程



int a = 100;
int main()
{    
    {

        printf("1 a=%d\n", a);
    }
    printf("2 a=%d\n", a);
    return 0;
}

static是静态的意思，可以用来：
1.修饰局部变量
2.修饰全局变量
3.修饰函数

extem是用来声明外部符号的




ertem:
在ass.c定义int a = 100;这就是定义的全局变量




//extern是用来声明外部符号的
笔记.c
extern int a;//变量的声明
int main()
{    
    {

        printf("1 a=%d\n", a);
    }
    printf("2 a=%d\n", a);
    return 0;
}
add.c
int a = 100;

extern是声明外部符号的，只要这个符号是来自外部的，只要用extern 就可以调用了

声明一各变量的方式，知道类型和名字就行了

//void test()//进入函数
//{
//    int a = 1;/*将a赋值为1局部变量*/
//    a++;//a直接新创建一个值
//    printf("%d", a);
//}
//
//int main5()
//{
//    for (int i = 0; i < 5; i++)//i从0开始，循环5次
//    {
//        test();
//    }
//    return 0;
//}
//为什么这个函数输出是2
//因为每次调用test函数的时候，我们就会定义一次a并赋值为1，然后就是2，
//第二轮循环也一样，在每个循环的开始a都是以1出现的，所以最后打印的结果就是5个2




void test()//进入函数
{
    static int a = 1;//在局部变量前面加static\
    //输出结果截然不同，结果为：23456
    a++;
    printf("%d", a);
}

int main()
{
    for (int i = 0; i < 5; i++)//i从0开始，循环5次
    {
        test();
    }
    return 0;
}
//为何在局部变量前面添加static后，结果变得不一样了
//static修饰局部变量改变了变量的声明周期
//在test函数中没有static的话，局部变量 是进入这个函数开始，出去这个函数生命周期结束
//没有被static修饰，局部变量的位置是在栈区的，进入这个函数生成，出去这个函数销毁
//被static修饰修饰的变量就不放在栈区了，就放在静态区了，static修饰修饰的变量叫静态变量
//存储在静态区的变量和全局变量一样的，声明周期就和程序的生命周期一样了
//但是本代码中的a的作用域不变，
//ststic修饰的变量，在第二轮循环的时候，使用的变量就是上一次留下来的，而不是新建的变量

//如何使用static去修饰变量
//:未来一个变量出了函数，我们还想保留值，等下次进入函数继续使用，就可以使用static去修饰这个变量

//如何使用static去修饰局部变量

//:未来一个变量出了函数，我们还想保留值，等下次进入函数继续使用，就可以使用static去修饰这个变量

// 将全局变量放到其他文件
//函数要先声明再使用，变量也一样
//一个全局变量，要想在其他文件中使用，只需要用extern声明外部符号，就可以使用了
//全局变量是默认带有外部链接属性的，只要用extern引用就行了
extern int g_val;//对变量进行声明
int main()
{
    printf("%d\n", g_val);



    return 0;
}
//但是如果想引用其他文件夹的全局变量，但是这个全局变量被static修饰了，
//  那么这个全局变量就不能被引用


//static修饰全局变量的时候，改变了全局变量的链接属性
//使得外部链接属性，变成了内部链接属性
//这种变量只能在自己所在的.c文件中使用，其他的.c文件中无法使用

//使用建议:如果一个全局变量，只想在所在的源文件内部使用，不想被其他文件发现，
// 就可以使用static修饰

//函数在另一个文件


//extern Add(int, int);//声明外部符号就可以使用了
//函数也具有外部链接属性的，只要在其他的.c文件中正确的声明，也可以直接使用

int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    int c = Add(a, b);
    printf("c=%d\n", c);
    return 0;
}

//Add(int x, int y)//static修饰函数，让函数外部链接属性变为内部链接属性
// 只能在自己所在的.c文件中使用，其他.c文件中无法使用
//{
//    return x + y;
//}