目录
一、函数的基本结构与定义
1.1 函数的返回值类型、函数名与参数列表
在 C++ 中，函数是一段完成特定任务的独立代码块。一个完整的函数包含返回值类型、函数名和参数列表。
函数的返回值类型决定了函数执行完毕后返回的数据类型，它可以是 C++ 中的基本数据类型，如int（整型）、float（单精度浮点型）、double（双精度浮点型）、char（字符型） 等，也可以是自定义的数据类型，像结构体（struct）、类（class），还可以是指针类型、引用类型等。若函数不需要返回任何值，则使用void关键字来标识。例如：
int add(int a, int b); // 返回值类型为int
double calculateArea(double radius); // 返回值类型为double
void printMessage(const std::string& message); // 返回值类型为void
函数名是用于标识该函数的标识符，其命名需要遵循 C++ 的标识符命名规则：必须以字母或下划线开头，后续字符可以是字母、数字或下划线，且不能使用 C++ 的关键字作为函数名。为了提高代码的可读性和可维护性，函数名应尽量做到清晰且具有描述性，能准确表达函数的功能，通常建议使用动词或动词短语作为前缀来表示函数执行的动作，比如calculateTotal（计算总和）、validateInput（验证输入）等。
参数列表是函数在被调用时接收外部传入数据的地方，参数列表中的参数被称为形式参数（形参）。形参相当于函数内部的局部变量，只有在函数被调用时才会被分配内存空间，并接收调用函数时传入的实际参数（实参）的值。形参可以有多个，多个形参之间用逗号隔开，每个形参都需要指定数据类型。例如，上述add函数中的a和b就是形参，它们的类型都是int；calculateArea函数中的radius是形参，类型为double。实参则是在调用函数时实际传递给函数的值，可以是常量、变量、表达式或函数等。例如：
int result = add(3, 5); // 3和5是实参
double area = calculateArea(2.5); // 2.5是实参
1.2 函数体的编写规范与注意事项
函数体是函数定义中位于参数列表之后的大括号{}内的代码部分，它包含了实现函数特定功能的一系列语句和逻辑。编写函数体时，需要遵循一定的规范并注意一些事项，以确保代码的清晰性、简洁性和可维护性。
代码的逻辑结构要清晰明了，通常可以采用模块化的方式，将复杂的功能分解为多个小的功能模块，每个模块通过独立的代码块或子函数来实现，这样有助于提高代码的可读性和可维护性。比如，在实现一个计算学生成绩统计的函数时，可以将计算总分、平均分、最高分、最低分等功能分别封装成独立的子函数，然后在主函数中调用这些子函数来完成最终的统计任务。
注释是提高代码可读性的重要手段，在函数体中，应适当添加注释来解释关键代码的作用、功能以及实现思路。特别是对于一些复杂的算法、逻辑判断或者容易引起误解的代码部分，注释显得尤为重要。例如：
// 计算两个整数的和
int add(int a, int b) {
// 将a和b相加，并返回结果
return a + b;
}
对函数的输入参数进行合法性检查是一个良好的编程习惯，可以有效避免函数在运行时因为接收到非法参数而导致的错误或异常情况。例如，在一个除法函数中，需要检查除数是否为零：
double divide(double dividend, double divisor) {
if (divisor == 0) {
std::cerr << "Error: divisor cannot be zero!" << std::endl;
return 0; // 这里可以根据实际需求返回合适的值，比如抛出异常等
}
return dividend / divisor;
}
在函数内部应尽量避免使用过多的全局变量，因为全局变量的使用会增加代码的耦合度，降低代码的可维护性和可测试性。如果确实需要使用全局变量，应尽量限制其作用域，并对其进行明确的注释说明。
同时，要注意函数的规模不宜过大，一个函数应尽量只完成单一的、明确的功能。如果一个函数的代码量过多，功能过于复杂，就应该考虑将其拆分成多个小的函数，每个小函数完成一个具体的子功能。这样不仅便于代码的阅读和理解，也有利于代码的调试和维护。
1.3 函数声明与函数定义的分离方法
在 C++ 编程中，函数声明和函数定义可以分离，这是一种非常实用的编程技巧，尤其在大型项目开发中。
函数声明的作用是告知编译器函数的存在，以及函数的返回值类型、函数名和参数列表，但并不包含函数的具体实现代码（即函数体）。函数声明也被称为函数原型，它的语法形式与函数定义的头部基本相同，只是末尾以分号;结束。例如：
int add(int a, int b); // 函数声明
double calculateArea(double radius); // 函数声明
void printMessage(const std::string& message); // 函数声明
函数定义则是函数的具体实现部分，它包含了函数体，即实现函数功能的具体代码。例如：
// 函数定义：计算两个整数的和
int add(int a, int b) {
return a + b;
}
// 函数定义：计算圆的面积
double calculateArea(double radius) {
return 3.14159 * radius * radius;
}
// 函数定义：打印消息
void printMessage(const std::string& message) {
std::cout << message << std::endl;
}
将函数声明和函数定义分离的常见做法是，把函数声明放在头文件（.h或.hpp）中，而把函数定义放在源文件（.cpp）中。这样做有以下几个好处：一是提高编译效率，当项目中多个源文件都需要使用某个函数时，只需要在头文件中声明一次函数，各个源文件包含该头文件即可，而不需要在每个源文件中都重复定义函数，从而减少了编译时间；二是增强代码的封装性和可维护性，通过将函数声明和定义分离，可以将函数的接口（声明）和实现细节（定义）分开，使得代码结构更加清晰，便于团队协作开发和后期维护。
例如，假设有一个数学运算库，其中包含add函数，我们可以这样组织代码：
在math.h头文件中声明add函数：
#ifndef MATH_H
#define MATH_H
int add(int a, int b);
#endif
在math.cpp源文件中定义add函数：
#include "math.h"
int add(int a, int b) {
return a + b;
}
在其他需要使用add函数的源文件中，只需包含math.h头文件即可：
#include <iostream>
#include "math.h"
int main() {
int result = add(3, 5);
std::cout << "The result of addition is: " << result << std::endl;
return 0;
}
通过这种方式，实现了函数声明与函数定义的分离，使得代码结构更加清晰，易于管理和维护。
二、函数的调用与参数传递实战
2.1 函数调用的语法与执行流程
在 C++ 中，函数调用是执行函数代码的操作，其语法非常直观，通过函数名加上一对括号()来实现，如果函数有参数，则在括号内传入相应的实参，多个实参之间用逗号,隔开。例如，对于前面定义的add函数，调用方式如下：
int result = add(3, 5);
这里add是函数名，(3, 5)是传入的实参，函数调用的结果会返回一个值，这里将返回值赋值给result变量。
函数调用的执行流程如下：当程序执行到函数调用语句时，首先会计算实参的值。比如在add(3, 5)中，会确定3和5这两个值。接着，系统会为被调用函数的形参分配内存空间，并将实参的值复制给形参，就像把3和5分别放入add函数中a和b对应的内存位置。然后，程序的控制权会转移到被调用函数的起始位置，开始执行被调用函数内的代码块，即执行add函数中的return a + b;语句。如果函数有返回值，在函数执行完毕后，会将返回值传递给调用函数。最后，程序返回到调用函数的下一条语句，继续执行后续代码。例如：
#include <iostream>
int add(int a, int b) {
return a + b;
}
int main() {
int num1 = 3;
int num2 = 5;
int sum = add(num1, num2); // 调用add函数
std::cout << "The sum is: " << sum << std::endl; // 输出结果
return 0;
}
在这个例子中，main函数中调用add函数，执行流程为：先计算num1和num2的值，然后将它们作为实参传递给add函数的形参a和b，接着执行add函数计算两数之和并返回，最后将返回值赋给sum变量，并在main函数中输出结果。
2.2 值传递方式的特点与应用场景
值传递是 C++ 中一种基本的参数传递方式。在值传递过程中，当函数被调用时，系统会将实参的值复制一份，传递给函数的形参。这意味着在函数内部，形参是实参的一个副本，它们在内存中占据不同的位置。对形参的任何修改，都只会影响形参本身，而不会改变原始的实参。例如：
#include <iostream>
void increment(int num) {
num++; // 对形参num进行自增操作
}
int main() {
int value = 5;
increment(value); // 调用increment函数
std::cout << "The value is: " << value << std::endl; // 输出结果
return 0;
}
在上述代码中，increment函数通过值传递接收value的值。在函数内部，对num进行自增操作，但main函数中的value值并不会改变，输出结果仍然是5。
值传递的适用场景主要有以下几种情况：当函数不需要修改实参的值，只是利用实参进行一些计算或操作时，值传递是一种简单且安全的选择。例如，在一个计算圆面积的函数中，传递圆的半径作为参数，函数只需要使用半径进行计算，而不需要改变半径的值，这种情况下使用值传递非常合适。另外，当传递的是基本数据类型（如int、float、char等）时，由于这些数据类型的大小通常较小，复制的开销不大，值传递也能高效地工作。
然而，当传递大型对象（如自定义的结构体、类对象等）时，值传递可能会导致性能问题。因为复制大型对象需要消耗较多的时间和内存资源，这会降低程序的执行效率。例如，假设我们有一个包含大量数据成员的类BigObject，如果使用值传递将BigObject对象传递给函数，每次调用函数时都要复制整个对象，这无疑会增加程序的运行时间和内存占用。所以在传递大型对象时，通常需要考虑其他更高效的传递方式，如引用传递或指针传递。
2.3 函数参数的默认值设置与使用规则
在 C++ 中，函数的参数可以设置默认值。当函数调用时，如果没有为设置了默认值的参数传递实参，那么该参数就会使用预先设定的默认值。这一特性为函数的调用提供了很大的灵活性，减少了函数重载的使用，使代码更加简洁和易读。例如：
#include <iostream>
void printInfo(const std::string& name, int age = 18, const std::string& city = "Unknown") {
std::cout << "Name: " << name << ", Age: " << age << ", City: " << city << std::endl;
}
int main() {
printInfo("Alice"); // 使用默认的age和city值
printInfo("Bob", 25); // 使用默认的city值
printInfo("Charlie", 30, "New York"); // 不使用默认值
return 0;
}
在上述代码中，printInfo函数的age参数默认值为18，city参数默认值为"Unknown"。在main函数中，第一次调用printInfo(“Alice”)时，age和city都使用默认值；第二次调用printInfo(“Bob”, 25)时，city使用默认值；第三次调用printInfo(“Charlie”, 30, “New York”)时，所有参数都不使用默认值。
设置函数参数默认值时，需要遵循一定的规则：默认参数必须从右向左依次设置，即如果一个函数有多个参数，从最右边的参数开始设置默认值，一旦为某个参数设置了默认值，其右边的所有参数都必须有默认值。例如：
// 正确的设置
void func(int a, int b = 10, int c = 20);
// 错误的设置，因为b有默认值，而c没有
void func(int a, int b = 10, int c);
此外，默认参数不能同时出现在函数的声明和定义中。如果函数有声明和定义，通常在声明中设置默认参数，这样在调用函数的地方，只需要包含函数声明的头文件，就能明确函数参数的默认值。例如：
// 在头文件中声明
void func(int a, int b = 10, int c = 20);
// 在源文件中定义
void func(int a, int b, int c) {
// 函数体实现
}
在实际应用中，合理地使用函数参数的默认值可以简化函数的调用，提高代码的可读性和可维护性。但需要注意的是，过度使用默认值可能会使函数的功能不够明确，因此要根据具体的业务需求和代码逻辑来谨慎设置。
三、函数的嵌套与递归调用实战
3.1 函数嵌套调用的语法与执行顺序
在 C++ 中，函数嵌套调用是指在一个函数的执行过程中调用另一个函数。其语法非常简单，只需要在一个函数的函数体内通过函数名加上括号及相应参数（如果有）来调用另一个已经定义好的函数即可。例如：
#include <iostream>
// 定义函数B
void functionB() {
std::cout << "This is function B." << std::endl;
}
// 定义函数A，在函数A中调用函数B
void functionA() {
std::cout << "This is the beginning of function A." << std::endl;
functionB();
std::cout << "This is the end of function A." << std::endl;
}
int main() {
functionA();
return 0;
}
在上述代码中，functionA函数内部调用了functionB函数，这就是一个简单的函数嵌套调用示例。
函数嵌套调用的执行顺序遵循 “先调用的函数后返回” 的原则，也就是常说的后进先出（LIFO，Last In First Out）顺序，类似于栈的操作。当程序执行到functionA函数中的functionB()调用语句时，会暂停functionA函数的执行，转而执行functionB函数的代码。当functionB函数执行完毕并返回后，程序才会继续从functionA函数中调用functionB函数的位置往后执行。就像上面的例子，首先输出This is the beginning of function A.，然后调用functionB函数，输出This is function B.，最后再输出This is the end of function A.。
如果存在多层嵌套调用，比如functionA调用functionB，functionB又调用functionC，其执行顺序依然遵循上述原则。先执行functionA的开头部分，遇到functionB调用时，暂停functionA，执行functionB；在functionB中遇到functionC调用时，再暂停functionB，执行functionC；functionC执行完返回functionB，functionB执行完再返回functionA，继续执行functionA剩余部分。例如：
#include <iostream>
// 定义函数C
void functionC() {
std::cout << "This is function C." << std::endl;
}
// 定义函数B，在函数B中调用函数C
void functionB() {
std::cout << "This is the beginning of function B." << std::endl;
functionC();
std::cout << "This is the end of function B." << std::endl;
}
// 定义函数A，在函数A中调用函数B
void functionA() {
std::cout << "This is the beginning of function A." << std::endl;
functionB();
std::cout << "This is the end of function A." << std::endl;
}
int main() {
functionA();
return 0;
}
这个例子中，输出顺序依次为：This is the beginning of function A.、This is the beginning of function B.、This is function C.、This is the end of function B.、This is the end of function A.。通过这样的执行顺序，C++ 能够有条不紊地处理复杂的函数嵌套逻辑，实现各种复杂的功能。
3.2 递归调用的原理与适用场景
递归调用是 C++ 中一种特殊的函数调用方式，它指的是一个函数在其函数体内部直接或间接地调用自身。例如，计算阶乘的函数就可以用递归方式实现：
#include <iostream>
// 递归计算阶乘
int factorial(int n) {
if (n == 0 || n == 1) {
return 1; // 终止条件，也称为递归出口
} else {
return n * factorial(n - 1); // 递归调用，不断将问题规模缩小
}
}
int main() {
int num = 5;
int result = factorial(num);
std::cout << num << "! = " << result << std::endl;
return 0;
}
在上述factorial函数中，当n为 0 或 1 时，直接返回 1，这是递归的终止条件。如果n大于 1，则通过n * factorial(n - 1)调用自身，将计算n的阶乘问题转化为计算n - 1的阶乘问题，随着递归的深入，n的值不断减小，最终会达到终止条件，从而结束递归调用。
递归调用的原理基于分治思想，即将一个复杂的大问题分解为若干个规模较小、但结构与原问题相似的子问题，通过递归地解决这些子问题，最终得到原问题的解。在递归调用过程中，系统会使用栈来保存每一次函数调用的现场信息，包括函数的参数、局部变量以及返回地址等。每次递归调用时，都会在栈顶创建一个新的栈帧，用于存储本次调用的相关信息；当递归返回时，会从栈顶弹出相应的栈帧，恢复之前的现场信息，继续执行后续代码。
递归调用适用于许多场景，尤其是那些具有明显递归结构或可以自然地分解为更小相似问题的任务。在数学计算方面，除了阶乘计算，斐波那契数列的计算也是递归的经典应用。斐波那契数列的定义为：F(0) = 0，F(1) = 1，F(n) = F(n - 1) + F(n - 2)（n > 1） ，用 C++ 实现如下：
#include <iostream>
// 递归计算斐波那契数列
int fibonacci(int n) {
if (n == 0) {
return 0;
} else if (n == 1) {
return 1;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
int main() {
int num = 7;
int result = fibonacci(num);
std::cout << "The " << num << "th Fibonacci number is: " << result << std::endl;
return 0;
}
在树状结构遍历中，递归也是一种非常自然且简洁的方式。以二叉树的前序遍历（先访问根节点，再访问左子树，最后访问右子树）为例，假设已经定义了二叉树节点结构体TreeNode，可以用递归实现如下：
#include <iostream>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
// 前序遍历二叉树
void preorderTraversal(TreeNode* root) {
if (root) {
std::cout << root->val << " ";
preorderTraversal(root->left);
preorderTraversal(root->right);
}
}
int main() {
// 简单构建一个二叉树
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
std::cout << "Preorder Traversal: ";
preorderTraversal(root);
std::cout << std::endl;
// 释放内存（省略具体释放代码，可使用递归或循环释放）
return 0;
}
在这个例子中，通过递归不断地访问根节点、左子树和右子树，实现了二叉树的前序遍历。此外，在文件系统遍历（如遍历目录和文件）以及许多分治算法（如归并排序、快速排序等）的实现中，递归都发挥着重要作用。
3.3 递归深度控制与避免栈溢出
虽然递归调用在解决某些问题时非常简洁和直观，但它也存在一个潜在的风险，即递归深度过大可能导致栈溢出（Stack Overflow）错误。这是因为每次递归调用都会在系统栈中创建一个新的栈帧，用于保存函数的参数、局部变量和返回地址等信息。如果递归调用的层数过多，栈空间会被不断消耗，当栈空间耗尽时，就会发生栈溢出错误，导致程序崩溃。
为了控制递归深度并避免栈溢出，可以采取以下几种方法：一是设置递归深度限制，在递归函数内部添加一个计数器变量，用于记录递归的层数。每次递归调用时，计数器加 1，当计数器达到预设的递归深度限制时，直接返回，不再进行递归调用。例如：
#include <iostream>
// 设置最大递归深度
const int MAX_DEPTH = 1000;
// 带递归深度限制的递归函数
int recursiveFunction(int n, int depth = 0) {
if (depth >= MAX_DEPTH) {
std::cerr << "Recursion depth limit reached!" << std::endl;
return -1; // 返回一个特殊值表示达到深度限制
}
if (n == 0 || n == 1) {
return 1;
} else {
return n * recursiveFunction(n - 1, depth + 1);
}
}
int main() {
int num = 1500;
int result = recursiveFunction(num);
if (result != -1) {
std::cout << num << "! = " << result << std::endl;
}
return 0;
}
在上述代码中，recursiveFunction函数增加了一个depth参数，用于记录递归深度。当depth达到MAX_DEPTH时，输出错误信息并返回 -1，从而避免了无限递归导致的栈溢出。
二是使用迭代替代递归，对于一些可以用递归解决的问题，也可以通过迭代（循环）的方式来实现。迭代方式通常不会受到栈空间的限制，因为它不需要在栈中保存大量的递归调用信息。以计算阶乘为例，用迭代方式实现如下：
#include <iostream>
// 迭代计算阶乘
int factorialIterative(int n) {
int result = 1;
for (int i = 1; i <= n; ++i) {
result *= i;
}
return result;
}
int main() {
int num = 5;
int result = factorialIterative(num);
std::cout << num << "! = " << result << std::endl;
return 0;
}
在这个例子中，通过for循环从 1 到n依次累乘，实现了与递归方式相同的阶乘计算功能，但避免了递归调用带来的栈溢出风险。
三是采用尾递归优化，尾递归是指在递归函数的最后一步调用自身，并且返回值直接是递归调用的结果，没有其他额外的计算。一些编译器能够对尾递归进行优化，将其转换为迭代形式，从而避免栈溢出问题。不过，C++ 标准并没有强制要求编译器支持尾递归优化，不同的编译器对尾递归的处理可能不同。例如：
#include <iostream>
// 尾递归计算阶乘
int factorialTailRecursive(int n, int acc = 1) {
if (n == 0 || n == 1) {
return acc;
} else {
return factorialTailRecursive(n - 1, acc * n);
}
}
int main() {
int num = 5;
int result = factorialTailRecursive(num);
std::cout << num << "! = " << result << std::endl;
return 0;
}
在上述代码中，factorialTailRecursive函数通过引入一个累加器acc，将乘法运算放在递归调用之前，使得递归调用成为函数的最后一步操作，符合尾递归的形式。如果编译器支持尾递归优化，这个函数在执行时就不会出现栈溢出问题。
四、实战项目：数学常用函数库实现
4.1 项目功能规划（求和、求积、求阶乘等）
我们规划实现的数学常用函数库，主要包含以下几个核心功能：
- 求和函数：实现对多个整数或浮点数的求和操作。该函数接受一个数组（或可变参数列表，在 C++11 及以上可使用std::initializer_list）作为输入，返回所有元素的总和。输入可以是任意数量的数值，输出为这些数值的累加结果。例如，输入{1, 2, 3, 4}，输出为10。
- 求积函数：用于计算多个数值的乘积。同样接受一个数组（或std::initializer_list）作为参数，返回所有元素相乘的结果。输入可以是不同类型的数值，输出是它们的乘积。例如，输入{2, 3, 4}，输出为24。
- 求阶乘函数：计算一个非负整数的阶乘。函数接受一个整数n作为输入，返回n!的结果，即n * (n - 1) * (n - 2) *… * 1，特别地，0! = 1。输入为一个非负整数，输出为该整数的阶乘值。例如，输入5，输出为120。
- 幂函数：计算一个数的指定次幂。函数接受两个参数，底数base和指数exponent，返回base的exponent次幂的结果，即base ^ exponent。输入分别为底数和指数，输出为幂运算的结果。例如，输入base = 2，exponent = 3，输出为8。
- 最大最小值函数：找出一组数值中的最大值和最小值。函数接受一个数组（或std::initializer_list）作为输入，分别返回这组数值中的最大值和最小值。输入为多个数值，输出为这组数值中的最大和最小值。例如，输入{3, 7, 1, 9, 4}，输出最大值为9，最小值为1。
4.2 各函数定义与调用代码实现
下面是使用 C++ 实现上述数学函数库的代码示例：
#include <iostream>
#include <initializer_list>
// 求和函数
double sum(std::initializer_list<double> numbers) {
double result = 0;
for (auto num : numbers) {
result += num;
}
return result;
}
// 求积函数
double product(std::initializer_list<double> numbers) {
double result = 1;
for (auto num : numbers) {
result *= num;
}
return result;
}
// 求阶乘函数
unsigned long long factorial(int n) {
if (n == 0 || n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
// 幂函数
double power(double base, int exponent) {
double result = 1;
for (int i = 0; i < exponent; ++i) {
result *= base;
}
return result;
}
// 最大最小值函数
void findMinMax(std::initializer_list<double> numbers, double& min, double& max) {
if (numbers.size() == 0) {
return;
}
min = max = *numbers.begin();
for (auto num : numbers) {
if (num < min) {
min = num;
}
if (num > max) {
max = num;
}
}
}
int main() {
// 测试求和函数
double sumResult = sum({1.5, 2.5, 3.5});
std::cout << "Sum: " << sumResult << std::endl;
// 测试求积函数
double productResult = product({2, 3, 4});
std::cout << "Product: " << productResult << std::endl;
// 测试求阶乘函数
unsigned long long factorialResult = factorial(5);
std::cout << "Factorial of 5: " << factorialResult << std::endl;
// 测试幂函数
double powerResult = power(2, 3);
std::cout << "2 to the power of 3: " << powerResult << std::endl;
// 测试最大最小值函数
double min, max;
findMinMax({3, 7, 1, 9, 4}, min, max);
std::cout << "Min: " << min << ", Max: " << max << std::endl;
return 0;
}
在上述代码中：
- sum函数通过遍历std::initializer_list来累加所有元素，实现求和功能。
- product函数类似地遍历列表，累乘所有元素来求积。
- factorial函数采用递归方式计算阶乘。
- power函数通过循环累乘底数base，实现幂运算。
- findMinMax函数遍历列表，找出最小值和最大值，并通过引用参数返回结果。
4.3 函数测试与性能优化
- 函数测试：对于实现的数学函数，可以采用多种测试方法来确保其正确性：
- 单元测试：使用如 Google Test 等单元测试框架，为每个函数编写独立的测试用例。例如，对于sum函数，可以测试不同数量、不同类型（整数、浮点数）的输入组合，验证其返回结果是否正确。
#include <gtest/gtest.h>
#include "math_library.h" // 假设上述函数定义在math_library.h中
TEST(SumTest, BasicSum) {
EXPECT_DOUBLE_EQ(sum({1, 2, 3}), 6);
}
TEST(ProductTest, BasicProduct) {
EXPECT_DOUBLE_EQ(product({2, 3, 4}), 24);
}
TEST(FactorialTest, BasicFactorial) {
EXPECT_EQ(factorial(5), 120);
}
TEST(PowerTest, BasicPower) {
EXPECT_DOUBLE_EQ(power(2, 3), 8);
}
TEST(MinMaxTest, BasicMinMax) {
double min, max;
findMinMax({3, 7, 1, 9, 4}, min, max);
EXPECT_DOUBLE_EQ(min, 1);
EXPECT_DOUBLE_EQ(max, 9);
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
- 边界测试：针对每个函数，测试边界条件。比如对于factorial函数，测试n = 0和n = 1的情况；对于power函数，测试exponent = 0和exponent = 1的情况。
- 异常测试：对于可能出现异常的情况进行测试，虽然上述函数目前没有明显的异常情况，但如果后续对输入进行更严格的限制，如factorial函数不接受负数输入时，就需要测试传入负数时函数的处理是否正确，是否能给出合适的错误提示。
- 性能优化：对于这些数学函数，可以考虑以下优化策略：
- 对于factorial函数：由于递归调用存在栈溢出风险且效率较低，可以将其改为迭代实现，减少函数调用开销。例如：
unsigned long long factorial(int n) {
unsigned long long result = 1;
for (int i = 1; i <= n; ++i) {
result *= i;
}
return result;
}
- 对于power函数：可以使用快速幂算法来提高计算效率。快速幂算法利用二进制拆分指数，将幂运算的时间复杂度从O(n)降低到O(log n)。例如：
double power(double base, int exponent) {
double result = 1;
while (exponent > 0) {
if (exponent & 1) {
result *= base;
}
base *= base;
exponent >>= 1;
}
return result;
}
通过这些测试和优化手段，可以提高数学函数库的可靠性和执行效率，使其在实际应用中更加稳定和高效。