C语言初阶——3函数

1. 函数是什么

函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。

您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的，但在逻辑上，划分通常是根据每个函数执行一个特定的任务来进行的。

函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。

C 标准库提供了大量的程序可以调用的内置函数。例如，函数 strcat() 用来连接两个字符串，函数 memcpy() 用来复制内存到另一个位置。

函数还有很多叫法，比如方法、子例程或程序，等等。

2. 函数分类

2.1 库函数

为什么会有库函数？
1） 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
2） 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
3）在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。
像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。
简单的总结，C语言常用的库函数都有：
IO函数
字符串操作函数
字符操作函数
内存操作函数
时间/日期函数
数学函数
其他库函数

2.2 自定义函数

如果库函数能干所有的事情，那还要程序员干什么？
所有更加重要的是自定义函数。
自定义函数和库函数一样，有函数名，返回值类型和函数参数。 但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。

• 函数组成：

ret_type fun_name(para1, * )
{
    statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1    函数参数

eg：写一个函数，找出两个整数中的最大值

3.函数的参数

实参和形参之间的关系：形参是实参的一份拷贝 ~ 如果我们修改了形参，那对实参没有任何影响~

3.1 实际参数（实参）：

真实传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

3.2 形式参数（形参）：

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

3.3 举例：交换函数

1、一开始写形参写的是（int x , int y）
这个时候调用函数的时候发现，它并没有对实参真的进行交换，只是交换形参而已

#include<stdio.h>



int swap(int x, int y)
{
	int temp = x;
	x = y;
	y = temp;
}


int  main()
{
	int a = 1;
	int b = 2;

	int result = swap(a, b);

	printf("%d,%d\n", a,b);

	return 0;
}

运行程序我们就会发现。a和b 的值根本没有改变，这是因为我们改变的仅仅是形参的值，实参的数据我们并没有进行操作。

我们需要对实参进行操作，需要将函数形参定义为：（int * x , int * y）;
int * x 表示 是整形指针类型的变量x
int * y 表示 是整形指针类型的变量y

只有传入实参的地址，才能真正找到我们实参的数字，才能对其进行操作。

#include<stdio.h>



int swap(int *x, int *y)
{
	int temp = *x;
	*x = *y;
	*y = temp;
}


int  main()
{
	int a = 1;
	int b = 2;

	int result = swap(&a, &b);

	printf("%d,%d\n", a,b);

	return 0;
}

只有*x访问到的值才是2,*y访问到的值是1，进行交换才能改变实参。

注意：
还有这个地方int temp = * x;
（这里的 * 是解引用的意思，意思是取到整形指针变量x的地址，地方，也就是传进来的实参1）
不能写成：
int *temp =*x
如果这样写，就变成指针变量的交换了。

4.函数的调用

• 传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

• 传址调用

1）传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
2）这种传参方式可以让函数和函数外边的变量建立起正真的联系，也就是函数内部可以直接操作函数外部的变量。

4.1 练习

1. 写一个函数可以判断一个数是不是素数。

//写一个函数可以判断一个数是不是素数。

int isPrim(int x)
{
	if (x == 1||x == 0)
	{
		return 0;
	}


	for (int i = 2; i < x; i++)
	{
		if (x % i == 0)
		{
			return 0;
		}
		return 1;

	}
}




int main()
{
	int num = 0;
	scanf("%d", &num);
	int result = isPrim(num);
	printf("%d\n", result);



	return 0;
}

• 写一个函数判断一年是不是闰年。
  闰年规则：
  1）普通闰年，不能被400整除的时候，就判断能不能被4整除
  2）世纪闰年，能被100整除的时候，就判定能不能被400整除，

//判断是不是闰年


int isLeapYear(int year)
{
	if (year % 100 == 0)
	{
		//世纪闰年
	    if (year % 400 == 0)
	    {
		return 0;
	    }
	return 0;
	}
	else {
		//普通闰年
		if (year % 4 == 0)
		{
			return 1;
		}
		return 0;

	}
	//if (year % 400 != 0 && year % 4 == 0)
	//{
	//	return 1;
	//}
	//if (year % 100 == 0&& year % 400 == 0)
	//{
	//	return 1;
	//}
	//return 0;
}

int  main()
{
	int year = 0;
	scanf("%d", &year);

		/*
	int y = isLeapYear(year);
	printf("%d\n", y);*/
	
	printf("%d\n", isLeapYear(year));

	return 0;
}

• 写一个函数，实现一个整形有序数组的二分查找。

#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

//其中arr表示待查找的数组
//x表示要去查找的数字
//形参这里的 int arr[] 已经不是一个数组了，而是被隐式转成一个指针int *
//C中的第二个惊天BUG ：数组名一言不合就转成指针了
//一般在函数传参的时候会转、还有对数组进行运算，进行加减比较的时候会转


int BinaySerch(int arr[], int size, int x)
{
	int left = 0;

	//int right = sizeof(arr) / sizeof(arr[0]);//C语言中求数组长度的经典办法！！
	//这里这样写是不对的，前面求出来是4 后面求出来也是4
	//sizeof 求的是四字节的个数，再除以最小单位
	//所以我们需要在数组名转成指针之前进行求其长度，具体求法在main函数中进行求解，最后需要给二分查找函数，添加一个参数，就是数组长度
	int right = size - 1;//设计left ,right是一个前闭后闭区间
	//只要这个区间不为空，就需要进行查找。
	while (left <= right)
	{
		int mid = (left + right) / 2;
		if (x < arr[mid])
		{

			//去左侧查找
			right = mid - 1;
		}
		else if (x > arr[mid])
		{
			//去右边查找
			left = mid + 1;
		}
		else {
			//找到了，此处使用函数返回值表示找到元素的下标
			//此处最好不要printf 
			//我们也不知道调用者到底是想拿到结果之后做什么事情，
			//调用者可能是需要打印，可能是需要记录文件，也可能是需要参与其他事情
			//这些事情都不应该是 binarySearch 这个函数需要考虑的事情
			//我们一般一个函数就做一件事，二分查找就进行查找
			//设计函数原则就是：一个函数只做一件事
			return mid;
		}
	}
	
	//如果上面的循环最后也没有找到合适的数字，
	//返回一个无效的下标，通常是返回-1
	return -1;

}


int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int size = sizeof(arr) / sizeof(arr[0]);


	//for (int i = 0; i < 10; i++) {
	//	scanf("%d", &arr[i]);
	//}
	int b = BinaySerch(arr,size, 5);
	printf("%d\n", b);
	return 0;
}

