C语言的函数

1. 函数是什么

• 计算机科学中的子程序，是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。
• 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。

2. C语言中函数的分类

1. 库函数
2. 自定义函数

2.1 库函数

2.1.1 如何学会使用库函数

学会查询工具的使用：

• MSDN（vs菜单栏搜索中输入Help Viewer下载组件）
• www.cplusplus.com
• http://en.cppreference.com（英文）
• http://zh.cppreference.com（中文）

2.2 自定义函数

自定义函数和库函数一样，有函数名，返回值类型和函数参数。

但不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。

//函数组成
ret_type fun_name(para1,*)
{                     //函数体
    statement;        //语句项
}

ret_type 返回类型
fun_name 函数名
para1    函数参数

#include

int Get_Max(int a, int b)
{
	return (a > b ? a : b);	//求较大值
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int c = Get_Max(a, b);
	printf("%d\n", c);
	return 0;
}

//两数字交换
#include

//形式参数
void Change(int x, int y)
{
	int temp = 0;
	temp = x;
	x = y;
	y = temp;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	Change(a, b);            //实际参数
	printf("%d %d", a, b);   //因为在调用Change函数时，是将实际参数ab的数值拷贝一份存入xy中，所以在后续xy调换后不影响ab的结果，ab调换失败
	return 0;
}

*******************************************************************************************

//形式参数
void Change(int* x, int* y)
{
	int temp = 0;
	temp = *x;
	*x = *y;
	*y = temp;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	Change(&a, &b);            //实际参数
	printf("%d %d", a, b);     //此次在调用Change函数时，Change函数拿到的是ab的地址存入到了xy指针中，在函数内通过*解引用xy，直接调换地址内的数值，所以最后调换成功
	return 0;
}

在需要改变传入实参的值时，形参用指针的方式传入。不需要改变传入实参的值时，形参用普通方式传入。

3. 函数的参数

3.1 实际参数（实参）

真实传给函数的参数，叫实参。

实参可以是：常量、变量、表达式、函数等。

3.2 形式参数（形参）

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

形参实例化之后其实相当于实参的一份临时拷贝。

4. 函数的调用

4.1 传值调用

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

4.2 传址调用

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

5. 练习

//打印100~200之间的质数
#include

int GetPrimeNumber(int x)                 //找质数函数
{
	for (int i = 2; i <= sqrt(x); i++)    //在数字根号前找不到因子即可判断是质数
	{
		if (x % i == 0)
		{
			return 0;
		}
	}
	return 1;
}

int main()
{
	for (int i = 101; i < 200; i+=2)        //循环找100~200之间奇数的质数
	{
		if (GetPrimeNumber(i) == 1)
		{
			printf("%d ", i);
		}
	}
	return 0;
}

//判断1000~2000年中的闰年
#include

