1. 函数是什么？
2. C语言中函数的分类
- 2.1 库函数
- 2.2 自定义函数
3. 函数的参数
4. 函数的调用
5. 函数的嵌套调用和链式访问
- 5.1 嵌套调用
- 5.2 链式访问
6. 函数的声明和调用
7. 递归
- 7.1 什么是递归？
- 7.2 递归的两个必要条件
- 7.3 递归与迭代

1. 函数是什么？

维基百科中对函数的定义：子程序

在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method,subprogram, callable unit），是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。

2. C语言中函数的分类

库函数
自定义函数

C语言标准规定了一些库函数：

// 函数名，参数类型，返回值类型，函数功能规定好。

编译器的厂商提供库函数。

2.1 库函数

C语言本身提供的函数 – 称为库函数。
C语言常见的库函数有：
- IO函数（input ，output，输入输出函数）
- 字符串操作函数
- 字符操作函数
- 内存操作函数
- 时间/日期函数
- 数学函数
- 其他库函数

参考文档，学习几个库函数。

例一：strcpy – string copy – 字符串复制有关。

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "bit";
	char arr2[] = "#######";
	strcpy(arr2, arr1);
	printf("%s\n", arr2);

	// strlen  -- string length  -- 跟字符串长度有关的
	// strcpy  -- string copy    -- 字符串复制有关。// /0也会拷贝

	return 0;
}

// 运行结果
// bit

第3章函数1. 函数是什么？2. C语言中函数的分类3. 函数的参数4. 函数的调用5. 函数的嵌套调用和链式访问6. 函数的声明和调用7. 递归

例二：memset – memory – 内存 set – 设置

#include <stdio.h>
#include <string.h>

int main ()
{
  char str[] = "almost every programmer should know memset!";
  memset (str,'-',6);
  puts (str);
  return 0;
}
// 运行结果
// ------ every programmer should know memset!


#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "hello bit";
	char* ret = (char*)memset(arr, 'x', 5);
	printf("%s\n", ret);
	return 0;
}

需要学会查询工具的使用：

MSDN(Microsoft Developer Network)

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 <stdio.h>

// 定义宏
#define MAX(X, Y) (X>Y?X:Y)

// 定义函数
int get_max(int a, int b) 
{
	return a > b ? a : b;
}

int main()
{
	int a = 10;
	int b = 20;
	printf("get_max(a, b) = %d\n", get_max(a, b));

	printf("MAX = %d", MAX(a, b));
	return 0;
}

写一个函数，可以交换两个整型变量的值。

#include <stdio.h>

//void Swap1(int a, int b)
//{
//	int tmp = 0;
//	tmp = a;
//	a = b;
//	b = tmp;
//}

// 不能完成任务
// 当实参传给形参的时候，
// 形参是实参的一份临时拷贝
// 对形参的修改是不会改变实参的

void Swap2(int* pa, int* pb) {
	int tmp = 0;
	tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}
int main()
{
	int num1 = 10;
	int num2 = 20;

    // Swap1(num1, num2);
	// printf("num1 = %d, num2 = %d\n", num1, num2);
	
	Swap2(&num1, &num2);
	printf("num1 = %d, num2 = %d\n", num1, num2);
	return 0;
}
// 运行结果
// num1 = 10, num2 = 20
// num1 = 20, num2 = 10

总结：

能将函数处理结果的两个数据返回给主调函数，的方法有：

形参用数组;
形参用两个指针;
用两个全局变量。

3. 函数的参数

实际参数（实参）：

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

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

无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

形式参数（形参）：

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

上面例子中

Swap1

和

Swap2

函数中的参数

、

pa

、

pb

都是形式参数。在

main

函数中传给

Swap1

函数的

num1

、

num2

和传给

Swap2

函数的

&num1

、

&num2

是实际参数。

这里我们对函数的实参和形参进行分析：

第3章函数1. 函数是什么？2. C语言中函数的分类3. 函数的参数4. 函数的调用5. 函数的嵌套调用和链式访问6. 函数的声明和调用7. 递归

可以看到

Swap1

函数在调用的时候，

，

拥有自己的空间，同时拥有了和实参一模一样的内容。所以我们可以简单的认为：形参实例化之后其实相当于实参的一份临时拷贝。