C中的数组很容易就转成指针了（指向首元素的指针）这是C中的第二个惊天BUG
很多时候都会出现：函数传参、参与运算的时候…
求数组长度：int size = sizeof(arr) / sizeof(arr[0]);
这样的写法还是比较抽象的
后面的高级编程语言对不这样求数组长度了

• 写一个函数，每调用一次这个函数，就会将num的值增加1。

#include<stdio.h>


void functionAdd(int *num)
{
	(*num)++;
	//必须加括号，*num++:会先算num++,再解引用
	
	
}
int main()
{
	int num = 0;
	//调用函数，使得num每次增加1
	functionAdd(&num);
	printf("%d\n", num);

	return 0;
}

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

• 嵌套调用

	functionAdd(&num);

• 链式访问：
  把一个函数的返回值作为另外一个函数的参数。把isLeapyear函数的返回值作为 printf的输入参数：

printf("%d\n", isLeapYear(year));

6 函数的声明和定义

函数声明：

1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，无关紧要。
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中的。
   eg :

extern void functionAdd(int* num);

#include 包含头文件，有两种模式：

#include <> 从系统目录中进行查找头文件（安装编译器的目录）
#include“ ” 先从当前项目查找，如果没找到，再找系统目录
eg:

//这是一个特殊的预处理指令
//保证头文件只被包含一次
#pragma once


extern void functionAdd(int* num);

第二种：也是防止头文件被重复编译

#ifndef __TEST_H__
#define __TEST_H__
//函数的声明
int Add(int x, int y);
#endif //__TEST_H__

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

