C语言基础教程_函数

---

前言

本篇主要记录C语言函数相关知识
个人学习笔记，如有错误，还请指正
希望各位能够点赞，收藏，关注。感谢各位。

---

一、函数的概念

函数是c语言的功能单位，实现一个功能可以封装一个函数来实现。
定义函数的时候一切以功能为目的，根据功能去定函数的参数和返回值

函数就是讲特定功能的代码封装在一个函数内部，当要使用这些代码时，只需要通过函数名就可以使用，这样操作起来更加方便

二、函数的分类

2.1 从定义角度分类

（1）库函数（C库实现的）
（2）自定义函数（程序员自己实现的）
（3）系统调用（操作系统实现的函数）

2.2 从参数角度分类

（1）有参函数、
函数由形式参数，可以是一个或者多个。参数类型取决于函数的功能

int fun(int a)
{
	//若干语句;
} 

（2）无参函数

int fun1(void)
{
	//若干语句;
}

2.3从返回值角度分类

（1）带返回值的函数
在定义函数的时候，必须要带返回值的类型，在函数体内，必须要有return
如果没有返回值类型，则默认返回int

char fun()
{
	char b = 'a';
	return b;
}

（2）没有返回值的函数
在定义函数的时候，函数名字前要加上void 表示没有返回值

void fun()
{
	//若干语句;
}

在函数里不需要return
如果想要结束函数，返回到被调用的地方，return; 什么都不返回就可以了

三、 函数的定义

3.1 函数的定义方法

返回值类型 函数名字(形参列表)
{
	//函数体
	//若干条语句
}

注意：
函数名字是标识符，所以需要满足标识符的命名规则
形参：按照函数功能具体需要，如果没有形参，也是需要加**()**
函数体上下位置必须要由 {}，形式参数必须要带类型，并且用逗号**，**分割开。
如果有返回值，需要在return 后面跟变量或者值，且必须要和函数名左侧的类型一致。
在一个程序中，相同的函数名只能出现一次

#include <stdio.h>

//定义一个没有参数也没有返回值的函数
void myfun1()
{
    printf("hello world\n");
    printf("nihao beijing\n");
    printf("welcome to 1000phone\n");

    return ;
}

//定义一个有参数的函数
void myfun2(int a, int b)
{
    int sum;
    sum = a + b;

    printf("%d + %d = %d\n", a, b, sum);
}

//定义一个有返回值的函数
int myfun3(int a, int b)
{
    int sum;
    sum = a + b;

    return sum;
}

int main(int argc, char *argv[])
{
    //函数的调用
    //函数在调用的时候如果没有参数，也必须加括号
    //函数调用的时候不能加返回值类型
    myfun1();

    return 0;
}

执行结果：

四、函数的声明

4.1 概念

（1）对已经定义的函数进行声明，函数的声明可以声明多次
（2）为什么要声明
有些情况下，不对函数声明，编译器在编译时，可能不认识这个函数。编译器在编译时，是从上往下编译的
（3）声明的方法

被调用函数和主调函数在哦同一个.c文件时,被调函数在下，主调函数在上。

直接声明法：将被调用的函数的第一行拷贝过去，后面加分号

void fun(void);	//函数的声明

int main()	//主调函数
{
	fun();
}

void fun(void)//被调函数
{
printf("hello,world!")
}

间接声明法：函数的声明放在头文件中，.c程序包含头文件即可

主调函数和被调函数不在同一个.c文件中的时候

声明的方法：
直接声明法
将被调用的函数的第一行拷贝过去，后面加分号，前面加extern
间接声明法（常用）
将函数的声明放在头文件中，.c程序包含头文件即可

五、函数的调用

函数调用方法

（1）带返回值的
变量 = 函数名（实参列表）；
（2）不带返回值
函数名（实参列表）；

#include <stdio.h>

void myfun1();
void myfun2(int a, int b);
int myfun3(int a, int b);
int main(int argc, char *argv[])
{
    //函数的调用
    //没有参数也没有返回值
    //直接写函数名，并且要在后面加括号
    myfun1();

    printf("**********************\n");

    //有参数，没有返回值
    //需要在函数名右边括号中传入参数，参数可以是常量表达式，也可以是变量表达式
    myfun2(100, 90);

    int x = 10, y = 20;
    //x、y：实参，实际参数，本质就是在函数调用的时候将实参的值传递给形参
    myfun2(x, y);

    printf("**********************\n");

    //有参数也有返回值
    //可以使用一个变量接收函数执行结果（返回值），或者直接输出也可以
    int n;
    n = myfun3(100, 90);
    printf("n = %d\n", n);

    printf("sum = %d\n", myfun3(90, 66));

    return 0;
}

void myfun1()
{
    printf("hello world\n");
    printf("nihao beijing\n");
    printf("welcome to 1000phone\n");

    return ;
}

//a、b：形参，形式参数，主要用于保存实参传递的值，本质跟实参没有任何关系，只是值传递
void myfun2(int a, int b)
{
    int sum;
    sum = a + b;

    printf("%d + %d = %d\n", a, b, sum);
}

int myfun3(int a, int b)
{
    int sum;
    sum = a + b;

    return sum;
}

执行结果：

六、函数总结

定义函数的时候，关于函数的参数和返回值是什么情况，完全取决于函数的功能。
当编写函数的时候，一开始不要想着函数如何传参和函数的返回值应该是什么
而是当在编写代码的途中，要使用某些值，但是当前函数中不存在，此时就需要进行传参，
这时候考虑怎么传参就是合适的时机
当函数编写完毕后，考虑是否要将某些结果返回给其他函数去使用，此时需要考虑返回值
使用函数的好处？
1、定义一次，可以多次调用，减少代码的冗余度。
2、使咱们代码，模块化更好，方便调试程序，而且阅读方便

