C语言学习 3.函数

函数

1. C语言中函数的分类

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

1.1 库函数

C语言中常用的库函数有：

• IO函数 printf scanf getchar purchar

• 字符串操作 strcmp strlen

• 字符操作函数 toupper

• 内存操作函数 memcpy memcmp memset

• 时间/日期操作函数 time

• 数学函数math pow

• 其他库函数

如何使用库函数

MSDN

<www.cplusplus.com>

http://en.cppreference.com (英文版)

http://zh.cppreference.com （中文版）

1.2 自定义函数

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

2. 函数的参数

2.1 实际参数（实参）

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

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

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

2.2 形式参数（形参）

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

例：写一个函数可以交换两个整型变量的内容

//错误版本
void Swap1(int x, int y)
{
	int tmp = 0;
	tmp = x;
	x = y;
	y = tmp;
}

//正确版本
void Swap2(int* px, int* py)
{
	int tmp = 0;
	tmp = *px;
	*px = *py;
	*py = tmp;
}
	
int main()
{
	int num1 = 1;
	int num2 = 2;
	Swap1(num1, num2);
	printf("Swap1:num1=%d num2=%d", num1, num2);
	Swap2(&num1, &num2);
	printf("Swap2: num1=%d num2=%d", num1, num2);

	return 0;
}

上面Swap1和Swap2中的参数x，y,px,py都是形式参数，在main函数中传给Swap1的num1,num2和传给Swap2的&num1,&num2是实际参数,Swap1在被调用时，x,y拥有自己的空间但地址与num1,num2不同，同时拥有了和实参一样的内容，因此可以认为：形参实例化后相当于实参的一份临时拷贝。

3. 函数的调用

3.1 传值调用

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

3.2 传址调用

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

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

void test (int arr[])
{
    arr[0]=1;
    arr[1]=2;
}

int main()
{
   int arr[10]={0};
   test(arr);//形参使用数组可以将两个数据返回给主调函数
   return 0;
}

3.3 练习

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

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

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

int main()
{
	//打印100-200之间的素数
	int i = 0;
	int count = 0;
	for (i = 100;i <= 200;i++)
	{
		if (is_prime(i) == 1)
		{
			count++;
			printf("%d ", i);
		}
	}
	printf("\ncount=%d", count);
	return 0;
}

2. 写一个函数判断一年是不是闰年

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

int is_leap_year(int n)
{
	if ((n % 4 == 0 && n % 100 != 0) || (n % 400 == 0))
    //也可直接return((n % 4 == 0 && n % 100 != 0) || (n % 400 == 0))
		return 1;
	else
		return 0;
}

int main()
{
	//打印1000-2000之间的闰年
	int y = 0;
	int count = 0;
	for (y = 1000;y <= 2000;y++)
	{
		if (is_leap_year(y))
		{
			printf("%d ", y);
			count++;
		}
	}
	printf("\ncount=%d\n", count);
	return 0;
}

3. 写一个函数，实现一个整型有序数组的二分查找

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

int binary_search(int arr[],int k,int sz)
{
	int left = 0;
	int right = sz - 1;
	while(left <= right)
	{
	     int mid = (left + right) / 2;
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else 
		{
			return mid;
		}
	}
		return -1;	
}

int main()
{
	//找到返回下标，找不到返回-1
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int key = 7;
	int sz = sizeof(arr) / sizeof(arr[0]);//必须在查找函数外定义，arr传递的是数组首元素的地址，如果在函数内求，则sizeof(a)=4,计算的是指针大小。
	int ret = binary_search(arr,key,sz);
	if (ret == -1)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，下标为：%d\n", ret);
	}
	return 0;
}

4. 写一个函数，每调用一次这个函数，就会将num的值加1

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

void Add(int* n)
{
	(*n)++;//++优先级高于*，也可写成*n=*n+1
}
int main()
{
	int num = 0;
	Add(&num);
	printf("%d\n", num);
	Add(&num);
	printf("%d\n", num);
	Add(&num);
	printf("%d\n", num);
	return 0;
}

5. 设计一个算法，求a和b的最小公倍数

#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d%d", &a, &b);
	int i = 1;
	while(1)
	{
		if (a * i % b == 0)
		{
			printf("%d\n", a * i);
			break;
		}
		i++;
	}
	return 0;
}

6. 将一句话的单词进行倒置，标点不倒置（输入长度不超过100）

例：I like beijing.经过函数后变为：beijing. like I

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

void reverse(char* left, char* right)
{
	while (left < right)
	{
		char tmp =0;
		tmp = *left;
		*left = *right;
		*right = tmp;

		left++;
		right--;
	}
}

int main()
{
	char arr[100] = { 0 };
	gets_s(arr);//输入
	int len = strlen(arr);

	//第一步：先将整句话倒置
	reverse(arr, arr + len - 1);

	//第二步：再将每句话中的每个单词倒置
	char* start = arr;
	while (*start)
	{
		char* end = start;
		while (*end != ' ' && *end != '\0')
		{
			end++;
		}
		reverse(start, end - 1);
		if (*end = ' ')
		{
			start = end + 1;
		}
		else
			start = end;
	}
	printf("%s\n", arr);
	return 0;
}

4. 函数的嵌套调用与链式访问

4.1 嵌套调用

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

#include<stdio.h>