int GetLeapYear(int year)        //获取闰年函数
{
    //方法一
	/*if (year % 400 == 0)
	{
		return 1;
	}
	else if (year % 100 == 0)
	{
		return 0;
	}
	else if (year % 4 == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}*/

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

int main()
{
	int a1 = 0;
	int b1 = 0;
	scanf("%d %d", &a1, &b1);        //输入年份
	for (int year = a1; year <= b1; year++)
	{
		if (GetLeapYear(year) == 1)
		{
			printf("%d ", year);
		}
	}

	return 0;
}

为了提高可使用性，自定义函数中最好不要使用printf函数，函数实现的功能要足够单一。

//二分查找
#include

int BinarySearch(int arr[], int y, int sz)
{
	int left = 0;
	int right = sz - 1;
	int mid;
	while (left <= right)			//循环条件
	{
		mid = left+(right-left)/2;	//防止溢出
			if (y < arr[mid])
			{
				right = mid - 1;
			}
			else if (y > arr[mid])
			{
				left = mid + 1;
			}
			else
			{
				return mid;			//找到情况
			}
	}
	return -1;						//找不到情况
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 9;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int ret = BinarySearch(arr, k, sz);
	if (ret == -1)
	{
		printf("找不到\n");
	}
	else
	{
		printf("下标为%d \n", ret);
	}
	return 0;
}

此处sz不能在函数内求，因为arr（数组）传入的是首元素地址，64位地址是8字节，做除法后结果为2。数组传参实际上传入的是数组首元素的地址，而不是整个数组。

bool类型是C99引入的类型，大小为1字节，使用时要引用头文件。

//每调用一次函数数字会加一
#include

void Add(int* p)
{
	(*p)++;
}

int main()
{
	int num = 0;
	Add(&num);
	printf("%d\n", num);
	Add(&num);
	printf("%d\n", num);
	return 0;
}

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

6.1 嵌套调用

#include 

void new_line()
{
    printf("hehe\n");
}

void three_line()
{
    int i=0;
    for(i=0;i<3;i++)
    {
        new_line();
    }
}

int main()
{
    three_line();
    return 0;
}

函数可以嵌套调用，但是不能嵌套定义。

6.2 链式访问

#include 

int main()
{
    printf("%d",printf("%d",printf("%d",43)));    //printf的返回值是打印的字符个数
}

前提是函数有返回值。

7. 函数的声明和定义

7.1 函数声明

1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数声明决定不了。
2. 函数的声明一般出现在函数的使用前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中。函数一般分为声明文件和定义文件，分别写在.h和.c文件中（一共分成函数声明文件.h、函数定义文件.c和源文件.c），使用的时候用#include “头文件.h”引用。引用头文件就相当于是把头文件的声明内容复制到源文件开始位置中。

#include 

int Add(int a,int b);    //不先定义函数的话需要先声明，保持和下面一直

int main()
{
    int a = 0;
    int b = 10;
    int sum = Add(a, b);
    printf("%d\n",sum);
    return 0;
}

int Add(int a,int b)
{
    return a+b;
}

生成静态库是将代码转换成二进制，防止别人看见代码内容。

生成静态库：新建项目中添加现有项，将头文件和源文件添加。解决方案资源管理器中项目名称右键-属性-常规-配置类型-静态库-确定。然后Ctrl+F7生成一个.lib结尾的静态库。

使用静态库：将头文件和静态库文件放入使用的项目文件夹中。添加头文件。#include“头文件.h”。#pragma comment(lib,"静态库文件.lib")。

//引入头文件
#include

#include"add.h"
//导入静态库
#pragma comment(lib,"add.lib")

int main()
{
    int a = add(2,5);
    printf("%d\n",a);
}

7.2 函数定义

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

8. 函数递归

8.1 什么是递归

程序调用自身的编程技巧称为递归。

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

8.2 递归的两个必要条件

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

//倒序打印输入的每个数字
#include

void print(int num)             //循环，不是递归
{
	while (num != 0)            //当数字等于0的时候跳出
	{
		printf("%d ", num%10);
		num /= 10;
	}
}

int main()
{
	print(1234);                
	return 0;
}

//正序打印输入的每个数字
#include

void print1(int num)
{
	/*if (num >9)                //方法一
	{
		print1(num / 10);
	}
	printf("%d ", num % 10);*/

	if (num != 0)                //方法二
	{
		print1(num / 10);
		printf("%d ",num % 10);
	}
}

int main()
{
	print1(1234);
	return 0;
}

思路：顺序打印方式为

1. print(123) 4
2. print( print(12) 3) 4
3. print( print( print(1) 2) 3)4

括号内部为递归部分，括号后为递归后输出的部分。

//求字符串长度
#include

//int my_strlen(char chr[])		//参数部分写成数组的形式
int my_strlen(char* chr)		//参数部分写成指针的形式
{
	int count = 0;        //临时变量，计数
	while (*chr != '\0')
	{
		count++;
		chr++;
	}
	return count;
}

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

//不创建临时变量，求字符串长度
int my_strlen1(char* chr)
{
	if (*chr != '\0')
	{
		return 1+my_strlen1(chr+1);
	}
	else
	{
		return 0;
	}
}

int main()
{
	char arr1[] = "abcdef";
	printf("%d\n", my_strlen1(arr1));
	return 0;
}

思路：计算方式为

1. a my_strlen1(bcd\0)
2. a my_strlen1(b my_strlen1(cd\0))
3. a my_strlen1(b my_strlen1(c my_strlen1(d\0)))
4. a my_strlen1(b my_strlen1(c my_strlen1(d a my_strlen1(\0))))

括号内部为递归部分，括号前为递归前加一的部分。

8.3 递归与迭代

//计算阶乘
int fac(int num)
{
	if (num != 1)
	{
		return num * fac(num - 1);
	}
	else
	{
		return 1;
	}
}
int main()
{
	printf("%d\n", fac(4));
	return 0;
}

思路：

1. 4*(3*2*1)
2. 4*(3*(2*1))
3. 4*(3*(2*(1)))

在调试函数的时候，如果递归的参数比较大，就可能会报错：stack overflow（栈溢出）这样的信息。局部变量、函数的形参返回值调用存放在栈区，系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者死递归，这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象成为栈溢出。

解决：

将递归写成非递归。

使用static对象替代nonstatic局部对象。