C语言函数

风中的云彩

发布于 2024-11-07 21:44:14

8150

文章被收录于专栏：C/C++的自学之路C/C++的自学之路

I don't expect anything but I'm open for everything.

函数概念

1. C语言中的函数就是：完成某项特定任务的一小段代码。 2. 类比一个小工厂，里面有已经设定好的特定的步骤，就是实现函数功能的过程。

函数分类

库函数

1. 网址：https://zh.cppreference.com/w/c/header 。 2. 使用库函数时，需要引入包含该库函数的头文件。

自定义函数

语法形式

ret_type fun_name(形式参数)
{

}

//ret_type 是函数返回类型
//fun_name 是函数名
//括号中放的是形式参数
//{}括起来的是函数体

形参和实参

1. 实参的内容传递给了形参，说明他们之间是有联系的。 2. 但是形参和实参其实占用了不同的内存空间。 3. 形参是实参的⼀份临时拷贝，调用完函数之后，形参所占用的内存被释放。

#include <stdio.h>
int Add(int x, int y)
{
	int z = 0;
	z = x + y;
	return z;
}
int main()
{
	int a = 0;
	int b = 0;
	//输⼊
	scanf("%d %d", &a, &b);
	//调⽤加法函数，完成a和b的相加
	//求和的结果放在r中
	int r = Add(a, b);
	//输出
	printf("%d\n", r);
	return 0;
}
//我们把第17⾏调⽤Add函数时，传递给函数的参数a和b，称为实际参数，简称实参。
//第2⾏定义函数的时候，在函数名add后的括号中写的x和y，称为形式参数，简称形参。

return 语句

1. 如果函数的返回类型是 void ，那么可以在完成函数调用之后，可以不用 return 语句。 2. return 语句执行后，函数就彻底返回，后边的代码不再执行。

void InitListNode(ListNode** pphead)//由于要改变phead指针的指向，所以要传入phead的地址，即使用ListNode** pphead。
{
	*pphead = CreateListNode(-1);//头指针指向头节点（不存储有效数据的节点）
}

数组做函数参数

1. 函数的形参要和函数调用时候的实参个数、类型匹配。 2. 函数的实参是数组，那么就有两种形参，第一种是以数组的形式来接收，第二种是以指针的形式来接收。（都是传递地址调用） 3. 形参接收的数组和实参的数组是同⼀个数组。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void set_arr(int arr[4][4], int a, int b);
void printf_arr(int arr[4][4], int a, int b);
int main()
{
	int arr1[4][4] = { 0 };
	set_arr(arr1, 4, 4);
	printf_arr(arr1, 4, 4);
	return 0;
}
void set_arr(int arr[4][4], int a, int b)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			scanf("%d", &arr[i][j]);
		}
	}
	return;
}
void printf_arr(int arr[4][4], int a, int b)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			printf("%d", arr[i][j]);
		}
	}
	return;
}

自定义函数的声明和定义

1. 如果自定义函数出现了先调用再定义时，需要在开头加上函数声明。

int is_leap_year(int y)；
int get_days_of_month(int y, int m)；

//把函数定义第一行直接拿来，在最后加上分号。

嵌套调用和链式访问

1. 嵌套调用就是，函数之间的互相调用。 2. 所谓链式访问就是，将⼀个函数的返回值作为另外⼀个函数的参数，像链条⼀样将函数串起来就是函数的链式访问。

//func.h
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int calculate(int m, int n);
int cal_year(int m);

//test.c
#include "func.h"
int main()
{
	int  m = 0, n = 0;
	scanf("%d%d", &m, &n);
	int a = calculate(m, n);//嵌套调用
	printf("%d", a);
	return 0;
}

//func.c
int calculate(int m, int n)
{
	int arr1[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	int day = arr1[n];
	if (cal_year(m))//嵌套调用
	{
		day++;
	}
	return day;
}
int cal_year(int m)
{
	if (((m % 4 == 0) && (m % 100 != 0)) || (m % 400 == 0))
		return 1;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
	printf("%d", strlen("1234567"));//链式访问
	return 0;
}

分文件书写

//.h中存放各种函数声明和其他库函数引用的声明。
//.c中存放主函数和自定义函数的调用。
//.c中主函数要加上 “.h” 的声明。

例如：写一个加法函数。

<test.c>文件

#include "add.h"
int main()
{
	int a = 0, b = 0;
	scanf("%d%d", &a, &b);
	int c = add(a, b);
	printf("%d", c);
	return 0;
}
存放主函数

<add.c>文件

int add(int a, int b)
{
	return (a + b);
}
存放自定义函数

<add.h>文件

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int add(int a, int b);
存放声明和定义

函数递归

函数递归概念

//递归就是函数自己调用自己
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
	printf("hehe");
	main();
	return 0;
}
//陷入了死循环

函数递归例子

例1：阶乘计算

//算n的阶乘
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int Func(int i)
{
	if (i == 0)
		return 1;
	else
		return (i * Func(i - 1));
}
int main()
{
	int i = 0;
	scanf("%d", &i);
	int a = Func(i);
	printf("%d", a);
	return 0;
}
//先递推到临界值，再回归。

例2：按顺序打印每一位

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void Printf(int i)
{
	if (i >= 9)
    {
		Printf(i / 10);
    }
	printf("%d", i % 10);
}
int main()
{
	int i;
	scanf("%d", &i);
	Printf(i);
	return 0;
}

例3：运行时堆栈

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int Func(int i)
{
	printf("%d", i);
	if (i < 100000)
		Func(i+1);
	else
		printf("%d", i);
	return 0;
}
int main()
{
	int i = 0;
	scanf("%d", &i);
	Func(i);
	return 0;
}
//需要运行的计算太大了，直接中途停止了。