函数的简单了解

函数

使用函数可以提高代码的可读性与执行力

函数是什么

函数就是功能，每个函数用来完成特定任务的独立程序代码单元，功能的名字就是函数的名字

一般会有输入参数与返回值

函数的分类

函数分为库函数与自定义函数（重点介绍自定义函数）

库函数

C语言提供给我们可以直接使用的函数

为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员 进行软件开发。
包括常见的printf函数与scanf函数就是IO函数。

库函数的使用都有头文件

下面是一个简单的库函数的例子
strcpy

char* strcpy(char* destination, const char* source);

这是搜索得到的strcpy函数的使用方法，并且可以搜索出此函数的头文件是<string.h>

#include<stdio.h>
#include<string.h>//头文件
int main()
{
    char arr[20] = "abc";
    char b[20] = { 0 };

    strcpy(b, arr);//括号里面的叫做参数
    //这个函数的返回值是char类型
    printf("%s", b);

    return 0;
}

搜索库函数的网站：

需要学会查询工具的使用：
1.MSDN(Microsoft Developer Network)
2.www.cplusplus.com
3.http://en.cppreference.com（英文版）
4.http://zh.cppreference.com（中文版）

自定义函数

自己创建的函数

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

//定义函数
type name(parameter)
{
    
}
//定义函数可以没有括号内的参数，但是返回值类型与函数名以及函数名后面的括号不能少

函数名

指定函数的名字，以便后续被调用

返回值类型

有返回值

#include<stdio.h>
int Add()
{
    return 9;
}//这是一个自定义的函数，函数名叫做Add,返回值类型是int型的
//return 后面的值就是返回的内容，这个值也可以是表达式
int main()
{
    int x = 0;
    x = Add();//函数返回值会被赋给x,但是要求x的类型与函数返回类型相同
    printf("%d",x);//9
    return 0;
}

无返回值

也有的函数没有返回值，那么在返回值的位置输入的类型就应该是void，即：

void func()
{
    //这中情况下可以有return，也可以没有return，但是都不会返回到主函数里面
}

函数参数

实际参数

真实传递给函数的参数，叫做实参
实参可以是常量、变量、表达式、函数等
无论实参是何种类型的值，再传递实参时，实参必须是一个确定的值，以便把这个值传给形参

形式参数

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

 #include<stdio.h>
int Add(int c,int d)//被调函数
    //被调函数里面的参数叫做形参
{
    return c+d;
}
int main()
{
    int a = 20;
    int b = 30;
    int x = 0;
    x = Add(a,b);//主调函数
    //这里Add函数括号里就是函数的参数
    //主调函数里面的参数叫做实参
    
    printf("%d",x);//50
    return 0;
}

形参可以和实参命名相同吗？
可以，因为形参和实参是在不同的内存单元发挥作用的，作用域不相同，是互不影响的

函数的声明与 定义

函数的定义：指函数功能的建立，即从函数首部开始以函数体结尾的代码段。

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

如果函数的定义在主函数前，则不用声明就可以使用
如果函数的定义在主函数后，则需要先声明函数才能调用函数

函数调用的数据传递

函数的调用有两种方法

传值调用

将实参的值传给形参，形参在函数开始调用时才分配空间，将实参的值储存进去，这种情况形参和实参只有值是相同的，地址是不同的，在被调函数中形参的值发生改变不会影响到实参。

#include<stdio.h>
void Func(int x,)
{
    x++;
    printf("%d",x);//11
}
int main()
{
    int a = 10;
    Add(a);
    printf("%d",a);//10
    return 0;
}

传址调用

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

#include<stdio.h>
Func(int *pa)
{
*pa = *pa + 1;    
}
int main()
{
    int a = 10;
    Func(&a);
    printf("%d",a);//11
    return 0;
}//把变量a的地址存放在指针变量pa里面，后面*pa的操作就是在改变a的值

函数运用的练习

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

//是素数返回1；
//不是素数返回0；
#include<stdio.h>

int is_prime(int n)
{
	int j = 0;
	for (j = 2; j < n; j++)
	{
		if (n % j == 0)
		{
			return 0;//直接返回，程序直接结束
		}
}
	return 1;
}

int main()
{
	int a = 0;
	int b = 0;
	for (a = 100; a <= 200; a++)
	{
		if (is_prime(a))
            /*返回0就不打印，返回1就打印*/
		{
		printf("%d", a);
		}
	}
	return 0;
}

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

#include<stdio.h>

int is_leap_year(int b)
{
if ((b % 4 == 0 && b % 100 != 0) || b % 400 == 0)
		return 1;
	else
		return 0;
}

int main()
{
	int a = 0;
	for (a = 1000; a <= 2000; a++)
	{//判断
		if (is_leap_year(a))
		{
			printf("%d  ", a);
		}
		
	}
    return 0;
}

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

int binary_serach(int arr[], int k,int sz) 
{

	int left = 0;
	int right = sz -1;//最右边的下标是数组元素个数-1

	while (left <= right)
	{
		int mid = (left + right) / 2;
	
		if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;//找不到了
}


//如果找到了返回下标，找不到返回-1；
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 7;
	int sz = sizeof(arr) / sizeof(arr[0]);//可以计算数组元素个数

	int ret = binary_serach(arr,k,sz);
	//数组arr再传参的时候传递的是首元素的地址	--->接收的是指针，大小是4

	if (-1 == ret)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了\n");
		printf("下标是%d", ret);
	}
	return 0;
}

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

嵌套调用

#include <stdio.h>
void new_line()
{
 printf("hehe\n");
}
void three_line()
{
    int i = 0;
 for(i=0; i<3; i++)
   {
        new_line();//早这个函数中调用new_line函数
   }
}
int main()
{
 three_line();
 return 0;
}

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

链式访问

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

int main()
{
    printf("%d", printf("%d", printf("%d", 43)));
    //注：printf函数的返回值是打印在屏幕上字符的个数
    //所以结果是4321
    return 0;
}

函数递归

什么是递归？ 程序调用自身的编程技巧称为递归（ recursion）。
递归做为一种算法在程序设计语言中广泛应用。
一个过程或函数在其定义或说明中有直接或间接 调用自身的 一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，
递归策略 只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
递归的主要思考方式在于：把大事化小
递归的两个必要条件
存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件。

关于函数递归的练习

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

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

求n的阶乘

#include<stdio.h>
int func(int n)
{
    if (n == 1)
        return 1;
    else
        return n * func(n - 1);
}

int main()
{

    int n = 0;
    scanf("%d", &n);
    int ret = 0;
    ret  = func(n);
    printf("%d", ret);

    return 0;
}

递归实现strlen功能

#include<stdio.h>

int my_strlen(char *s)
{
    if (*s == '\0')
        return 0;
    else
        return 1 + my_strlen(s+1);
}
int main()
{
    char arr[] = "abcd";
    int len = 0;
    len = my_strlen(arr);
    printf("%d", len);

    return 0;
}

计算斐波那契数

#include<stdio.h>

int fib(int n)
{
    if (n <= 2)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}
int main()
{

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

else
return 1 + my_strlen(s+1);
}
int main()
{
char arr[] = “abcd”;
int len = 0;
len = my_strlen(arr);
printf("%d", len);

return 0;

}

计算斐波那契数

```c


#include<stdio.h>

int fib(int n)
{
    if (n <= 2)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}
int main()
{

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