4. 函数的调用

传值调用：

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

形参是实参的一份临时拷贝。

传址调用：

传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的格式。

这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。

练习：

写一个函数，判断一个数是否是素数。

#include <stdio.h>
#include <math.h>

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

int main()
{
	int a = 18;
	if (1 == is_prime(a))
		printf("%d是素数\n", a);
	else
		printf("%d不是素数\n", a);

	return 0;
}

写一个函数，判断一年是否是闰年。

#include <stdio.h>
int is_leap_year(int x)
{
	return ((x % 4 == 0 && x % 100 != 0) || (x % 400 == 0));
}
int main()
{
	int year = 2008;
	if(1 == is_leap_year(year))
		printf("%d是闰年\n", year);
	else
		printf("%d不是闰年\n", year);
	return 0;
}

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

#include <stdio.h>
				// 本质上这里的 a 是一个指针
int binary_search(int a[], int b,int sz)
{
	int left = 0;
	// 调用函数的时候不能使用这种方式，求数组长度。
	// 	   sizeof() 计算指针的大小就是 4 或者 8
	// int sz = sizeof(a) / sizeof(a[0]);
	 int right = sz - 1;

	while (left <= right)
	{
		int mid = (left + right) / 2;
		if (a[mid] < b)
			left = mid + 1;
		else if (a[mid] > b)
			right = mid - 1;
		else
			return mid;
	}
	return -1;
}

int main()
{
	// 二分查找
	// 在一个有序数组中查找具体的某个数
	// 如果找到了，返回这个数的下标，找不到返回-1
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 1;
	int sz = sizeof(arr) / sizeof(arr[0]);
	// 传递过去的是首元素的地址
	int ret = binary_search(arr,k,sz);
	if (ret == -1)
		printf("找不到指定数字\n");
	else
		printf("找到了,下标是：%d\n", ret);

	return 0;
}

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

#include <stdio.h>
void Add(int* p)
{
	(*p)++;
    // 由于++的优先级比*高，如果不给*p加括号，那么将得不出正确的结果。
}
int main()
{
	int num = 0;
	Add(&num);
	printf("num = %d\n", num);
	Add(&num);
	printf("num = %d\n", num);
	Add(&num);
	printf("num = %d\n", num);

	return 0;
}
// num = 1
// num = 2
// num = 3

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

5.1 嵌套调用

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

#include <stdio.h>

void new_line()
{
	printf("hello world\n");
}

void three_line()
{
	int i = 0;
	for(i=0; i<3; i++)
	{
		new_line();
	}
}
 
int main()
{
 	three_line();
 	return 0;
}
// 运行结果
// hello world
// hello world
// hello world

5.2 链式访问

把一个函数的返回值作为另外一个函数的参数。

#include <stdio.h>
#include <string.h>

int main()
{
    printf("%d",printf("%d",printf("%d",43)));
    return 0;
}


// printf的返回值是打印在屏幕上的字符的个数。
// 如果发生错误，将返回负数。
// 运行结果
// 4321

6. 函数的声明和调用

函数声明：

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

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

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

函数的定义：

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

将函数声明放到

Add.h

文件中。

// #pragma one  -- 使头文件只会被包含一次。 -- 等价于 ifndef

#ifndef __ADD_H__    // 如果没有定义过__ADD_H__ 
#define __ADD_H__    // 定义__ADD_H__ 

// 函数声明
int Add(int x, int y);

#endif // !__ADD_H__

将函数定义放到

Add.c

文件中。

// 函数的定义
int Add(int x, int y)
{
    int z = x + y;
    return z;
}

在

test.c

文件中进行使用。

#include <stdio.h>
#include "add.h"  // 自己写的头文件用 "" 双引号引 

// 导入静态库
// #pragma comment(lib,"add.lib")
int main()
{
	int a = 10;
	int b = 20;
	int sum = 0;
	sum = Add(a, b);
	printf("%d\n", sum);
	return 0;
}

分块去写的好处：

多人协同；
封装和隐藏；

7. 递归

7.1 什么是递归？

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

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

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

最简单的递归调用

#include <stdio.h>
int main()
{
	printf("haha\n");
	main();
	return 0;
}
// 该程序会进入死循环打印 haha ，栈内存耗光后会报如下图所示的错误。
// 函数调用向栈区申请空间

