C语言学习笔记六、函数

六、函数

1.概念

某种功能代码的封装,也可以传递一些参数，根据参数的选择功能；也可以获取返回一个返回值

2.作用

①. 减少重复代码

②. 方便移植

3.函数的定义

例如：
//计算两数之和
//函数体 --》函数的定义
//返回值类型 函数名(形参1, 形参2)
int add(int a, int b)
{
    
    int num = a+b;
    
    return num;
}
函数内的功能代码--》函数体
​

4、函数的声明

        //函数声明
        //返回值类型 函数名(形参1， 形参2);
        int add(int a, int b);
        int add(int , int ); -->写声明时可以不写形参变量名

5.函数的调用

例如：
int main()
{
    int num;
    int add(int a, int b)
    {
        a+b;
    }
    num = add(300,400);   --》这种是获取函数返回值的调用。
    printf("%d", num);
    add(300,400);         --》不获取函数返回值的调用。
    
    return 0;
}
​
注意：
①.函数调用时不能写函数放回值类型，  如： int add(a,b);  这里的int是不能加的！！！
②.函数调用时不能写形参类型。       如： add(int a, int b); 括号内的参数不能加类型！！！

6.函数调用与定义的示例代码

#include <stdio.h>
#include <strings.h>
​
//函数声明
//返回值类型 函数名(形参1, 形参2);
int add(int a, int b);  //或者int add(int , int );函数的形参变量名可以不写。
​
int main()
{
    int num=0, a=100, b=200;
    num=add(a,b);
    printf("%d\n", num);
    
    return 0;
}
​
int add(int a, int b)
{
    int num = a + b;
    return num;
}

7.函数代码执行顺序

 

8.函数传参

①. 传值 --》调用函数时，把变量的值传递进去，在函数调用过程它是不会修改到原本函数变量的值

②. 传地址--》可以通过函数调用时，去修改原本函数变量的值

③. 传数组 -->最简单方便就是传递数组首元素地址

④. 主函数传参 --->在执行程序时，通过Linux命令行传递的参数，传递的参数都是字符串

传值和传递地址例子：
#include <stdio.h>
#include <strings.h>
​
int main()
{
    int num=100;
    
    //不获取返回值调用
    func(num);
    printf("main:&num:%p\n",&num);
    printf("main:num:%d\n", num); //num的值没有被修改
    
    //获取返回值调用
    num = func1(num);
    printf("main1:&num:%p\n",&num);
    
printf("main1:num:%d\n", num); //num的值有被修改
    
    func2(&num);
    printf("main2:&num:%p\n",&num);
    printf("main2:num:%d\n", num); //num的值有被修改
    
    
    
    //func1(&num);
    
    return 0;
}
​
//传参传递值，不可以修改原本函数变量的值
int func(int num) 
{
    num =200;
    printf("func:&num:%p\n",&num); //不是同个变量
    printf("func:num:%d\n", num);
    return 0;
}
//传参传递值，可以修改原本函数变量的值，只能通过返回值，给原本函数的值重新赋值
int func1(int num) //函数没有调用前，内存是没有分配，函数调用结束后，内存会被释放
{
    num =300;
    printf("func1:&num:%p\n",&num);//不是同个变量
    printf("func1:num:%d\n", num);
    return num;
}
​
//传参传递地址，可以修改原本函数变量的值
int func2(int *num_p) //函数没有调用前，内存是没有分配，函数调用结束后，内存会被释放
{
    *num_p=400;
    printf("func2:&num:%p\n",num_p);//不是同个变量
    printf("func2:num:%d\n", *num_p);
    return 0;
}
​
​
​
​
----------------------------------------------------------------------------
​
函数传参传递数组：
#include <stdio.h>
#include <strings.h>
#include <string.h>
void func(char buf[30]);
void func1(char (*p)[30] );
​
int main()
{
    char buf[30]="hello world";
    
    //func(buf);
    func1(&buf);//&buf -->char (*)[30] 
    return 0;
​
}
​
//void func(char buf[30])
//void func(char buf[])
//void func(char buf[10000])   //这三种方式都是表示传递的是首元素地址
void func(char *buf)           //基本上都用这种传递的是首元素地址
{
    printf("buf:%s\n", buf);
    int len = strlen(buf);
    printf("len:%d\n", len);
    printf("sizeof(buf):%u\n", sizeof(buf));
    
    return ;
}
​
void func1(char (*p)[30] )         //数组传参传递数组指针
{
    printf("*p:%s\n", *p);
    int len = strlen(*p);
    printf("len:%d\n", len);
    printf("sizeof(p):%u\n", sizeof(p));
    
    return ;
}
​
​
​
​
----------------------------------------------------------------------------
字符串本质：
//"./a.out"字符串本质是首字符地址，类型为：char *
    
    char *p = "hello";      //把字符串首字符地址保存到了p里面，字符串"hello"实际存储到了只读常量区
    //*p = 'd';  //不允许，只读常量区的数据不能修改
    
    printf("p:%s\n", p);
    
    char buf[10] = "hello"; //把整个字符串保存到了数组buf里面
    buf[0] = 'd';
    
    printf("buf:%s\n", buf);
​

9.函数执行过程

函数跳转执行：它是需要保护现场（保存寄存器的值，保存代码执行位置）
函数执行结束：会跳转会原本函数里面继续执行，它先需要恢复现场，把原本寄存器的值重新加载，恢复当前的代码执行位置
函数没有被调用前，里面的变量系统是不会分配内存的.
函数调用结束，内存会被释放