做网站的怎么挣钱、科学新概念外链平台

目录

函数是什么

库函数

学习使用 strcpy 库函数

自定义函数

写一个函数能找出两个整数中的最大值 

写一个函数交换两个整型变量的内容

牛刀小试

写一个函数判断一个整数是否是素数

写一个函数判断某一年是否是闰年

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

函数的嵌套调用

函数的链式访问

一段有趣的代码

函数的声明、调用和定义

函数的定义

函数调用

函数声明 

函数递归 

什么是递归

递归的两个必要条件 

一个简单的递归

牛刀小试

要求使用函数递归实现：接受一个无符号整型值，按照顺序打印他的每一位

要求写一个函数：能实现求字符串的长度 

编写函数，不允许创建临时变量，求字符串的长度

---

函数是什么

在 C 语言里，函数和数学中的函数有相似之处

以数学函数 f(x)=2x+1 为例，当 x 取值不同时，函数会有不同的结果。比如 x=2 时，将 x=2 代入函数可得 f(2)=2×2+1=5；当 x=3 时，代入后得到 f(3)=2×3+1=7

同样，这个数学函数也能用 C 语言中的函数来表示。我们可以定义一个 C 语言函数，让它接收一个参数，在函数内部按照 2x+1 的规则进行计算并返回结果，从而实现与这个数学函数相同的功能

代码演示：

int f(int x)
{return 2*x + 1;
}int main()
{int x = 0;scanf("%d", &x);printf("%d\n", f(x));return 0;
}

---

库函数

在 C 语言里，为了方便使用常用功能，会将这些功能封装成一个个函数，这些函数被称为库函数，像 printf 函数、scanf 函数、strlen 函数等都属于库函数

需要注意的是，C 语言本身并没有直接实现这些库函数，而是制定了 C 语言的标准以及库函数的约定。比如对于 scanf 函数，C 语言标准规定了它的功能、函数名、参数和返回值等

而库函数的具体实现通常由编译器来完成，常见的编译器如 VS2022 编译器、gcc 编译器等，它们会依据 C 语言标准对库函数进行具体的编码实现，这样开发者就能在编程时直接使用这些库函数了

学习使用 strcpy 库函数

C/C++ 中的库函数信息，都可以在 cplusplus.com 网站 上查询到

如果想学习或了解某个库函数的用法、参数含义及功能，直接在这个网站搜索对应的函数名即可，它是编程中查阅库函数的实用资源

strcpy 库函数

“destination” 代表目的地字符串，“source” 代表源头字符串。当一个函数的返回值类型为 char* 时，意味着该函数返回的是目的地字符串的首地址

strcpy 是一个库函数，从其文档可知，它的功能是进行字符串拷贝。具体来说，就是把源头字符串的数据复制到目的地字符串，并且会覆盖目的地字符串原有的内容，同时还会将源头字符串末尾的结束符 '\0' 也一同复制过去

若要在代码中使用 strcpy 函数，需要包含相应的头文件，头文件代码如下：

#include<string.h>

代码演示：

char source[] =  "hello world";
char destination[] =  "xxxxxxxxxxxxxxxx";strcpy(destination, source);printf("%s\n", destination);

代码验证：

---

自定义函数

在编程中，自定义函数指的是开发者根据实际需求自己编写的函数。它和 C 语言中的库函数（如printf、strlen）一样，都遵循相同的基本结构，包括：

• 返回类型：函数执行完毕后输出的数据类型（如int、char*）；
• 参数：函数执行时需要的输入信息（可以没有参数，也可以有多个）；
• 返回值：通过return语句返回的结果（若无需返回结果，返回类型为void）

写一个函数能找出两个整数中的最大值 

代码演示： 

int get_max(int a, int b)
{return a > b ? a : b;
}int main()
{int a = 0;int b = 0;scanf("%d %d", &a, &b);int max = get_max(a, b);printf("%d\n", max);return 0;
}

写一个函数交换两个整型变量的内容

代码演示：

void Swap(int* a, int* b)
{int tmp = *a;*a = *b;*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;
}

在编写函数交换两个整型变量的值时，不能直接传递实参。这是因为在函数调用时，实参的值会被复制给形参，实参和形参分别占用不同的内存空间，也就是各自独立的空间。在函数内部对形参进行操作，只会改变形参的值，而不会影响到实参原本的值

为了真正实现交换两个实参的值，我们需要传递实参的地址。由于实参是 int 类型，所以函数的形参要使用 int* 类型来接收这些地址。int* 类型的变量可以存储整型变量的地址。在函数内部，通过 * 这个解引用关键字，我们可以根据存储的地址找到对应的实参，进而对实参的值进行修改，这样就能实现两个实参值的交换