第3章函数1. 函数是什么？2. C语言中函数的分类3. 函数的参数4. 函数的调用5. 函数的嵌套调用和链式访问6. 函数的声明和调用7. 递归

7.2 递归的两个必要条件

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

《函数栈帧的创建和销毁》

练习

接收一个整型值（无符号），按照顺序打印它的每一位。

例如：

输入: 1234，输出: 1 2 3 4.

#include <stdio.h>
void print(unsigned int n)
{
	if (n > 9)
	{
		print(n / 10);
	}
	printf("%d ", n % 10);
}
int main()
{
	unsigned int num = 0;
	scanf("%d", &num); // 1234

	// 递归
	// print(1234)
	// print(123)   4
	// print(12)  3 4
	// print(1) 2 3 4   
	//
	print(num);
	return 0;
}

第3章函数1. 函数是什么？2. C语言中函数的分类3. 函数的参数4. 函数的调用5. 函数的嵌套调用和链式访问6. 函数的声明和调用7. 递归

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

#include <stdio.h>
#include <string.h>

// 计数器的方式
//int my_strlen(char* str)
//{
//	int count = 0;
//	while(*str != '\0')
//	{
//		count++;
//		str++;
//	}
//	return count;
//}


// 递归的方法
// 把大事化小
// my_strlen("bit");
// 1+my_strlen("it");
// 1+1+my_strlen("t");
// 1+1+1+my_strlen("");
// 1+1+1+0
int my_strlen(char* str)
{
	if (*str != '\0')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}

int main()
{
	char arr[] = "bit";
    // char* p = "bit"; // 也可以
	int count = 0;
	// int len = strlen(arr);
	// printf("%d \n", len);

	int len = my_strlen(arr);   // arr是数组，数组传参，传过去的不是整个数组，而是第一个元素的地址
	printf("len = %d \n", len);
	return 0;
}

#include <stdio.h>
#include <assert.h>
unsigned int my_strlen(const char* str)
{
	assert(str != NULL);
	int count = 0;
	while (*str++)
		count++;
	return count;
}
int main()
{
	char arr[] = "abcdef";
	printf("字符个数为：%u\n", my_strlen(arr));
	return 0;
}

7.3 递归与迭代

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

#include <stdio.h>
// 递归的方式
int Fac(int n)
{
	if (n <= 1)
		return 1;
	else
		return n * Fac(n - 1);
}
int main()
{
	int n = 0;
	int ret = 0;
	scanf("%d", &n);
	ret = Fac(n);  // 递归的方式
	printf("%d\n", ret);
	return 0;
}

求第 n 个斐波那契数（不考虑溢出）。

#include <stdio.h>
// 递归方法
int Fib(int n)
{
	if (n <= 2)
		return 1;
	else
		return  Fib(n - 1) + Fib(n - 2);
}
int main()
{
	// TDD -- 测试驱动开发
	int ret = Fib(30);
	printf("ret = %d\n", ret);
	return 0;
}

上述代码存在问题：

在使用 Fac() 函数求10000的阶乘（不考虑结构的正确性），程序会崩溃。
使用 Fib() 函数的时候，如果要计算第 50 个斐波那契数字的时候特别消耗时间。

为什么呢？

我们发现

Fib()

函数在调用的过程中很多计算其实在一直重复。

如果我们把代码修改一下：

#include <stdio.h>

int count = 0; // 全局变量

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

// 运行结果
// ret = 832040
// 3 == 317811

// 可以看到 在求第30个斐波那契数的时候3就被运算了 317811次。

那我们如何改进呢？

在调试 Fac() 函数的时候，如果你的参数比较大，那就会报错： stack overflow （栈溢出）这样的信息。系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。

解决上述问题的方法：

将递归改成非递归。
使用 static 对象替代 nonstatic 局部对象。在递归函数设计中，可以使用 static 对象替代 nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放 nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。

采用非递归的方式实现上述案例：

// 循环的方式实现 求n的阶乘 
int Fac(int n)
{
	int i = 0; 
	int ret = 1;
	for (i = 1; i <= n; i++)
		ret *= i;
	return ret;
}


