一：函数是什么？
（1）：是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。
（2）：一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
二：C语言中函数的分类
1：库函数:C语言内部提供的函数。(使用库函数必须包含#include对应的头文件)
（1）：库函数存在的意义：
为了提高我们的工作的效率,
（2）：库函数的学习与使用
我们可以通过 ( www.cplusplus.com , cppreference.com)等网址来查找函数名、返回值类型，函数参数，头文件类型等信息。
如：
(1)strcpy:
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[]="Sample string";
char str2[40];
char str3[40];
strcpy (str2,str1);
strcpy (str3,"copy successful");
printf ("str1: %s\nstr2: %s\nstr3: %s\n",str1,str2,str3);
return 0;
}str1: Sample string str2: Sample string str3: copy successful
strcpy的用法：strcpy函数会把源头source的数据拷贝到目的地空间里面以后，会把目的地空间的起始地址给返回回来。
#include<stdio.h>
#include<string>
int main()
{
char arr1[] = "qwe";
char arr2[] = "#######"；//qwe\0######
strcpy(arr2,arr1);
printf("%s\n",arr2);
return 0;
}qwe
(2)memset:
#include <stdio.h>
#include <string.h>
int main ()
{
char str[] = "almost every programmer should know memset!";
memset (str,'-',6);
printf("%s\n",str);
return 0;
}
------ every programmer should know memset!
由此我们可以知道字符串中前num个字符将被中间赋予的值所覆盖
*****2：自定义函数:自我设置的函数，和库函数一样都有函数名、返回值类型、函数参数等
（1）：自定义函数的组成
（2）：例题
1：用函数找出两个整数的最大值
#include<stdio.h>
int get_max(int x, int y)
{
if (x > y)
{
return x;
}
else
{
return y;
}
}
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;
}输入：3 7
输出：7
2 ：用函数交换两个整型变量的内容
错误：
#include<stdio.h>
void Swap(int a, int b)//void表示无返回值
{
int tmp = 0;//创建临时变量tmo
tmp = a;//将a值赋给tmp
a = b;//将b值赋给a
b = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前：a=%d，b=%d\n", a, b);
Swap(a, b);
printf("交换后：a=%d，b=%d\n", a, b);
return 0;
}若输入34 56
交换前：a=34,b=56
交换后：a=34,b=56
明显没有发生交换，是错误的。
正确示：
#include<stdio.h>
void Swap(int* pa, int* pb)//
{
int tmp = 0;
tmp = *pa;
*pa = *pb;
*pb = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前：a=%d，b=%d\n", a, b);
Swap(&a, &b);
printf("交换后：a=%d，b=%d\n", a, b);
return 0;
}若输入10 20
交换前：a=10，b=20
交换后：a=20，b=10
注意：<形参无法影响实参，要通过指针变量才行>
3.打印九九乘法表
#include <stdio.h>
void print_table(int n)
{
int i = 0;//行
for(i=1;i<+n;i++)
{
int j = 0;
for(j=1;j<=i;j++)
{
printf("%d*%d=%d", i, j, i*j);
}
printf("\n");
}
}
int main ()
{
int n = 0;
scanf("%d",&n);
print_table(n);
return 0;
}三：函数中的参数
1：实际参数（在主函数中的函数的参数）
真实传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。
无论函数是那种类型的两，在调用函数时，它们都必须有确定的值，以便把这些值传送给形参。（若是函数参量则必须先能求出一个值，如get_max(3, 7)）
2：形式参数 （非实参的 ）
形式参数是指函数名后括号中的变量。形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。因此形式参数只在函数中才有效。
当函数调用的时候,实参传给形参，形参将是实参的一份临时拷贝，所以形参的修改，不影响实参。（可用后面传值调用理解）
四：函数的调用
函数被使用时的方法分为：
*** 1：传值调用：函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
我们拿上面的交换数值举例：
#include<stdio.h>
void Swap(int x, int y)//void表示无返回值
{
int tmp = 0;//创建临时变量tmo
tmp = x;//将x值赋给tmp
x = y;//将y值赋给x
y = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前：a=%d，b=%d\n", a, b);
Swap(a, b);
printf("交换后：a=%d，b=%d\n", a, b);
return 0;
}》》》由传值调用知识点可知，当我们输入a,b值后，进行到Swap函数将ab 传值给x,y,在经过变换后出函数体被销毁，而ab打印后未发生交换
***** 2：传址调用：把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
当这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。
《需要改变实参时，用传址调用，反之用传值调用》
#include<stdio.h>
void Swap(int* pa, int* pb)//定义指针变量
{
int tmp = 0;
tmp = *pa;
*pa = *pb;
*pb = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前：a=%d，b=%d\n", a, b);
Swap(&a, &b);
printf("交换后：a=%d，b=%d\n", a, b);
return 0;
}由于通过址调用，所以在跳出Swap后，仅销毁指针变量，而实参已经发生改变，达到交换数值的目的。
3：练习
（1）：写一个函数可以判断一个数是不是素数
#include<stdio.h>
#include<math.h>
int is_primer(int n)
{
int j = 0;
for (j=2;j<n;j++)
{
if(n%j == 0)
return 0；
/* else
return 1;
是不能再加上这个的，我们需要的事是从2到n-1均判断。如当n等于9时就出错了
*/
{
return 1;
}
int main()
{
//打印100~200之间的素数
int i = 0;
for (i = 100; i <= 200; i++)
{
//判断i是否为素数
if (is_primer(i) == 1)
{
printf("%d ", i);
}
}
return 0;
}（2）：写一个函数判断一年是不是闰年
int is_leap_year(int y)
{
if (((y%4==0)&&(y%100!=0)) || (y%400==0))
return 1;
else
return 0;
}
int main()
{
int year = 0;
int count = 0;
for (year=1000; year<=2000; year++)
{
//判断y是不是闰年
if (is_leap_year(year) == 1)//leap year就是闰年
{
count++;
printf("%d ", year);
}
}
printf("\ncount = %d\n", count);
return 0；
}（3）：写一个整形有序数组的二分查找
#include<stdio.h>
int binary_search(int arr[], int a, int sz)//形参为数组、需要查找的整数、数组的元素个数
//本质上arr是一个指针,所以是4个字节
{
int left = 0;
int right = sz-1;
int mid = 0;
while (left<=right)
{
int mid = (right＋left)/2;//找中间的元素
if (arr[mid] > a)//中间元素大于查找值，说明在左边
{
right = mid - 1;
}
else if (arr[mid] < a)//中间元素小于查找值，说明在右边
{
left = mid + 1;
}
else
{
return mid;//中间值等于查找值
}
}
if (left>right)
{
return -1;//找不到，返回-1
}
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10};
//只能在主函数里面定义sz变量,sizeof(arr)在主函数里使用不需要传递地址
int sz = sizeof(arr) / sizeof(arr[0]);//元素的个数
int k = 7;
scanf("%d", &k);
int ret = binary_search(arr, k, sz);//再多加一个sz变量,传到形参上去
if (-1 == ret)
{
printf("找不到\n");
}
else
{
printf("找到了，下标是:%d\n", ret);
}
return 0;
}（4）：写一个函数，每调用一次这个函数，就会将 num 的值增加1
#include<stdio.h>
void Add(int* p)
{
(*p)++;//解引用找到变量再加1，注意这个括号不能忘
}
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;
}五：函数的嵌套调用和链式访问
函数和函数之间是可以有机的组合的
1.嵌套调用
函数可以根据需要进行相互调用。
#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;
}注：函数不能嵌套定义，但可以嵌套调用
2.链式访问
（1）把一个函数的返回值作为另一个函数的参数。
#include<stdio.h>
#include<string.h>
int main()
{
//int len = strlen("abcdef");
//1
//printf("%d\n", len);
//2
printf("%d\n", strlen("abcdef"));//链式访问,把strlen("abcdef")的值作为printf函数的参数
return 0;
}（2）
#include<stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
return 0;
}结果：4321
对printf函数的调用，打印的是双引号中或后的参数 或者 是某函数的返回值
可知printf的返回值是打印的字符的个数
第一次调用打印43，第二次打印第一次的返回值即2，第三次打印第二次的返回值即1，所以结果是4321.
六：函数的声明和定义
（1）：函数的声明（函数叫什么，参数是什么，返回类型是什么）
如：
int Add(int x,int y)注意：1.函数的声明一般出现在函数的使用之前。要满足先声明后使用。
2.但是具体是不是存在，函数声明决定不了
3.函数的声明一般要放在头文件(.h文件中)中的。
（2）：函数的定义（指函数的具体实现，交待函数的功能实现）
注意：1.函数不能嵌套定义
2.函数的定义一般放在源文件（.c文件中）中
（进行自定义函数的头文件的引用时应使用双引号“”而不用<>）
注意：当一个功能复杂时就可以用这种分模块编写的方式，一般情况将其写到一个源文件中即可。
七：函数的递归
1：什么是递归
递归也就是程序函数自己调用自己,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归的主要思考方式在于：把大事化小
举例：
#include<stdio.h>
int main()
{
printf("hehe\n");
main();
return 0;
}结果会一直死循环的打印hehe，最后会因为 栈溢出（Stack overflow） 而挂了
每一次函数的调用都会在栈区申请内存空间，而上面代码递归无限次申请，最终导致栈溢出.
内存一般划分为 栈区：局部变量，函数参数
堆区：动态开辟的内存（malloc,calloc）
静态区：全局变量，static修饰的变量
2：递归的两个必要条件
（1） 存在限制条件，当满足这个限制条件的时候，递归便不再继续,防止栈溢出。
（2）每次递归调用之后越来越接近这个限制条件。
1.接受一个整型值（无符号），按照顺序打印它的每一位
#include<stdio.h>
void print(unsigned int n)
{
if (n>9)//至少两位数
{
print(n/10);//满足递归的两个必要条件.再次调用print函数
}
printf("%d", n%10);
}
int main()
{
unsigned int num = 0;
//无符号整型用%u
scanf("%u", &num);//1234
print(num);//按照顺序打印num的每一位
return 0;
}2.求字符串长度
/1普通方法
#include<stdio.h>
#include<string.h>
int my_strlen(char* str)//str里面存的是第一个字符的地址
{
int count = 0;
while(*str != '\0') //*str是解引用操作，获得第一个字符
{
count++;
str++;
}
return count;
}
int main()
{
char arr[] = "bit";
int len = my_strlen(arr);
printf("len = %d\n",len);
return 0;
}
//2递归方法，不创建临时变量
#include<stdio.h>
#include<string.h>
int my_strlen(char* str)//str里面存的是第一个字符的地址
{
if(*str != '\0')
return 1+my_strlen(str+1);
else
return 0;
}
int main()
{
char arr[] = "bit";
int len = my_strlen(arr);
printf("len = %d\n",len);
return 0;
}3：函数的递归与迭代(迭代就是重复，与循环差不多)
递归中我们调用函数，它的优点是所需代码量少，简洁。但缺点是大量重复的计算会减缓了程序的运行速度
当我们使用迭代时，循环不需要大量调用函数，这个程序的运行速度会加快不少，只是这个程序的代码量会大很多。
（1）求第n个斐波那契数
斐波那契数列（1 1 2 3 5 8 13 21 34 55 ....）：后一位数值等于前两个值之和
//方法一:递归法
#include<stdio.h>
int Fib(int n)
{
/* if (n == k)//算第k个斐波那契数被计算了多少次
{
count++;
}*/
if (n<=2)
return 1;
else
return Fib(n - 1) + Fib(n - 2);
}
//int count = 0;
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fib(n);//定义一个ret来接受上面函数的返回值
printf("%d", ret);
//printf("count=%d\n", count);
return 0;
}
//方法二:迭代
#include<stdio.h>
int Fib(int n)
{
int a = 1;
int b = 1;//前两个数都是1
int c = 1;//不能使c=0,当n小于2时会输出0
while (n>2)
{
c = a + b;
a = b;
b = c;
n--;//这一步别忘了
}
return c;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fac(n);
printf("%d", ret);
return 0;
}注意：当我们使用递归的方法时，如果n大时，由于大量的函数调用使得非常容易栈溢出
（2）求n的阶乘：
//非递归法：
int Fac1(int n)
{
int i = 0;
int ret1 = 1;//阶乘初始化必然为1
for (i=1; i<=n; i++)
{
ret *= i;
}
return ret1;
}
//递归法：
int Fac2(int n)
{
if(n<=1)
return 1;
else
return n*Fac*(n-1)
}
int main()
{
int n = 0;
int ret1 = 0;
scanf("%d", &n);
int ret = Fac(n);//定义一个ret来接受上面函数的返回值
printf("%d", ret1);
return 0;
}提示：
1.许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
2.但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3.当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。
扫一扫
2475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
