C语言-函数

函数

定义：

维基百科对计算机中函数的定义：

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

C语言中的函数

C语言中的函数分为两类：

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

【库函数是什么】

像之前使用过的printf，scanf，getchar，putchar，这些都是库函数，比如很多的程序员在写代码时都需要用到输入输出操作，所以，像输入输出操作这种常用的功能，C语言就对其进行了封装，避免程序员每次使用该功能时，都要自己去实现该功能。这样就提高了效率，方便程序员更好的进行软件开发。

【库函数的学习】

参考：https://cplusplus.com/reference/

我们将常用的库函数分个类：

• IO函数
• 字符串操作函数
• 内存操作函数
• 时间/日期函数
• 数学函数
• 其他库函数

我们来看看其中的几个库函数的使用：

• strcpy函数：

  

Parameters：参数

Return Value：返回值

通过查阅我们了解到，strcpy函数的功能是Copy string，将source指针指向的内容拷贝到destination中，并且’\0’也会被拷贝。**其头文件为string.h,**需要包含。

我们来看看具体用法：

int main()
{
	char arr1[] = { "World!" };
	char arr2[10] = { "Hello!"};
	printf("before:%s\n", arr2);
	strcpy(arr2, arr1);//将arr1拷贝到arr2中。
	printf("after:%s", arr2);
	return 0;
}

运行结果：

memset函数的功能是Fill block of memory(填充内存块)，将ptr指针指向的内容的前num个字节的值设置为value，其头文件是string.h，需要包含

看看具体用法：

int main()
{
	char arr[] = { "World!" };

	printf("before:%s\n", arr);
	memset(arr, 'x', 1);
	printf("after:%s", arr);
	return 0;
}

运行结果：

注意：在我们使用库函数时，需要通过 #include 包含其对应的头文件。

【自定义函数】

库函数虽然很常用，但其也无法完成生活中的全部需要，不然还需要程序员干什么呢，库函数不够用时，我们就可以自定义函数，自己实现它。

自定义函数和库函数一样，需要函数名，返回值类型，函数参数列表，函数体。

举个例子：写个函数求两个数的最大值

//语法格式：返回值类型 函数名（参数列表）{函数体}
int get_max(int x, int y)//此处用x，y接收a和b。
{
 return (x>y)?(x):(y);//这里要返回的数的类型与返回值类型是对应的
}
int main()
{
 	int num1 = 10;
 	int num2 = 20;
 	int max = get_max(num1, num2);
 	printf("max = %d\n", max);
	return 0;
}

我们再写一个能交换两个数的函数

void Swap1(int x, int y)
{
     int tmp = 0;
     tmp = x;
     x = y;
     y = tmp;
}
int main()
{
     int num1 = 1;
     int num2 = 2;     
     printf("Swap1::num1 = %d num2 = %d\n", num1, num2);
     Swap1(num1, num2);
     printf("Swap2::num1 = %d num2 = %d\n", num1, num2);
     return 0;
}

我们发现函数并不能达到理想的功能，这是为什么呢？这里我们就需要了解函数的参数了。

【函数的参数】

【实际数参】：

我们在使用函数时，真实给函数传递的参数是实际参数，简称实参。

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

无论函数的实参是什么类型，在将其作为实参调用时，必须要有确定的值。假如传递的是一个变量，那么这个变量必须要有确切的值

【形式参数】：

形式参数是值函数名之后括号内的变量，简称形参。为什么叫形参呢？这是因为形式参数只在函数被调用时才被创建（分配内存单元），当函数调用完毕时，形式参数自动被销毁，所以形式参数只在函数体内有效。

接下来我们解释一下上述的Swap1函数为何无法实现功能：

通过调试我们发现，x，y和num1，num2的内存空间是不同的。所以在Swap1函数中对x，y的操作只对x，y生效，也就是说，Swap1函数只是将x，y的值进行的交换，在函数调用结束时，x，y的内存空间就被释放了，而num1，num2没有任何变化，所以a，b的值不会被交换。这里总结起来就是：函数被调用时，形参会被实例化（开辟内存空间），形参实例化的过程其实就是对实参的一份临时拷贝。

那么这个函数应该如何改进呢？我们可以尝试将num1，num2的地址传递给形参。具体如下：

void Swap2(int *px, int *py)
{
 int tmp = 0;
 tmp = *px;
 *px = *py;
 *py = tmp;
}
int main()
{
     int num1 = 1;
     int num2 = 2;
     printf("Swap1::num1 = %d num2 = %d\n", num1, num2);
     Swap2(&num1, &num2);
     printf("Swap2::num1 = %d num2 = %d\n", num1, num2);
     return 0;
}

Swap2函数被调用时，其形参px，py本质上是指针变量，其中存放的分别是num1，num2变量的地址，再通过*（解引用）操作符找到实参所在的内存空间，*px就相当于是num1变量本身，*py类似。再通过操作*px,*py来操作num1和num2.

【函数的调用】

函数的调用主要分为为两种：

• 传值调用
• 传址调用

【传值调用】

函数的形参和实参分别占用不同的内存空间，对形参的改变不会影响实参。

【传址调用】

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

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

函数调用的注意点：先看下边的代码：

int main()
{
	int a = 1;
	int b = 4;
	int c = Add(a, b);
	printf("%d", c);
	return 0;
}
int Add(int x, int y)
{
	return x + y;
}