// 循环方式求斐波那契数
int Fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1; // 若将 c 赋值 0，则 n =1 和 n = 2的情况无法计算，将 c 赋值为1,则可以解决这个问题。
	while (n > 2 )
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	return c;
}

什么时候用递归：

当解决一个问题递归和非递归都可以使用，且没有明显问题，那就可以使用递归。
当解决一个问题递归写起来很简单，非递归比较复杂，且递归没用明显问题，那就用递归。
如果说，用递归解决问题，写起来简单，但是有明显问题，那就不能使用递归。

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

汉诺塔问题
青蛙跳台阶问题

. 将递归改成非递归。

2. 使用

static

对象替代

nonstatic

局部对象。在递归函数设计中，可以使用

static

对象替代

nonstatic

局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放

nonstatic

对象的开销，而且

static

对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。

采用非递归的方式实现上述案例：

// 循环的方式实现 求n的阶乘 
int Fac(int n)
{
	int i = 0; 
	int ret = 1;
	for (i = 1; i <= n; i++)
		ret *= i;
	return ret;
}


// 循环方式求斐波那契数
int Fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1; // 若将 c 赋值 0，则 n =1 和 n = 2的情况无法计算，将 c 赋值为1,则可以解决这个问题。
	while (n > 2 )
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	return c;
}

什么时候用递归：

当解决一个问题递归和非递归都可以使用，且没有明显问题，那就可以使用递归。
当解决一个问题递归写起来很简单，非递归比较复杂，且递归没用明显问题，那就用递归。
如果说，用递归解决问题，写起来简单，但是有明显问题，那就不能使用递归。

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

汉诺塔问题
青蛙跳台阶问题

希望可以对大家有所帮助，如果有什么不对的地方，还烦请指教，谢谢！

第3章函数1. 函数是什么？2. C语言中函数的分类3. 函数的参数4. 函数的调用5. 函数的嵌套调用和链式访问6. 函数的声明和调用7. 递归

目录

1. 函数是什么？

2. C语言中函数的分类

2.1 库函数

2.2 自定义函数

3. 函数的参数

4. 函数的调用

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

5.1 嵌套调用

5.2 链式访问

6. 函数的声明和调用

7. 递归

7.1 什么是递归？

7.2 递归的两个必要条件

7.3 递归与迭代

继续阅读

swmm与lisflood-fp源码如何一起编译 CMake命令

Windows下VS开发环境环境安装工程项目设置关于Debug和Release的提示

一文看懂字符串的加减乘除

C++ 第十五周报告1--《冒泡法排序》

C语言：初学者必定看懂的注释！！！猴子吃桃问题。猴子第一天摘下若干个桃子，每天都吃了前一天剩下的一半零一个，到第10天早上想再吃的时候，就剩下一个桃子. 求第一天共摘多少个桃子。

ICG表面修饰稀土上转换纳米颗粒，ICG-PCL-PEG-FA 吲哚菁绿-聚已内酯-聚乙二醇-叶酸

[转]九大排序算法——C语言实现及详解

C++实现简单顺序表

while 循环、do- while 循环和 for 循环之间的那点事C语言自学之三种循环比较

Android电视机（机顶盒）初次开发的一些经验分享

结构体：typedef与struct的区别

C经典书籍笔记——C陷阱与缺陷②(语法陷阱之优先级)一、错误案列二、优先级规律

线性表之顺序表的实现

C++判断素数、求最大公约数代码判断一个数是否为素数求两个数的最大公约数

SequoiaDB巨杉数据库C++驱动概述

hdu7108哈希

第3章 函数1. 函数是什么？2. C语言中函数的分类3. 函数的参数4. 函数的调用5. 函数的嵌套调用和链式访问6. 函数的声明和调用7. 递归

目录

1. 函数是什么？

2. C语言中函数的分类

2.1 库函数

2.2 自定义函数

3. 函数的参数

4. 函数的调用

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

5.1 嵌套调用

5.2 链式访问

6. 函数的声明和调用

7. 递归

7.1 什么是递归？

7.2 递归的两个必要条件

7.3 递归与迭代

继续阅读

第3章函数1. 函数是什么？2. C语言中函数的分类3. 函数的参数4. 函数的调用5. 函数的嵌套调用和链式访问6. 函数的声明和调用7. 递归