---

牛刀小试

写一个函数判断一个整数是否是素数

代码演示：

int is_prime(int tmp)
{if (tmp <= 1)return 0;for (int i = 2; i <= sqrt(tmp); i++){if (tmp % i == 0)return 0;}return 1;
}int main()
{int input = 0;scanf("%d", &input);if (is_prime(input))printf("is prime\n");elseprintf("not is prime\n");return 0;
}

代码解析：

我们要编写一个函数来判断一个整数是否为素数。素数是指大于 1 且只能被 1 和自身整除的正整数。所以在判断之前，首先要排除小于等于 0 的整数，因为它们显然不符合素数的定义

该函数的返回规则是：返回 0 表示这个数不是素数，返回 1 表示这个数是素数

对于输入的变量 input，我们需要判断它是否为素数。判断的方法是，用 input 对 2 到 input - 1 之间的数进行取模运算。可以使用 for 循环来遍历这个区间内的所有数。如果在遍历过程中，input 对某个数取模的结果为 0，那就说明 input 除了 1 和它本身之外，还能被其他数整除，那么它就不是素数，此时函数直接返回 0

不过，其实并不需要从 2 遍历到 input - 1，只需要遍历 2 到 sqrt(input)（sqrt 是开平方函数）之间的数即可。这是因为如果一个数 input 不是素数，那么它一定可以分解为两个因数 m 和 n，即 input = m * n，其中 m 和 n 中至少有一个小于等于 sqrt(input)。所以，只要检查到 sqrt(input) 就可以判断 input 是否为素数了

如果 for 循环执行完毕都没有找到能整除 input 的数，那就说明 input 只能被 1 和它本身整除，即 input 是素数，此时函数返回 1

写一个函数判断某一年是否是闰年

代码演示：

int is_leap_year(int year)
{if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))return 1;elsereturn 0;
}int main()
{ int year = 0;scanf("%d", &year);is_leap_year(year);if (is_leap_year(year))printf("is leap year\n");elseprintf("not is leap year\n");return 0;
}

代码解析：

闰年的判断规则是能被 4 整除但不能被 100 整除，或能被 400 整除的年份

根据以上的规则编写出对应的逻辑代码，就能判断某一年是否是润年

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

代码演示：

int binary_search(int* parr, int size, int number)
{int left = 0;int right = size - 1;while (left <= right){int mid = (left + right) / 2;if (parr[mid] < number){left = mid + 1;}else if(parr[mid] > number){right = mid - 1;}else{return mid;}}return -1;
}int main()
{int arr[] = { 1,2,4,6,7,9,12,32,45,77,90 };int size = sizeof(arr) / sizeof(arr[0]);int input = 0;scanf("%d", &input);int ret = binary_search(arr, size, input);if (ret == -1)printf("number not found\n");elseprintf("number index is: %d\n", ret);return 0;
}

代码解析：

我们要实现一个二分查找函数，二分查找是一种高效的查找算法，它的前提是数组必须是有序的。在函数调用时，需要传递三个参数：数组的指针 arr，用于访问数组元素；数组的元素个数 size，这样能确定查找范围；要查找的整数 input，即我们要在数组中找到的目标值

函数的返回值规则是：如果在数组中找到了目标值 input，就返回该值在数组中的下标；如果没有找到，就返回 -1，因为数组的下标最小是从 0 开始的， -1 可以作为一个明确的未找到的标识

1. 初始化查找范围：定义两个变量，left 作为左下标，初始值设为 0，它指向数组的起始位置；right 作为右下标，初始值设为 size - 1，它指向数组的末尾位置
2. 开始循环查找：使用 while 循环来进行查找，循环的条件是 left <= right。只要满足这个条件，就说明还有元素没有被检查过，查找过程可以继续
3. 计算中间下标：在每次循环内部，计算中间元素的下标 mid，计算公式为 mid = (left + right) / 2。通过这个中间下标，我们可以将数组分成两部分
4. 比较中间元素与目标值：
   • 如果 input 大于中间元素 arr[mid]，说明目标值在数组的右半部分，此时更新 left 为 mid + 1，缩小查找范围到右半部分
   • 如果 input 小于中间元素 arr[mid]，说明目标值在数组的左半部分，此时更新 right 为 mid - 1，缩小查找范围到左半部分
   • 如果 input 等于中间元素 arr[mid]，说明已经找到了目标值，直接返回 mid，也就是目标值在数组中的下标
5. 未找到目标值：如果 while 循环结束后还没有找到目标值，说明目标值不在数组中，此时返回 -1 即可

---

函数的嵌套调用