七、变量的存储类型

7.1 内存的分区

（1）内存：物理内存，虚拟内存
物理内存：实实在在存在的存储设备
虚拟内存：操作系统虚拟出来的内存
操作系统会在物理内存和虚拟内存中间左映射

（2）在运行程序的时候，操作系统会将 虚拟内存分区

堆：

在动态申请内存的时候，在堆里开辟内存

栈：

主要存放局部变量。

静态全局区

未被初始化的静态全局区

静态变量（定义变量时候，需要用static修饰），或者全局变量没有初始化的存在本区

初始化的静态全局区

全局变量，静态变量，赋过初值的存放在本区

代码区

存放程序代码

文字常量区

存放常量的

7.2 普通的全局变量

7.2.1概念：

在函数外部定义的变量

//若干语句


int num  = 1;
int main()
{

	printf("%d\n",num);
	return 0;
}

7.2.2作用范围：

全局变量的作用范围是程序的所有地方，不过使用之气那需要声明，
extern int num 注意：在声明的时候不需要赋值

7.2.3生命周期：

程序运行这个那个过程中，全局变量一直存在，直到程序结束

注意：
定义普通的全局变量的时候，如果不进行赋初值，则它的默认值为0

#include <stdio.h>

//定义一个普通全局变量
//只要是在main函数外（也在子函数外）的变量，就是全局变量
//如果全局变量没有进行初始化，则系统自动将其初始化为0
int num;

//全局变量可以在程序的任意一个位置进行对其的操作
 void myfun()
 {
     num = 888;
 }

int main(int argc, char *argv[])
{
    printf("num = %d\n", num);

    myfun();

    printf("num = %d\n", num);

    return 0;
}

执行结果

7.3 静态全局变量

7.3.1概念

定义全局变量的时候，前面使用static修饰

static int num = 1;
int main()
{
	printf("%d",num);
	return 0;
}

7.3.2作用范围

static 限定了静态全局变量的作用范围
只能在定义他的.c文件中使用

7.3.3生命周期

在程序的整个运行过程中，一直存在

注意：
定义静态变量的时候，如果不赋初值，他的默认值为0。

#include <stdio.h>

//定义一个静态全局变量
//静态全局变量只能在其定义的.c文件中任意位置使用，不能跨文件使用
static int num;

void myfun()
{
    num++;
}

int main(int argc, char *argv[])
{
    printf("num = %d\n", num);

    myfun();

    printf("num = %d\n", num);

    return 0;
}

执行结果：

7.4普通的局部变量

7.4.1 概念

在函数内部定义的，或者复合语句中定义的变量

int main()
{
	int num  =1;	//局部变量
	
}

7.4.2 作用范围

在函数中定义的变量，在函数中有效
在复合语句中定义的变量，在复合语句中有效

7.4.3 生命周期

在函数调用之前，局部变量不占用空间，调用函数的时候，
才为局部变量开辟空间，函数结束了，局部变量就释放了。
在复合语句中定义的亦如此。

#include <stdio.h>

//定义一个局部变量
//在函数内部定义的，不加任何修饰的变量都是局部变量
void myfun()
{
    int num = 100;
    num++;

    printf("num = %d\n", num);

    return ;
}

int main(int argc, char *argv[])
{
    //局部变量只能在定义的函数内部使用，声明周期相对较短，函数结束，局部变量就会释放
    //printf("num = %d\n", num);
    myfun();
    myfun();
    myfun();

    return 0;
}

执行结果：

7.5 静态的局部变量

7.5.1 概念

定义局部变量的时候，在前面加上static修饰

7.5.2 作用范围

在它定义的函数或者复合语句中有效。

7.5.3 生命周期

第一次调用函数的时候，开辟空间赋值，函数结束后，不释放，以后调用那个函数的时候，不再为其开辟空间，也不赋初值，用的还是之前的那个变量。

#include <stdio.h>

//定义一个静态局部变量
//在函数内部定义的使用static修饰的变量就是静态局部变量

void myfun()
{
    //如果普通局部变量不进行初始化，则默认是随机值
    //如果静态局部变量不进行初始化，则默认是0
    int a; //普通局部变量
    static int num; //静态局部变量

    printf("a = %d\n", a);
    printf("num = %d\n", num);
}

void myfun1()
{
    //静态局部变量不会随着当前函数执行结束而释放空间，下次使用的函数之前的空间
    //静态局部变量只会初始化一次
    static int num1 = 100;
    num1++;

    printf("num1 = %d\n", num1);
}

int main(int argc, char *argv[])
{
    myfun();

    myfun1();
    myfun1();
    myfun1();

    return 0;
}

执行结果：

7.6 外部函数

咱们定义的普通函数，都是外部函数。
即函数可以在程序的任何一个文件中调用。
在分文件编程中，只需要将函数的实现过程写在指定的.c文件中，然后将其声明写在指定的.h文件中，其他文件只要包含了头文件，就可以使用外部函数

7.7 内部函数

内部函数也称之为静态函数，就是用static修饰的函数
在定义函数的时候，返回值类型前面加static 修饰。这样的函数被称为内部函数。
static 限定了函数的作用范围，在定义的.c中有效。
内部函数和外部函数的区别：
外部函数，在所有地方都可以调用，
内部函数，只能在所定义的.c中的函数调用。
扩展：
在同一作用范围内，不允许变量重名。
作用范围不同的可以重名。
局部范围内，重名的全局变量不起作用。（就近原则）

---

总结

在本片中主要讲解了C语言函数部分，以及变量的存储。
如有错误，请指正
码字不易，希望各位点赞，收藏，关注，感谢各位。