1. 函数是什么？
在计算机程序中，子程序是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定任务，具备相对的独立性。
一般输入参数会有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
2. C语言中函数的分类：
- 库函数
- 自定义函数
2.1 库函数
完成在编程过程中的一些基础功能（如打印字符串、拷贝字符串等操作），不是业务性的代码。
C语言常用的库函数有：
- IO函数——输入输出函数 printf scanf putchar getchar
- 字符串操作函数 strcpy strlen
- 字符操作函数 toupper—小写转大写
- 内存操作函数 memcpy memcpm memset
- 时间/日期函数 time
- 数学函数 sqr pow
- 其他库函数
使用库函数，必须包含#include对应的头文件。
对于库函数来说，并不需要记住所有库函数，只需要学会查询的工具即可：
- MSDN (Microsoft Developer Network)
- www.cplusplus.com
- http://en.cppreference.com (英文版)
- http://zh.cppreference.com (中文版)
2.2 自定义函数
自定义函数和库函数一样，，有函数名，返回值类型和函数参数。
函数的组成：
//函数的基本结构
char* strcpy(arr1, arr2) //char*—返回值类型，strcpy—函数名，arr1 arr2—函数参数
{
语句项; //函数体
}例1：写一个函数，求两个整数中的最大值。
//写一个函数，求两个整数中的最大值。
#include <stdio.h>
int get_max(int x, int y)
{
return (x > y) ? x : y; //返回较大值
}
int main()
{
int a = 5;
int b = 19;
int max = get_max(a, b); //此时a→x，b→y只是传递数值，并不改变大小，因此不需要传地址
printf("max=%d\n", max);
return 0;
}例2：写一个函数，交换两个整型变量的内容。
//写一个函数，交换两个整型变量的内容。
#include <stdio.h>
void swap(int* px, int* py) //创建两个指针变量。只需交换数值，不需要返回用void
//函数内部和外部之间存在变量的改变，因此需要传地址
{
int c = 0;
c = *px;
*px = *py;
*py = c; //不需要返回值。因此不需要写return。return只能返回一个值，不能同时返回两个值
}
int main()
{
int a = 5;
int b = 19;
swap(&a, &b); //此时a→* px，b→* py不仅传递数值，还要改变大小，因此需要传地址
printf("a=%d b=%d\n", a, b);
return 0;
}3. 函数的参数和函数的调用
3.1 定义
- 实际参数（实参）：真实传给函数的参数。可以是常量、变量、表达式、函数等。无论实参是何种类型，在进行函数调用时，他们都必须有确定的值。
例：下述代码中的 a, b, &a, &b
确定的值—— 例：int max = get_max(2+5, get_max(4, 8));→int max = get_max(2+5, 8);
- 形式参数（形参）：指函数名后括号中的内容。只有在函数被调用的过程中才实例化（分配内存单元），当函数调用完成后就自动销毁，因此形式参数只在函数中有效。 当函数只是被定义但没被调用时，并没有开辟空间，只有在被调用的一瞬间才开辟空间。
例：下述代码中的 x, y, * px, * py
- 传值调用：函数的形参和实参分别占有不同的内存块，对形参的修改不会影响实参。例：Swap1。Swap1在被调用的时候，实参传给形参，其实形参是实参的一份临时拷贝。
- 传址调用：把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。这种方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。 例：Swap2。
//实参和形参、传值调用和传址调用
#include <stdio.h>
void Swap1(int x, int y)
{
int c = 0;
c = x;
x = y;
y = c;
}
void Swap2(int* px, int* py)
{
int c = 0;
c = *px;
*px = *py;
*py = c;
}
int main()
{
int a = 5;
int b = 19;
Swap1(a, b); //传值调用
printf("Swap1::a=%d b=%d\n", a, b);
Swap2(&a, &b); //传址调用
printf("Swap2::a=%d b=%d\n", a, b);
return 0;
} /*输出结果为：Swap1::a = 5 b = 19
Swap2::a = 19 b = 5*/3.2 练习
- 打印200-300之间的素数。
- 打印1000-2000年之间的闰年。
- 实现一个整形有序数组的二分查找。
- 写一个函数，每调用一次这个函数，就会将num的值增加1。
//1.打印200-300之间的素数
#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 i = 0;
int count = 0; //数一下一共有多少个素数
for (i = 200; i <= 300; i++)
{
if (is_prime(i) == 1)
{
count++;
printf("%d ", i);
}
}
printf("\ncount=%d\n", count);
return 0;
} /*输出结果为：211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293
count=16*/ //2.打印1000-2000年之间的闰年。
#include <stdio.h>
int is_leap_year(int x)
{
if (x % 4 == 0 && x % 100 != 0 || x % 400 == 0)
return 1;
else
return 0;
}
int main()
{
int i = 0;
int count = 0; //查一下有多少个
for (i = 1000; i <= 2000; i++)
{
if (is_leap_year(i) == 1)
{
count++;
printf("%d ", i);
}
}
printf("\ncount=%d\n", count);
return 0;
} //3.实现一个整形有序数组的二分查找。
#include <stdio.h>
int binary_search(int a[], int k, int s)
{
int left = 0;
int right = s - 1;
int mid = 0;
while (left <= right)
{
mid = (left + right) / 2; //更新中间位置,必须放在循环内部
if (a[mid] < k)
left = mid + 1;
else if (a[mid] > k)
right = mid - 1;
else
return mid; //找到目标值，返回其下标
}
return -1; //找不到了
}
int main()
{
int arr[] = {6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; // 已排序的数组
int key = 14; // 要查找的值
int sz = sizeof(arr) / sizeof(arr[0]); // 数组长度
int ret = binary_search(arr, key, sz); //找到返回值的下标 调用二分查找函数
if (ret != -1)
printf("找到啦，下标是：%d\n", ret);
else
printf("找不到\n");
return 0;
} //输出结果为：找到啦，下标是：8 //4.写一个函数，每调用一次这个函数，就会将num的值增加1。
#include <stdio.h>
void add(int* p)
{
(*p)++;
}
int main()
{
int num = 0;
add(&num);
add(&num);
add(&num);
add(&num);
add(&num);
printf("%d\n", num);
return 0;
} //输出结果为：5 因为调用了5次4. 函数的嵌套调用和链式访问
4.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;
} /*输出结果为：hehe
hehe
hehe*/4.2 链式访问
- 把一个函数的返回值作为另一个函数的参数。
//函数的链式访问
#include <stdio.h>
#include <string.h>
int main()
{
char arr[20] = "hello";
printf("%d\n", strlen(arr)); //strlen的值做了printf的参数
return 0;
} //输出结果为：5- printf函数的返回值是打印在屏幕上字符的个数
//函数的链式访问
//代码1
#include <stdio.h>
int main()
{
printf("%d\n", printf("%d\n", printf("%d\n", 54))); // //回车也是字符
return 0;
} /*输出结果为：54
3
2*/
//代码2
#include <stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 54)));
return 0;
} /*输出结果为：5421*/5. 函数的声明和定义
5.1 函数声明
- 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数声明决定不了。
- 一般出现在函数使用之前，要满足先声明后使用。
- 函数的声明一般放在头文件中，定义放在对应的源文件中。（名字最好一致）
5.2 函数定义
- 函数的定义是指函数的具体实现，交代函数的功能实现。
//函数的声明与定义
#include <stdio.h>
int main()
{
int a = 10;
int b = 30;
int add(int x, int y); //声明
int c = add(a, b);
printf("%d\n", c);
return 0;
}
int add(int x, int y) //定义
{
return x + y;
}6. 函数递归
6.1 什么是递归——函数自己调用自己
- 主要思考方式：将大事化小。
- 它通常把一个大型复杂的的问题层层转化为一个与原问题相似的规模较小的问题来求解。
- 只需要少量的程序就可描述出解题过程所需要的多次重复计算，大大减少了程序的代码量。
- 递归调用完从哪来回哪去。先一个个执行递归调用函数，全部执行完毕后再把没执行完的语句一层一层从里向外执行。
6.2 递归的两个必要条件——没有肯定错，都有不一定对
- 存在限制条件，当满足这个限制条件时，递归便不再继续。
- 每次递归调用之后越来越接近这个限制条件。
6.3 练习
练习1. 接收一个整形值（无符号），按照顺序打出它的每一位。 例：输入：25436，输出：2 5 4 3 6
递归思想：25436 % 10 = 6
25436 / 10 = 2543 % 10 = 3
2543 / 10 = 254 % 10 = 4
254 / 10 = 25 % 10 = 5
25 / 10 = 2 % 10 = 2
2 / 10 = 0 //已经拿完每一位了
//调用时是从上到下依次调用，全部调用完毕后，由下到上依次打印。
//1. 接收一个整形值（无符号），按照顺序打出它的每一位。 例：输入：25436，输出：2 5 4 3 6
#define _CRT_SECURE_NO_WARNINGS 1
#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("%u", &num); //%u打印的是是无符号整形
print(num); //自己定义的函数，可以打印参数部分的每一位
return 0;
} /*输出结果为：25436
2 5 4 3 6*/练习2. 编写函数不允许创建临时变量，求字符串的长度。（模拟实现一个strlen函数）
递归思想：my_strlen("hello");
1 + my_strlen("ello");
1 + 1 + my_strlen("llo");
1 + 1 + 1 + my_strlen("lo");
1 + 1 + 1 + 1 + my_strlen("o");
1 + 1 + 1 + 1 + 1 + my_strlen("");
1 + 1 + 1 + 1 + 1 + 0 = 5
//2. 编写函数不允许创建临时变量，求字符串的长度。（模拟实现一个strlen函数）
#include <stdio.h>
int my_strlen(char* str)
{
if (*str != '\0')
return 1 + my_strlen(str + 1);
else
return 0;
}
int main()
{
char arr[] = "hello";
printf("%d\n", my_strlen(arr)); //数组名实际上传递的是首元素的地址
return 0;
} //输出结果为：56.4 递归与迭代
- 循环是迭代的一种方式。
- 有些功能可用迭代方式实现，也可用递归方式实现。
- 如果一个代码功能实现的时候用递归求解非常简单，代码易理解，且没有明显的缺陷，用递归方法；如果求解过程中，写出来很简单但计算时有明显的缺陷，用非递归方法。
练习3. 求 n 的阶乘。（不考虑溢出） // 0 和 1 的阶乘都为 1。
递归思路：fac(i) = 1 i<=1
n*fac(i-1) i>1
//3. 求 n 的阶乘。（不考虑溢出）
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int fac(int n)
{
if (n <= 1)
return 1;
else
return n * fac(n - 1);
}
int main()
{
int i = 0;
scanf("%d", &i);
int ret = fac(i);
printf("%d\n", ret);
return 0;
} /*输出结果为：8
40320*/练习4. 求第 n 个斐波那契数。（不考虑溢出）
递归思路：fib (i) = 1 i<=2
fib(i-1) + fib(i-2) i>2
//4. 求第 n 个斐波那契数。（不考虑溢出）
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int count = 0; //计算某一步被计算了多少次
int fib(int n)
{
if (n == 4);
count++; //计算第3个斐波那契数被计算了多少次
if (n <= 2)
return 1;
else
return fib(n - 1) + fib(n - 2);
}
int main()
{
int i = 0;
scanf("%d", &i);
int ret = fib(i);
printf("%d\n", ret);
printf("count=%d\n", count);
return 0;
} /*输出结果为：7
13
count=25*/- 练习3和练习4 在计算较大的数（例：1000000！和 第50个斐波那契数）时，会进行大量重复的计算，效率非常低，此时会采用循环或非递归的方式来实现。
循环方式实现过程：
a = 7, c = 2, a = 1, b = 2;
a = 6, c = 3, a = 2, b = 3;
a = 5, c = 5, a = 3, b = 5;
a = 4, c = 8, a = 5, b = 8;
a = 3, c = 13, a = 8, b = 13;
a = 2 跳出程序，结果为13
//4. 求第 n 个斐波那契数。（不考虑溢出）——循环方法
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int fib(int n)
{
int a = 1;
int b = 1;
int c = 1; //因为 n=1 或 n=2 时直接返回1，所以c的初始化直接为1
while (n > 2)
{
c = a + b;
a = b;
b = c;
n--; // n不减即进入死循环，算第5个数时，循环执行3次
}
return c;
}
int main()
{
int i = 0;
scanf("%d", &i);
int ret = fib(i);
printf("%d\n", ret);
return 0;
} /*输出结果为：7
13*/
扫一扫
1269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