在编程中，当我们定义了多个函数后，有时会需要在一个函数的执行过程中，调用另一个函数来完成特定任务。这种 在一个函数内部调用另一个函数的方式，就是函数的嵌套调用

代码演示：

void print()
{printf("hello world\n");
}void three_print()
{for (int i = 0; i < 3; i++){print();}
}int main()
{three_print();return 0;
}

在 three_print 函数中调用了 print 函数，这就是函数的嵌套调用 

---

函数的链式访问

函数的链式访问是一种编程技巧，它指的是将一个函数的返回值直接作为另一个函数的参数来使用

代码演示：

printf("%d\n", strlen("abcdef"));

把 strlen 函数的返回值作为 printf 函数的参数，这就是函数的链式访问 

函数的链式访问可以让代码更加简洁和紧凑，避免创建中间变量。不过，在使用链式访问时也要注意代码的可读性，如果链式访问的函数过多，可能会让代码变得难以理解和调试。所以，在实际编程中要根据具体情况合理使用函数的链式访问 

一段有趣的代码

代码演示：

printf("%d", printf("%d", printf("%d", 43)));

问：最后在控制台上输出的结果是多少？

需明确 printf 函数的返回值为其输出的字符个数：

如：printf("%d", 1); 的返回值就是 1，printf("%d", 123); 的返回值就是 3

具体执行过程如下：

1. 执行最内层 printf("%d", 43)，会先在控制台输出 43（共 2 个字符），返回值为 2
2. 中间层 printf("%d", 2) 接收内层返回值，输出 2（1 个字符），返回值为 1
3. 最外层 printf("%d", 1) 接收中间层返回值，输出 1（1 个字符）

综上，控制台输出结果为 4321

代码验证：

---

函数的声明、调用和定义

函数的定义

int Add(int a, int b)
{return a + b;
}

函数 Add 的功能为计算两个整数的和，其定义是实现该功能的具体代码逻辑，即通过设定参数接收两个整数输入，在函数体内执行加法运算，并将运算结果作为返回值输出，从而完成两个整数相加功能的程序实现

函数调用

int main()
{int a = 0;int b = 0;scanf("%d %d", &a, &b);int sum = Add(a, b);printf("%d\n", sum);return 0;
}

在 main 函数里使用 Add 函数的操作，在编程中被称作函数调用，此操作可触发 Add 函数执行其预设功能

函数声明 

// 函数声明
int Add(int a, int b);int main()
{int a = 0;int b = 0;scanf("%d %d", &a, &b);// 函数调用int sum = Add(a, b);printf("%d\n", sum);return 0;
}// 函数定义
int Add(int a, int b)
{return a + b;
}

在 C 程序设计中，若自定义函数的定义位于 main 函数之后，则需在 main 函数执行前进行函数声明

这是由于程序遵循从上至下的执行逻辑，编译器在处理 main 函数时若未预先知晓自定义函数的存在，会因无法识别函数名称而报错

按照模块化编程规范，函数声明通常被放置在头文件（.h）中，用于告知编译器函数的参数类型和返回值类型；而函数的具体实现（定义）则集中存储在对应的源文件（.c）中，这种分离式设计有助于代码的组织、维护及复用，确保程序在编译阶段能够正确解析函数调用关系

---

函数递归 

什么是递归

递归是函数直接或间接调用自身的编程方式。需定义基线条件（终止递归的条件）和递归条件（逐步逼近基线的逻辑），通过重复调用解决可分解为相似子问题的任务

递归的核心思维在于：把大事化小

递归的两个必要条件 

1. 基线条件（终止条件）：必须存在至少一个无需递归调用的终止条件，用于退出递归过程，避免无限循环；
2. 递归条件：函数需通过自身调用逐步分解问题，且每次递归调用必须更接近基线条件，确保问题规模递减直至满足终止条件

一个简单的递归

int main()
{printf("hello\n");main();return 0;
}

若 main 函数直接调用自身，构成直接递归。由于该递归未设置基线条件（终止条件），程序会无限次递归调用自身，导致调用栈不断增长

当栈空间被耗尽时，将引发栈溢出错误，造成程序异常终止。这一现象体现了递归中终止条件的必要性 —— 缺少该条件会破坏递归的收敛性，最终导致内存资源耗尽

牛刀小试

要求使用函数递归实现：接受一个无符号整型值，按照顺序打印他的每一位

例如：

输入：1234 ；输入：1 2 3 4 

代码演示：

void print_every_one(int n)
{if (n > 9){print_every_one(n / 10);}printf("%d ", n % 10);
}

代码解析：