7 函数递归

7.1 什么是递归？

程序调用自身的编程技巧称为递归（ recursion）。 递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。 递归的主要思考方式在于：把大事化小

一个函数自己调用自己，这就叫“递归”。
递归的代码有一个特点，看起来代码就只有寥寥几行，实际上执行过程非常复杂~一般多少次超出人脑能思考的范围，我们需要结合画图和调试进行理解学习

7.2 递归的两个必要条件

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

7.3 练习

7.3.1 练习1：顺序打印每一位

1. 接受一个整型值（无符号），按照顺序打印它的每一位。 例如： 输入：1234，输出 1 2 3
   

#include<stdio.h>
#include"test.h"

int printNum(unsigned int num )
{
	if (num > 9)//表示num是两位数
	{//开始递归调用
		printNumx(num / 10);
	}
	printf("%d ", num % 10);
}
//函数递归
int main()
{
	//一个整型值（无符号），按照顺序打印它的每一位。 例如： 输入：1234，输出 1 2 3 4.
	printNum(1234);
	return 0;
}

调试熟悉递归~

DLL是动态链接库~~

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

第一版

#include<stdio.h>
#include"test.h"


int myStrlen(char* str)
{
	//求数组长度，从字符串开头开始，依次往后找 '\0'
	//每遇到一个字符，如果不是‘\0’就count++
	//遇到‘\0’就结束循环，返回count的值即可
	int i = 0;
	int count = 0;
	for (int i = 0; i <7; i++)
	{
		if (str[i] != '0')
		{
			count++;
		}
	}
	
	return count;
	}
int main()
{//编写函数不允许创建临时变量，求字符串的长度。
	int arr[] = { '1','2','3','4','5','6','7','0'};
	int ret = myStrlen(arr);
	printf("%d\n", ret);

	return 0;
}

是自己写的但是觉得自己写的很扯，就是因为不知道长度求长度，我这直接for循环，那不是还得知道长度呢。

第二版：使用while循环，但是我们没有按照题目要求来进行求解，题目要求不能创建局部变量。继续改进

#include<stdio.h>
#include"test.h"
int myStr(char str[])//这里还可以写成int  myStr(int *str) 这两者是等价的
{
	int count = 0;
	while (str[count] != '\0')
	{
		count++;
	}

	return count;

}
int main()
{
	printf("%d\n", myStr("abcd"));
	return 0;
}

第三版：像这种不允许创建局部变量，或者不让使用循环，就可以考虑递归。

按理说,数组是数组，指针是指针：两个互不相干的事情~ ~
但是C语言的设计就把这俩概念给整ran了 ~ ~ 数组一言不合就变成指针了~ ~ 指针又能像数组一样[ ] 来取下标~~

指针运算.可以加减一个整数~+1意味着得到一个新的指针,这个新的指针,指向下一个元素.
例如：str保存这"abcd"中a的地址~.
str + 1就得到了一个新的指针变量,里面保存的就是b的地址~ str + 2里面保存的就是c的地址~

//如果不让创建局部变量和循环，就可以考虑递归
int myStr2(char* str)
{
	if (str[0] == '\0')
	{
		return 0;
	}
	return 1 + myStr2(str +1);
}


int main()
{
	//printf("%d\n", myStr("abcd"));
	printf("%d\n", myStr2("abcd"));
	return 0;
}

这个代码的含义是这样的：要求"abcd"的长度,转换成求"a"的长度+ "bcd"的长度~

7.3.3 编写函数求n的阶乘

//求n的阶乘~递归求法
int factor(int num) {
	if (num == 1)
	{
		return 1;
	}
	return  num * factor(num - 1);
}



int main()
{
	printf("%d\n", factor(6));


	return 0;
}

7.3.3 斐波那契数列

//斐波那契数列
int fib(int n) {
	if (n == 1 || n ==2) {
		return 1; 
	}

	return fib(n-1) + fib(n - 2);
}

int main()
{
	printf("%d\n", fib(6));

	//printf("%d\n", factor(6));


	return 0;
}