函数
1.库函数
例如：memset
1 #include <stdio.h>
2 #include <string.h>//含memset
3 int main()
4 {
5
6 char ch[20] = "abcs321";
7 int len = strlen(ch);//读取ch长度（不包含\n）
8 memset(ch, '1', len);//把全部len长度的字符全部替换为1
9 printf("%s\n", ch);
10 return 0;
11 }
2. 自定义函数
定义函数要写函数输入和返回类型，如 int get_max(int x, int y) 表示输入的是整型x, y，返回整型；void swap(int a, int b) 表示输入整型 a, b，不返回任何值。
当变量跳转到其他函数时，如void swap(int a, int b), 此处ab进入swap函数后，地址会改变，必须把地址传给函数才不会变地址，如下面
1 #include <stdio.h>
2 void swap(int* pa, int* pb)
3 {
4 int z = *pa;
5 *pa = *pb;
6 *pb = z;
7 }
8 int main()
9 {
10 int a = 10;
11 int b = 20;
12 printf("a = %d b = %d\n", a, b);
13 swap(&a, &b);
14 printf("a = %d b = %d\n", a, b);
15 return 0;
16 }
形参是指如 ，此处a为变量。
实参指如 get_max = (a, int get_max = (3, 7))，a和(3, 7)
1 //调用的时候，实参传给形参，其实形参是实参的一份临时拷贝，改变形参，不能改变实参。
2 void Swap1(int x, int y)//调用的形参，生命周期=局部变量
3 {
4 int tmp = 0;
5 tmp = x;
6 x = y;
7 y = tmp;
8 }
9
10 void Swap2(int* px, int* py)//调用的形参
11 {
12 int tmp = 0;
13 tmp = *px;
14 *px = *py;
15 *py = tmp;
16 }
17
18 int main()
19 {
20 int num1 = 1;
21 int num2 = 2;
22 Swap1(num1, num2);//传值调用，括号里为实参
23 printf("Swap1::num1 = %d num2 = %d\n", num1, num2);
24 Swap2(&num1, &num2);//传址调用
25 printf("Swap2::num1 = %d num2 = %d\n", num1, num2);
26 return 0;
27 }
例题：写函数来判断闰年：
1 int is_leap_year(int y)
2 {
3 return((y % 100 != 0 && y % 4 == 0) || (y % 400 == 0));//简洁
4 }
5
6 int main()
7 {
8 int y = 0;
9 for (y = 1000; y <= 2000; y++)
10 {
11 if (is_leap_year(y) == 1)
12 printf("%d ",y);
13 }
14 return 0;
15 }
-----------------------
当需要求数组长度时，需要先计算好长度再输入函数，如 int sz = sizeof(a) / sizeof(a[0]); 在函数内部传入的是数组首地址，sizeof(a)计算的是指针的大小=4
函数的嵌套使用：
函数不能嵌套定义，但能嵌套调用
1 #include <stdio.h>
2 void new_line()//函数的嵌套调用
3 {
4 printf("hehe\n");
5 }
6 void three_line()
7 {
8 int i = 0;
9 for (i = 0; i < 3; i++)
10 {
11 new_line();
12 }
13 }
14 int main()
15 {
16 three_line();
17 return 0;
18 }
函数的链式访问：
1 #include <stdio.h>
2 int main()
3 {
4 printf("%d", printf("%d", printf("%d", 43)));//注：printf函数的返回值是打印在屏幕上字符的个数
5 return 0;
6 }
函数声明：
1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数
声明决定不了。
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中的。
函数定义：
函数的定义是指函数的具体实现，交待函数的功能实现。
test.h的内容：放置函数的声明
1 int Add(int x, int y);//函数的声明
test.c的内容：放置函数的实现
1 int Add(int x, int y)
2 {
3 return x+y;
4 }
函数的递归
程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的
一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的主要思考方式在于：把大事化小。
递归必要条件：
1.存在限制条件，当满足这个限制条件的时候，递归便不再继续。
2.每次递归调用之后越来越接近这个限制条件。
如将1234打印为1 2 3 4
1 #include <stdio.h>
2 void print(int n)
3 {
4 if (n > 9)
5 {
6 print(n / 10);
7 }
8 printf("%d ", n % 10);
9 }
10
11 int main()
12 {
13 int num = 1234;
14 print(num);
15 return 0;
16 }
思路：
--------------------------------------------------------------------------------
栈溢出（stack flow）：内存的栈区被局部变量占满。故：
1.不能死递归，都有跳出条件，每次递归逼近跳出条件
2.递归层次不能太深，否则会栈溢出
------------------------------
练习：
编写函数不允许创建临时变量，求字符串的长度。
1 #include <stdio.h>
2 int my_strlen(const char* str)
3 {
4 if (*str == '\0')
5 return 0;
6 else
7 return 1 + my_strlen(str + 1);
8 }
9 int main()
10 {
11 char* p = "abcdef";
12 int len = my_strlen(p);
13 printf("%d\n", len);
14 return 0;
阶乘：
1 #define _CRT_SECURE_NO_WARNINGS
2 #include <stdio.h>
3 int fac(int f)
4 {
5 if (f > 1)
6 return f * fac(f - 1);
7 else
8 return 1;
9 }
10 int main()
11 {
12 int n = 0;
13 scanf("%d", &n);
14 printf("%d\n", fac(n));
15 return 0;
16 }
斐波那契数列：1 1 2 3 5 8 13 21 34 55 ...
1 #define _CRT_SECURE_NO_WARNINGS
2 #include <stdio.h>
3 int fi(int n)
4 {
5 if (n <=2 )
6 return 1;
7 else
8 return (fi(n-1)+fi(n-2));
9 }
10
11 int main()
12 {
13 int n = 0;
14 scanf("%d", &n);
15 printf("%d\n", fi(n));
16 return 0;
17 }
此方法（递归）效率低下。用循环更高效：
1 #define _CRT_SECURE_NO_WARNINGS
2 #include <stdio.h>
3 int fib(int n)
4 {
5 int a = 1;
6 int b = 1;
7 int c = 1;
8 while (n>2)
9 {
10 c = a + b;
11 a = b;
12 b = c;
13 n--;
14 }
15 return c;
16 }
17
18 int main()
19 {
20 int n = 0;
21 scanf("%d", &n);
22 printf("%d\n", fib(n));
23 return 0;
24 }
课后习题：
打印1~100中含有多少个9
1 #include <stdio.h>
2 int main()
3 {
4 int n = 0;
5 int count = 0;
6 for (n = 1; n <= 100; n++)
7 {
8 if (n / 10 == 9)
9 count++;
10 if (n % 10 == 9)
11 count++;
12 }
13 printf("%d\n", count);
14 return 0;
15 }
打印10个数中的最大数字：
1 #include <stdio.h>
2 #include <string.h>
3
4 int main()
5 {
6 int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
7 int max = arr[0];
8 int l = sizeof(arr)/sizeof(arr[0]);
9 for (int i = 0; i < l; i++)
10 {
11 if (arr[i] > max)
12 {
13 max = arr[i];
14 }
15 }
16 printf("%d\n", max);
17 return 0;
18 }
（a,b）是逗号表达式，其值为最右表达式的值
将一个字符串倒序：
方法1：
1 #include <stdio.h>
2 #include <string.h>
3 void reverse_string(char* str)
4 {
5 char temp = 0;
6 int left = 0;
7 int right = strlen(str)-1;
8 while (left < right)
9 {
10 temp = str[left];
11 str[left] = str[right];
12 str[right] = temp;
13 left++;
14 right--;
15 }
16 }
17
18 int main()
19 {
20 char arr[]="abcdef";
21 reverse_string(arr);
22 printf("%s\n",arr);
23 return 0;
24 }
方法2：（递归）
1 #include <stdio.h>
2 #include <string.h>
3 void reverse_string(char* str)
4 {
5 char temp = *str;
6 int len = strlen(str);
7 *str = (*str + len - 1);
8 *(str + len - 1) = '\0';
9 if (strlen(str + 1) >= 2)
10 {
11 reverse_string(str + 1);
12 }
13 *(str + len - 1) = temp;
14
15 }
16
17 int main()
18 {
19 char arr[]="abcdef";
20 reverse_string(arr);
21 printf("%s\n",arr);
22 return 0;
23 }
标签：2308,return,函数,int,str,printf,include From： https://www.cnblogs.com/scut4787749233/p/17625323.html