int fun(int m, int n) { int c=0; static int b=2; if(m<b || n<b) return m*n; else if(m%b==0 && n%b==0) {c=b; return c*fun(m/b,n/b);} else {b++; return fun(m,n);} } 这个函数的作用

这个函数名为 `fun`，接受两个整型参数 `m` 和 `n`。其作用是计算 `m` 和 `n` 的最大公约数。

具体实现过程为：

1. 初始化变量 `c` 和 `b`，其中 `c` 初始值为 0，`b` 初始值为 2。

2. 如果 `m` 或 `n` 中有一个小于 `b`，则直接返回 `m*n`。

3. 如果 `m` 和 `n` 都能被 `b` 整除，则将 `c` 的值赋为 `b`，并递归调用 `fun(m/b, n/b)`，将返回值乘以 `c`。

4. 如果 `m` 和 `n` 都不能被 `b` 整除，则将 `b` 加 1，再递归调用 `fun(m, n)`。

该函数使用了递归算法实现，通过不断缩小 `m` 和 `n` 的值来求解它们的最大公约数。

相关问题

//程序阅读，输出结果 #include <stdio.h> int fun(int n); int a; int main() { fun(4); printf("%d", a); return 0; } int fun(int n) { static int count = 0; count++; if (n <= 2) return 1; int r = fun(n - 1) + fun(n - 2); a = count; return r; }

这段程序的输出结果是 7。程序的执行过程是这样的：

1. main 函数调用 fun(4)。
2. fun(4) 内部执行 fun(3) 和 fun(2)。
3. fun(3) 内部执行 fun(2) 和 fun(1)。
4. fun(2) 和 fun(1) 都返回 1。
5. fun(3) 返回 fun(2) + fun(1) = 2。
6. fun(4) 内部执行 fun(3) 和 fun(2)。
7. fun(2) 已经被执行过了，不再执行，直接返回 1。
8. fun(3) 已经被执行过了，不再执行，直接返回 2。
9. fun(4) 返回 fun(3) + fun(2) = 3。
10. fun(4) 执行完毕，a 的值为3。
11. main 函数输出 a 的值，即输出 3。
12. 程序执行完毕，返回 0。

#include<iostream> using namespace std; class My { private: int a; static int b; public: My(int i) { a=i; b=b+a; } static void fun(My M) { cout<<"a="<<M.a<<endl; cout<<"b="<<b<<endl; } }; int My::b=0; int main() { My A(150),B(300); My::fun(A); B.fun(B); } 这段代码的功能

这段代码的功能是定义了一个名为My的类，其中包含了一个私有的整型变量a、一个静态的整型变量b和一个公有的构造函数My(int i)。在构造函数中，将参数i的值赋值给a，并将a的值加上静态变量b的值赋给b。此外，类中还定义了一个静态的成员函数fun，参数为My类型的对象M，函数中输出参数M的私有变量a的值和静态变量b的值。

在主函数中，创建了两个My类型的对象A和B，并分别传入参数150和300。然后分别通过类名和对象名来调用静态函数fun，其中类名调用时传入了对象A，对象名调用时传入了对象B。调用函数fun时，会输出对应对象的私有变量a的值和静态变量b的值。