该函数实现按顺序打印无符号整数每一位的功能，核心通过数学运算 %10（取个位）和 /10（去除个位）分解数字，并结合递归逐层处理

算法思路：

数字分解原理：

1. 对于任意整数 n，n % 10 可获取其个位数字（如 123 % 10 = 3）
2. n / 10 可去除个位，得到高位数字（如 123 / 10 = 12）

通过重复这两步，可逐位拆解整数的每一位

递归过程分析（以 n = 123 为例）：

首次调用与递归展开

• 初始调用 print_every_one(123)，因 123 > 9，触发递归调用 print_every_one(123 / 10 = 12)
• 第二次调用 print_every_one(12)，因 12 > 9，继续递归调用 print_every_one(12 / 10 = 1)

基线条件触发（递归终止）

• 第三次调用 print_every_one(1)，此时 1 <= 9，不满足递归条件，跳过 if 语句，直接执行 printf("%d ", 1 % 10)，输出 1

逐层返回与后续打印

• 返回上一层（第二次调用，n = 12），执行 printf("%d ", 12 % 10)，输出 2
• 再返回初始层（首次调用，n = 123），执行 printf("%d ", 123 % 10)，输出 3

最终输出结果

控制台按递归返回顺序打印 1 2 3，实现从高位到低位的顺序输出

核心逻辑总结：

• 递归特性：通过不断将问题规模缩小（n / 10），直至满足基线条件（n <= 9）时终止递归，再逐层返回处理当前层的打印逻辑
• 执行顺序：递归调用时先处理高位（通过不断剥离个位），返回时再依次打印低位，利用调用栈的后进先出特性，自然实现从高位到低位的顺序输出

要求写一个函数：能实现求字符串的长度 

代码演示：

int my_strlen(const char* s)
{int count = 0;while (*s != '\0'){count++;s++;}return count;
}

代码解析：

此函数 my_strlen 用于计算字符串的长度。参数 s 是一个指向字符串首字符的指针

在 C 语言里，字符串以 '\0' 作为结束标志。函数利用 while 循环来遍历字符串，只要当前指针 s 所指向的字符不是 '\0'，就表明还有字符需要统计

在循环内部，count 变量用于统计字符串中字符的数量，每统计一个字符，count 的值就加 1。同时，指针 s 通过 s++ 操作指向下一个字符，从而实现对字符串的逐字符遍历

当 s 指向 '\0' 时，意味着已经遍历完整个字符串，此时循环结束，count 变量中存储的数值就是字符串中字符的总个数，也就是该字符串的长度，最后将其作为函数的返回值返回

编写函数，不允许创建临时变量，求字符串的长度

代码演示：

int my_strlen(const char* s)
{if (*s == '\0')return 0;return 1 + my_strlen(s+1);
}

代码解析：

函数参数与返回值

该函数接受一个指向 const char 类型的指针 s 作为参数，const 表明此指针指向的字符串内容不能被修改。函数返回一个 int 类型的值，即字符串的长度

递归终止条件

在函数内部，首先会检查指针 s 所指向的字符是否为 '\0'。在 C 语言中，字符串以 '\0' 作为结束标志。如果当前字符是 '\0'，则意味着已经到达字符串的末尾，此时函数将返回 0。这是递归的终止条件，它确保了递归调用不会无限进行下去，避免出现栈溢出的错误

递归调用逻辑

若当前字符不是 '\0'，说明还未遍历完整个字符串。函数会将指针 s 向后移动一位（s + 1），使其指向下一个字符，然后再次调用 my_strlen 函数，以计算从下一个字符开始的子字符串的长度。由于当前字符也是字符串的一部分，所以在递归调用返回的结果上加 1，表示当前字符的长度。最终将这个累加后的结果作为当前字符串的长度返回

递归调用示例

假设传入的字符串为 "abc"，递归调用过程如下：

• 第一次调用 my_strlen("abc")，当前字符为 'a'，不是 '\0'，则进行递归调用 1 + my_strlen("bc")
• 第二次调用 my_strlen("bc")，当前字符为 'b'，不是 '\0'，继续递归调用 1 + my_strlen("c")
• 第三次调用 my_strlen("c")，当前字符为 'c'，不是 '\0'，再次递归调用 1 + my_strlen("")
• 第四次调用 my_strlen("")，此时当前字符为 '\0'，满足终止条件，返回 0
• 返回到第三次调用，my_strlen("c") 返回 1 + 0 = 1
• 返回到第二次调用，my_strlen("bc") 返回 1 + 1 = 2
• 返回到第一次调用，my_strlen("abc") 返回 1 + 2 = 3

通过这种递归的方式，函数逐步缩小问题规模，直到满足终止条件，最终计算出整个字符串的长度