新手c语言讲解及题目分享（十四）--函数专项练习（二）
新手c语言讲解及题目分享（十四）--函数专项练习（一）-CSDN博客
目录
前言
一.函数调用中的参数传递
1．普通变量作为函数的参数
2．数组元素作为参数
3．数组名作为函数的参数
4．指针变量作为函数的参数
二.函数的嵌套调用
三.函数的递归调用
四.函 数 与 宏
1．不带参数的宏定义
2．带参数的宏定义
五.函数指针与返回指针的函数
1.指向函数的指针变量定义的一般形式
2.用指向函数的指针变量调用函数
Ⅰ.利用指针进行函数的选择调用
Ⅱ.指向函数的指针变量作函数参数
3.返回指针值的函数
前言
前一章我讲解了一些有关函数的部分内容，但已经足够开始编写程序。但还有些细节的地方和不理解的地方在这篇都会涉及到。主要包括函数中参数的传递，不同类型的结构作为函数参数和函数的嵌套等一些函数的进阶内容都会在本文中讲解。对我个人而言函数还是非常重要的，它可以是你的代码具有更高的可读性。
这期题目分享全放到文章中。
一.函数调用中的参数传递
当被调用函数是有参函数时，主调函数与被调函数之间具有数据传递关系。 定义函数时的参数称为形式参数，简称形参。
形参在函数未被调用时没有确定的值，只 是形式上的参数。调用函数时的参数称为实际参数，简称实参。实参可以是变量、常量或表达式，有确定的取值，是实实在在的参数。函数定义时形参不占用内存，只有发生调用时才 被分配内存单元，接收实参传来的数据。
定义函数时必须定义形参的类型。函数的形参与实参的数量应相等，并且对应的形参和 实参的类型相同。形参和实参可以同名，形参是该函数内部的变量，即使形参和实参同名， 也是两个不同的变量，占用不同的内存单元。
1．普通变量作为函数的参数
单向的值传递（实参→形参），形参和实参分别分配存储空间，形参值的改变不会影响 实参。
2．数组元素作为参数
由于形参是在函数被调用时临时分配存储单元，不可能为一个数组元素单独分配存储单 元（数组是一个整体，在内存中占连续的一段存储单元）。因此数组元素只能用作函数实 参，不能用作形参。在用数组元素作函数实参时，把实参的值传给形参，也是单向的值传递 方式。
题目： 编写一个C语言程序，该程序包含一个函数 process_element，它接受一个整数参数。该函数将检查传入的整数是否为正数，如果是，则计算并返回该整数的平方；如果不是，则返回0。然后在 main 函数中，创建一个整数数组，并使用循环遍历数组中的每个元素，调用 process_element 函数处理每个元素，并打印结果。
#include
// 函数声明
int process_element(int element);
int main() {
int numbers[] = {3, -1, 5, 0, -4, 7};
int size = sizeof(numbers) / sizeof(numbers[0]);
// 遍历数组并处理每个元素
for (int i = 0; i < size; i++) {
int result = process_element(numbers[i]);
printf("The square of %d is: %d\n", numbers[i], result);
}
return 0;
}
// 函数定义
int process_element(int element) {
if (element > 0) {
return element * element; // 如果是正数，返回其平方
} else {
return 0; // 如果不是正数，返回0
}
}
在这个程序中，process_element 函数接受一个整数参数，并根据该整数的值返回其平方或0。main 函数创建了一个整数数组，并使用 for 循环遍历数组。在每次迭代中，它调用 process_element 函数，并将当前数组元素的值作为参数传递。然后，程序打印出每个元素及其处理后的结果。
这个例子展示了如何将数组元素作为参数传递给函数，以及如何在函数内部根据传入的参数执行不同的操作。
3．数组名作为函数的参数
数组是存储数据的重要工具。数组中存放的数据有次序关系，很容易进行统一处理。 函数可以通过参数传递来处理数组。用数组名作为函数实参时，向形参（数组名或指针变 量）传递的是数组在内存中的起始地址，形参和实参共用一个内存单元，形参值的改变会 影响实参。
题目： 编写一个C语言程序，该程序包含一个函数 sum_array，它接受一个整数数组和数组的大小作为参数，并计算数组中所有元素的和。然后在 main 函数中，创建一个整数数组，调用 sum_array 函数计算并打印数组元素的总和。
#include
// 函数声明
int sum_array(int arr[], int size);
int main() {
int numbers[] = {1, 2, 3, 4, 5};
int size = sizeof(numbers) / sizeof(numbers[0]);
int sum = sum_array(numbers, size);
printf("The sum of the array elements is: %d\n", sum);
return 0;
}
// 函数定义
int sum_array(int arr[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += arr[i]; // 累加数组中的每个元素
}
return sum; // 返回总和
}
在这个程序中，sum_array 函数接受一个整数数组 arr 和数组的大小 size 作为参数。函数通过一个 for 循环遍历数组中的所有元素，并将它们累加到变量 sum 中。完成累加后，函数返回总和。
在 main 函数中，我们创建了一个整数数组 numbers 并计算了其大小。然后，我们调用 sum_array 函数，并将数组名 numbers 和数组的大小 size 作为参数传递。最后，我们打印出数组元素的总和。
这个例子展示了如何在C语言中将整个数组作为参数传递给函数。需要注意的是，在C语言中，数组名 arr 在函数参数列表中实际上是一个指向数组第一个元素的指针，因此函数内部无法直接获取数组的大小，必须作为单独的参数传递。
4．指针变量作为函数的参数
将普通变量的地址传递给形参变量，形参变量必须是指针类型的。指针作为函数参数进 行传递，实质上还是值的单向传递，只不过传递的是地址值，实参和形参指向同一个存储单 元。在函数中改变形参变量所指向内存单元的值的，相当于改变了实参所指向的存储单元的 值。而实参指针变量的值没有改变。在程序设计过程中，往往利用这点，在编写程序时，通 过函数调用改变多个值。
题目： 编写一个C语言程序，该程序包含一个函数 increment，它接受一个指向整数的指针作为参数，并将该指针所指向的整数增加10。然后在 main 函数中，声明一个整数变量，初始化它，并调用 increment 函数来增加其值。最后，打印出增加后的值。
#include
// 函数声明
void increment(int *ptr);
int main() {
int value = 5;
printf("Original value: %d\n", value);
increment(&value); // 调用函数，传递变量的地址
printf("Value after increment: %d\n", value);
return 0;
}
// 函数定义
void increment(int *ptr) {
*ptr += 10; // 增加指针所指向的整数的值
}
在这个程序中，increment 函数接受一个指向整数的指针 ptr 作为参数。在函数内部，通过解引用指针 *ptr 来访问和修改指针所指向的整数，将其增加10。
在 main 函数中，我们声明了一个整数变量 value 并初始化为5。然后，我们调用 increment 函数，并将 value 的地址（通过 &value 获取）作为参数传递。调用 increment 函数后，value 的值增加了10。最后，我们打印出增加后的值。
这个例子展示了如何在C语言中使用指针作为函数参数，并通过指针修改传递的变量值。这是C语言中常用的技术，因为它允许函数直接修改传入的变量，而不仅仅是其副本。
二.函数的嵌套调用
C 语言中，函数的定义是平行的、独立的，函数间无从属关系，不允许嵌套定义，但可 以嵌套调用，即在调用一个函数的过程中，被调用的函数又可以调用另一个函数。无论嵌套 调用多少层，每个函数调用结束后都会返回到调用点，继续程序的执行，直到主函数执行完 成时程序运行结束。嵌套调用为结构化的程序设计提供了基本的支持。
题目： 编写一个C语言程序，该程序包含两个函数：square 和 sum_of_squares。square 函数接受一个整数参数并返回其平方。sum_of_squares 函数接受两个整数参数，计算并返回这两个整数的平方和。在 main 函数中，调用 sum_of_squares 函数并打印结果。
#include
// 函数声明
int square(int num);
int sum_of_squares(int a, int b);
int main() {
int num1 = 3;
int num2 = 4;
// 调用 sum_of_squares 函数，它内部调用 square 函数
int result = sum_of_squares(num1, num2);
printf("The sum of squares of %d and %d is: %d\n", num1, num2, result);
return 0;
}
// square 函数定义，返回整数的平方
int square(int num) {
return num * num;
}
// sum_of_squares 函数定义，返回两个整数平方的和
int sum_of_squares(int a, int b) {
return square(a) + square(b); // 嵌套调用 square 函数
}
在这个程序中，square 函数接收一个整数 num 并返回 num 的平方。sum_of_squares 函数接收两个整数 a 和 b，它通过调用 square 函数两次（一次为 a，一次为 b）来计算这两个数的平方和，并将结果返回。
在 main 函数中，我们声明了两个整数 num1 和 num2，分别初始化为3和4。然后，我们调用 sum_of_squares 函数，并将 num1 和 num2 作为参数传递。sum_of_squares 函数内部调用了 square 函数两次，分别计算 num1 和 num2 的平方，并将这两个平方值相加。最后，我们打印出计算得到的结果。
这个例子展示了函数的嵌套调用，即一个函数在执行过程中调用了另一个函数。
三.函数的递归调用
函数的递归指在调用函数的过程中，直接或间接的调用函数自身。 合理的递归调用应是有限的，在一定条件下会停止的。递归算法里必须具有使函数调用 终结的条件，称为递归终结条件。 从程序设计的角度考虑，递归算法包括递归公式和递归终结条件。
递归过程可表示为： if(递归终结条件) return (终结条件下的值);
else return (递归公式);
从数学的角度考虑就是构造递归函数。递归函数包括递归公式和递归终结条件（终结值）。
题目： 编写一个C语言程序，该程序包含一个递归函数 factorial，它接受一个非负整数 n 作为参数，并返回 n 的阶乘（n!）。在 main 函数中，读取用户输入的一个非负整数，并使用 factorial 函数计算并打印其阶乘。
#include
// 函数声明
unsigned long long factorial(int n);
int main() {
int number;
printf("Enter a non-negative integer: ");
scanf("%d", &number);
// 检查输入是否为非负整数
if (number < 0) {
printf("Factorial is not defined for negative numbers.\n");
} else {
// 调用递归函数计算阶乘
unsigned long long result = factorial(number);
printf("Factorial of %d is: %llu\n", number, result);
}
return 0;
}
// 递归函数定义，计算阶乘
unsigned long long factorial(int n) {
if (n == 0) {
return 1; // 递归的基本情况
} else {
return n * factorial(n - 1); // 递归调用
}
}
在这个程序中，factorial 函数是一个递归函数，它计算并返回一个非负整数 n 的阶乘。递归的基本情况是当 n 为0时，此时阶乘为1。对于其他情况，函数通过递归调用自身来计算 n * (n - 1)!。
在 main 函数中，程序提示用户输入一个非负整数，然后检查这个数是否为非负。如果输入有效，程序调用 factorial 函数来计算并打印出该数的阶乘。
递归是一种强大的编程技术，但它需要谨慎使用，因为错误的递归可能会导致无限循环或栈溢出。对于这个例子，确保输入的整数不会太大，以避免计算结果超出 unsigned long long 的范围。
四.函 数 与 宏
宏定义用指定的宏名（标识符）代替宏体。
1．不带参数的宏定义
不带参数的宏定义的一般形式为：
#define 宏名 宏体
其中，#define 是宏定义命令，宏名是一个标识符，宏体是一个字符序列。
2．带参数的宏定义
#define 宏名(形参表列) 宏体
其中，#define 是宏定义命令，宏名是一个标识符，形参表列是用逗号隔开的一个标识符 序列，宏体是包含形参的一个字符序列。
在程序中使用带参数宏的一般形式为：
宏名(实参表列)
其中，实参表列是逗号隔开的表达式。
注：（1）定义带参数的宏时，宏名和右边的圆括号之间不能加空格，否则，就成了不带参数的宏定义。
（2）为了正确进行替换，一般将宏体和各形参都加上圆括号。
（3）若实参是表达式，宏替换之前不求解表达式，宏替换之后进行编译时再求解。
五.函数指针与返回指针的函数
1.指向函数的指针变量定义的一般形式
指向函数的指针变量定义方式为：
类型说明符 (*指针变量名)();
类型说明符指函数返回值的类型
注：在定义指向函数的指针变量时，两对圆括号都不能省略。下两种形式具有不同的含义：
int (*fp)(); /*定义一个指向函数的指针变量*/
int *fp(); /*在老版本的 C 语言，这是声明返回整型指针值的函数原型*/
2.用指向函数的指针变量调用函数
定义了指向函数的指针变量后，通过指针变量可间接调用函数。用指向函数的指针变量 调用函数分为两个步骤：
（1）将函数的入口地址（即函数名）赋值给指向函数的指针变量；
（2）将指向函数的指针变量（连同圆括号）代替函数名使用。
Ⅰ.利用指针进行函数的选择调用
根据不同的条件，将不同的函数首地址赋值给函数指针变量，通过函数指针变量来间接 地调用该函数，从而达到根据不同条件调用不同函数的目的。
题目： 编写一个C语言程序，该程序包含四个不同的函数，每个函数执行一个基本的数学运算（加、减、乘、除）。主函数中，根据用户输入的运算符（+、-、*、/），使用函数指针来调用相应的运算函数，并打印结果。
#include
// 声明四个运算函数
double add(double a, double b) { return a + b; }
double subtract(double a, double b) { return a - b; }
double multiply(double a, double b) { return a * b; }
double divide(double a, double b) { return b != 0 ? a / b : 0; }
int main() {
double num1, num2, result;
char operator;
// 定义函数指针数组，用于选择函数
double (*operation[4])(double, double) = {add, subtract, multiply, divide};
char *ops = "+-*/"; // 对应运算符的字符串
// 从用户那里获取输入
printf("Enter an operator (+, -, *, /): ");
scanf(" %c", &operator);
printf("Enter two numbers: ");
scanf("%lf %lf", &num1, &num2);
// 查找运算符并调用相应的函数
for (int i = 0; i < 4; i++) {
if (operator == ops[i]) {
result = operation[i](num1, num2); // 通过函数指针调用函数
break;
}
}
// 打印结果
if (operator == '/' && num2 == 0) {
printf("Division by zero is undefined.\n");
} else {
printf("Result: %lf\n", result);
}
return 0;
}
Ⅱ.指向函数的指针变量作函数参数
用指向函数的指针变量作为函数参数，把相应函数的入口地址传送给主调函数。函数通 过函数指针变量调用相应的函数。
题目： 编写一个C语言程序，该程序包含一个名为 apply_operation 的函数，它接受两个整数和一个指向函数的指针作为参数。该指针指向的函数执行一个基本的数学运算（加、减、乘、除）。apply_operation 函数将调用传入的函数来对两个整数进行运算，并返回结果。在 main 函数中，根据用户的选择，调用 apply_operation 函数并打印结果。
#include
// 声明四个基本运算函数
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
int divide(int a, int b) { return b != 0 ? a / b : 0; }
// apply_operation 函数声明，它接受一个指向函数的指针作为参数
int apply_operation(int a, int b, int (*operation)(int, int));
int main() {
int num1, num2, result;
int choice;
// 获取用户输入的两个数字
printf("Enter two numbers: ");
scanf("%d %d", &num1, &num2);
// 获取用户选择的运算类型
printf("Choose an operation:\n");
printf("1: Addition\n");
printf("2: Subtraction\n");
printf("3: Multiplication\n");
printf("4: Division\n");
scanf("%d", &choice);
// 根据用户选择调用 apply_operation 函数
switch (choice) {
case 1:
result = apply_operation(num1, num2, add);
break;
case 2:
result = apply_operation(num1, num2, subtract);
break;
case 3:
result = apply_operation(num1, num2, multiply);
break;
case 4:
result = apply_operation(num1, num2, divide);
if (num2 == 0) {
printf("Division by zero is undefined.\n");
return 1;
}
break;
default:
printf("Invalid choice.\n");
return 1;
}
// 打印结果
printf("Result: %d\n", result);
return 0;
}
// apply_operation 函数定义
int apply_operation(int a, int b, int (*operation)(int, int)) {
return operation(a, b); // 调用传入的函数指针
}
3.返回指针值的函数
函数的返回值不仅可以是整型、实型、字符型等数据，也可以是指针类型的数据，即地址值。当函数返回指针类型数据时，应在定义函数时对返回值的类型进行说明。说明的格式为：
函数返回值类型 *函数名(形式参数表列)
题目： 编写一个C语言程序，该程序包含一个名为 create_array 的函数，它接受一个整数 n 作为参数，并返回一个指向包含 n 个整数的数组的指针。在 main 函数中，调用 create_array 函数，并打印数组中的元素。
#include
// 函数声明
int* create_array(int n);
int main() {
int n, *array;
// 从用户那里获取 n 的值
printf("Enter the number of elements in the array: ");
scanf("%d", &n);
// 调用 create_array 函数并打印结果
array = create_array(n);
printf("The elements of the array are: ");
for (int i = 0; i < n; i++) {
printf("%d ", array[i]);
}
printf("\n");
return 0;
}
// 函数定义
int* create_array(int n) {
int *ptr = (int*)malloc(n * sizeof(int)); // 动态分配内存
if (ptr == NULL) { // 检查内存分配是否成功
printf("Memory allocation failed.\n");
return NULL;
}
// 初始化数组元素
for (int i = 0; i < n; i++) {
ptr[i] = i + 1; // 数组元素从1开始
}
return ptr; // 返回指向数组的指针
}
————由于博主还是大三的在读生，时间有限，每天会不定时更新一些学习经验和一些32的项目，如果喜欢就点点关注吧，大佬们！！！！————