void new_line()
{
	printf("haha\n");
}
void three_line()//打印了三次haha
{
	int i = 0;
	for (i = 0;i < 3;i++)
	{
		new_line();
	}
}

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

4.2 链式访问

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

#include<stdio.h>

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "ADD";
	strcpy(arr1, arr2);//strcpy(),将arr2的内容拷贝到arr1中
	printf("%s\n", arr1);
	//链式访问
	printf("%s\n", strcpy(arr1, arr2));
	return 0;
}

5. 函数的声明与定义

5.1 函数声明

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

5.2 函数定义

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

test.h的内容放函数的声明

#ifndef__TEST_H__
#define__TEST_H__
//函数的声明
int Add(int x,int y)

#endif//__TESH_H__

test.c的内容放函数的实现

#include"test.h"
int Add(int x,int y)
{
    return x+y; 
}

这种分文件书写的形式，在三子棋和扫雷时再详细展开。

6. 函数递归

6.1 什么是递归

程序调用自身的技巧称为递归，递归的主要思考方式在于：把大事化小。

每次函数调用都会在内存开辟一块新的函数栈帧。

6.2 递归的两个必要条件

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

6.3 练习

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

输入：1234，输出1 2 3 4

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>

void print(unsigned int n)
{
	if (n >= 10)
	{
		print(n / 10);//全部执行完后猜开始打印，假如1234，1 2 3 4
	}
	printf("%d ", n%10);
}

int main()
{
	unsigned int num = 0;
	scanf("%u", &num);//%u为打印无符号值
	print(num);
	return 0;
}

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

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

int my_strlen(char* str)
{
	if ((*str) != '\0')
	{
		return 1 + my_strlen(str + 1);
	}
	else
	{
		return 0;
	}
}

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

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

//递归方式
#include<stdio.h>

int factorial(int n)
{
	if (n > 1)
	{
		return n * factorial(n - 1);
	}
	else
	{
		return 1;
	}
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret=factorial(n);
	printf("%d", ret);
	return 0;
}

//非递归方式
int factorial(int n)
{
	int i = 0;
	int ret = 1;
	for (i = 1;i <= n;i++)
	{
		ret *= i;
	}
	return ret;
}

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

//递归方式
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>

int count = 0;
int fib(int n)
{
	if (n == 3)
		count++;//如果n为较大数，count的值会非常大
	if (n > 2)
	{
		return fib(n - 1) + fib(n - 2);
	}
	else
	{
		return 1;
	}
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret=fib(n);
	printf("%d", ret);
	return 0;
}

//非递归方式
int fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1;
	while (n > 2)//不断前移
	{
		a = b;
		b = c;
		c = a + b;
		n -= 1;
	}
	return c;
}

但是上面代码存在问题，当要求的数字太大时会特别费时间，甚至程序会崩溃。这是因为：

1. fib在调用过程中进行了很多重复计算。

2. 系统分配给程序的内存空间时有限的，但如果出现了死循环或死递归，就有可能导致一直开辟栈空间，最终导致栈空间耗尽，这样的现象称为栈溢出。

如何解决上述问题：

1. 将代码写成非递归。

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

6. 实现一个函数，打印乘法口诀表，行数和列数自己决定

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

void print_table(int n)
{
	int i = 0;
	int j = 0;
	for (i = 1;i <= n;i++)
	{
		for (j = 1;j <= i;j++)
		{
			printf("%2d*%-2d=%-3d ", i, j, i * j);
		}
		printf("\n");
	}
}

int main()
{

	int n = 0;
	scanf("%d", &n);
	print_table(n);
	return 0;
}

7. 将参数字符串中的字符反向排列，不是逆序打印，且不能使用函数库中的字符串操作函数

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

int my_strlen(char* str)
{   
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
//递归写法
void reverse_string(char* str)
{
	char tmp = *str;
	int len = my_strlen(str);
	*str = *(str + len - 1);
	*(str + len - 1) = '\0';
	if (my_strlen(str + 1) >= 2)
	{
		reverse_string(str + 1);
	}
	*(str + len - 1) = tmp;
}

int main()
{

	char arr[] = "abcdef";
	reverse_string(arr);//数组名arr是数组arr首元素的地址
	printf("%s\n", arr);
	return 0;
}

//非递归写法
void reverse_string(char* str)
{
	int left = 0;
	int right = my_strlen(str) - 1;
	while (left < right)
	{
		int tmp = *(str + left);
		*(str + left) = *(str + right);
		*(str + right) = tmp;
		left++;
		right--;
	}
}

8. 编写一个函数实现n的k次方，使用递归实现

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>

double Pow(int n, int k)
{
	if (k == 0)
		return 1.0;
	else if (k > 0)
		return n * Pow(n, k - 1);
	else
		return 1 / (Pow(n,-k));
}

int main()
{
	int n = 0;
	int k = 0;
	scanf("%d%d", &n,&k);
	double ret = Pow(n, k);
	printf("%lf", ret);
	return 0;
}

9. 写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

int digitsum(unsigned int i)
{
	if (i > 9)
		return (i % 10 + digitsum(i / 10));
	else
		return i;
}

int main()
{
	unsigned int i = 0;
	scanf("%u", &i);
	int n = digitsum(i);
	printf("%d\n", n);
	return 0;
}