编译之后会有一个警告：

这个警告是什么意思呢？它在提醒我们：我们在使用Add函数的时候，没有对其进行定义，因为在使用Add函数之前，并没有看到Add函数的实现。正确的做法是：我们应该把函数定义在其使用之前。还有一种解决办法就是在文件的最开始对自定义函数进行声明操作，这样不管在任何时候使用自定义函数就不会产生警告了。

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

函数声明的语法：

//返回值类型 函数名 参数列表  
//以下两种方式都可：
int Add(int x,int y);
int Add(int ,int);

方法一：

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int a = 1;
	int b = 4;
	int c = Add(a, b);
	printf("%d", c);
	return 0;
}

方法二：

int Add(int x,int y);//声明函数
int main()
{
	int a = 1;
	int b = 4;
	int c = Add(a, b);
	printf("%d", c);
	return 0;
}
int Add(int x, int y)
{
	return x + y;
}

【函数的嵌套调用和链式访问】

【嵌套调用】：

#include <stdio.h>
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;
}

以上这样函数之间可以相互调用。

注意：函数可以嵌套调用但是不能嵌套定义。

嵌套定义的例子：

#include <stdio.h>

void three_line()
 {
    
    
 void new_line()//不能在函数中再次定义函数。会编译出错
    {
         printf("hehe\n");
    }
    
 
    	int i = 0;
	 for(i=0; i<3; i++)
   {
        new_line();
   }
}
int main()
{
 	three_line();
 	return 0;
}

【链式访问】

链式访问就是将一个函数的返回值作为另外一个函数的参数。

例子：

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[20] = "hello";
    int ret = strlen(arr);
    printf("%d\n", ret);
 return 0;
}

上段代码中，strlen函数将字符串arr的长度计算出之后，将结果赋值给了ret变量，再通过printf函数打印ret变量展示计算结果。

我们将这段代码改进以下：

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[20] = "hello";
    printf("%d\n", strlen(arr));
 return 0;
}

改进之后，strlen函数将返回值直接作为printf函数的参数并进行打印操作，这就是函数的链式访问。

【链式访问的小练习】：

int main()
{
    printf("%d", printf("%d", printf("%d", 43)));
    //结果是啥？
    //打印4321
    return 0;
}

要想知道执行结果，就必须知道printf函数的返回值的含义：

通过查阅，printf函数的返回值就是被打印的字符的个数，那么就可以推测打印结果了。最里面的printf函数打印了43，返回值是2，外一层的printf函数再将2打印，返回1，最外层的printf函数再将1打印。

那么下面这段代码的结果呢？

int main()
{
    printf("%d", printf("%d", printf("%d ", 43)));//这里多了一个空格
    //结果是啥？
    return 0;
}

【函数递归】

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

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

举个例子：

int main()//这就是递归，当然这是个错误的示范。
{
	printf("hello\n");
	main();
}

练习1：写一个能打印一个整数的每一位的递归

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(num);
	return 0;
}

运行结果：

图解：

递归的必要条件：

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

练习2：写一个能求字符串函数的递归函数

#incude <stdio.h>
int Strlen(const char*str)
{
     if(*str == '\0')
     return 0;
     else
     return 1+Strlen(str+1);
}
int main()
{
     char *p = "abcdef";
     int len = Strlen(p);
     printf("%d\n", len);
     return 0;
}

练习

实现可以判断一个数是不是素数的函数。

int IsPrime(int n)//100 - 200的素数
{
	int i = 0;
	for (i = 2; i <= sqrt(n); i++)
	{
		if (n % i == 0)
		{
			return -1;
		}
	}
	return 1;
}
int main()
{
	int i = 0;
	int count = 0;
	for (i = 100; i < 200; i++)
	{
		if (IsPrime(i) == 1)
		{
			printf("%d ", i);
			count++;
		}
	}
	printf("\nThe Number Is %d", count);
	return 0;
}

判断一年是不是闰年。

int is_leap_year(int y)//闰年
{
	return( (y % 4 == 0) && (y % 100 != 0) || (y % 400 == 0));
}
int main()
{
	int year = 0;
	int i = 0;
	int count = 0;
	for (i = 1000; i <= 2000; i++)
	{
		if (is_leap_year(i) == 1)
		{
			printf("%d ", i);
			count++;
		}
	}
	printf("\n%d\n", count);
	return 0;
}

实现一个整形有序数组的二分查找

int BinarySearch(int* arr, int k, int size)
{
	int left = 0;
	int right = size - 1;
	int mid = 0;
	while (left <= right)
	{
		mid = left + (right - left) >> 2;//计算中间元素的下标,防止数据溢出
		if (arr[mid] == k)
		{
			return mid;
		}
		if (arr[mid] > k)
		{
			right = mid - 1;
		}
		if (arr[mid] < k)
		{
			left = 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]);
	int k = 4;//记录要查找的数
	int ret = BinarySearch(arr, k, size);
	if (ret == -1)
	{
		printf("Not Find!\n");
	}
	else
	{
		printf("The Number Is Found! The Composition Is %d!\n", ret);
	}
	return 0;
}

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

void Plus(int* p)
{
	(*p)++;//++的优先级大于*
}
int main()
{
	int num = 0;
	int i = 0;
	for (i = 0; i < 8; i++)
	{
		Plus(&num);
		printf("%d ", num);
	}
	return 0;
}