C语言 - 函数（二） - IPS99技术分享

1.函数的嵌套调用和链式访问

函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。

1.1嵌套调用

你写的函数我可以用，我写的函数你可以用，这个叫做嵌套调用。

但是不可以嵌套定义

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int main()
{
	int a = Add(1, 2);
	printf("%d",a);
	return 0;
}
// 函数的地位是平等的

男女的地位也是平等的！

1.2链式访问

当函数不写返回值时，返回类型默认为int

#include <string.h>
int main()
{
	int len = strlen("asdasdsadwadfgree");// 计算字符串的长度
	//printf("%d", len);
	// 链式访问 像一个链条把函数串起来了
	//printf("%d\n", strlen("asdasdsadwae"));
	printf("%d", printf("%d",printf("%d",43)));输出结果为4321
	return 0;
}

2.函数的声明和定义

2.1函数声明：

1.告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不存在，函数声明决定不了。

2.函数的声明一般出现在函数的使用之前。要满足先声明后使用。

3.函数的声明一般要放在头文件中的。

2.2函数的定义

函数的定义是指函数的具体实现，交代函数的功能实现。

test.h

防止函数的声明

#include <stdio.h>
#define	_CRT_SECURE_NO_WARNINGS
//函数声明和定义
// 要把函数定义在后面 前面要进行函数的声明
int Add(int x, int y);// 告诉他有个函数叫Add 他的第一参数的类型是int  第二个参数的类型也是int
int main()
{
	int a = 0;
	int b = 0;
	scanf_s("%d %d", &a, &b);
	// 完成加法
	int sum = Add(a,b);
	printf("和为%d",sum);
	return 0;
}
// 函数的定义
int Add(int x, int y)
{
	return x + y;
}

在初学编程的时候，觉得把所有的代码写到一个文件夹里最方便。

但是在公司不是这么写！

1. 从协作的角度考虑
2. 模块儿化设计

例如业务拆分计算机拆分：加法减法乘法除法

一个文件写函数的声明一个文件写函数的实现

#include <stdio.h>
#define	_CRT_SECURE_NO_WARNINGS
//函数声明和定义
// 要把函数定义在后面 前面要进行函数的声明
// 告诉他有个函数叫Add 他的第一参数的类型是int  第二个参数的类型也是int
#include "Add.h"
#include "sub.h"

int main()
{
	int a = 0;
	int b = 0;
	scanf_s("%d %d", &a, &b);
	// 完成加法
	int sum = Add(a,b);
	printf("和为%d",sum);
	int ret = Sub(a, b);
	printf("差为%d",ret);
	return 0;
}

ADD.h

#pragma once
// 加法函数的声明
int Add(int x,int y);

ADD.c

// 加法函数的实现
int Add(int x, int y)
{
	return x + y; 
}

sub.h

#pragma once
// 减法函数的声明
int Sub(int x, int y);

sub.c

// 减法函数的实现
int Sub(int x, int y)
{

	return x - y;
}

导入静态库的一个方法

3.函数递归

3.1什么是函数递归

程序调用自身的编程技巧称为递归(recursion)

递归作为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中由直接或间接调用自身的

一种方法，他通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略

只需要少量的程序就可以描述出解题过程所需要的多次重复计算，大大减少了程序的代码量。

递归的主要思考方式在于：把大事化小

3.2递归的两个必要条件

存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件

3.2.1练习1

接受一个整形值（无符号），按照顺序打印他的每一位。

例如：

输入1234，输出1 2 3 4

unsigned 接收一个无符号的整数

使用函数递归来实现

// 使用函数递归来实现
void print(unsigned int n) // 参数类型为 unsigned 
{
	if (n > 9)//if本身不是一个循环 但是加了一个printf函数就是循环了
	{
		print(n / 10);// 结果为123  一直除以10当变量为个位数时 跳出循环 然后模10
	}
	printf("%d ",n%10);// 结果为4

}
int main()
{
	unsigned int num = 0;// unsigned 接收一个无符号的整数
	scanf_s("%u", &num);
	print(num);//接受一个整形值（无符号），按照顺序打印他的每一位。
	
	return 0;
}

 思路
// print(1234);
// print(123) 4 最容易得出一个4  1234 % 10 得出4
// print(12) 3 4
// print(1) 2 3 4
//1 2 3 4

3.2.2练习2

编写函数不允许创建临时变量，求字符串的长度

// 编写函数不允许创建临时变量，求字符串的长度

// 先实现求字符串的长度
// 模拟实现strlen
#include <string.h>
// int my_strlen(char str[]) 参数部分写成数组形式
int my_strlen(char* str) //a的地址传过去需要一个char*的值接收 参数部分写成指针形式
{
	int count = 0;//计数，临时变量
	while(*str != '\0')
	{
		count++;
		str++;// 找下一个字符
	}
	return count;
}
int main()
{
	char arr[] = "abc";
	int len = my_strlen(arr);
	printf("%d", len);	
	return 0;
}
// 允许创建临时变量的写法

不允许创建临时变量，递归求解

int my_strlen(char* str)
{
	if (*str != '\0')
	{
		return 1 + my_strlen(str+1);// 如果要取b地址 第一个字符加1
	}
	else
		return 0;

}
int main()
{
	char arr[] = "abc";
	int len = my_strlen(arr);
	printf("%d", len);	
	return 0;
}

3.3递归与迭代

3.3.1练习3

求n的阶乘。（不考虑溢出）

// 递归实现
int fac(int n)
{
	if(n <= 1)
	{
		return 1;
	}
	else
	{
		return n * fac(n - 1);
	}
}
int main()	
{
	int n = 0;
	scanf_s("%d",&n);
	int ret = fac(n);
	printf("阶乘的结果为%d", ret);
	return 0;
}

3.3.2练习4

求第n个斐波那契数。

1 1 2 3 5 8 13 21·········

前两个数相加的和等于第三个数

规律可以写为n = （n-1） + (n-2)

int Fib(int n)
{
	if (n <= 2)
	{
		return 1;
	}
	else
	{
		return Fib(n - 1) + Fib(n - 2);
	}
}
int main()
{
	int n = 0;
	scanf_s("%d", &n);
	int ret = Fib(n);
	printf("ret = %d", ret);
	return 0;
}

带入Fib 找出斐波那契数规律

但是我们发现：

在使用Fib这个函数时，如果我们要计算第50个斐波那契数的时候特别费时间。
使用factorial函数求10000的阶乘，程序会崩溃

因为在调用的过程中很多计算一直在重复

函数递归的几个经典题目：

汉诺塔问题

青蛙跳台问题

分享知识，记录生活！

标签：return,函数,递归,int,C语言,Add,printf
From： https://blog.csdn.net/2301_79799881/article/details/144055152

C语言 - 函数（二）