迹忆客 专注技术分享

C++ 与许多其他编程语言一样，C++ 带有一个内置库，其中包含函数和模块以简化任务。 pow() 函数是一个内置函数，可让我们轻松计算数字的幂。

但是，可能存在一种情况，例如在编码平台上，您必须在不使用任何内置函数的情况下找到数字的幂。 对你将如何做到这一点有什么猜测吗？

在本文中，我们将讨论在不使用 pow() 函数的情况下计算数字指数的各种方法。

在 C++ 中不使用 pow() 函数计算指数

在我们继续使用 pow() 函数的替代方法之前，让我们先看看 pow() 函数在 C++ 中是如何工作的。

C++ 中的 pow() 函数

顾名思义，pow() 或幂函数计算数字的幂。 此函数采用两个值作为参数，并且还需要使用头文件。

我们传入 pow() 函数的第一个值作为基数，第二个值是基数必须提高到的指数。 这是一个借助 pow() 函数计算 5^3 值的程序。

#include<iostream>
#include<math.h>
#include<stdio.h>

using namespace std;
int main()
{
    double b=5.0, p=3.0, ans;
    ans = pow(b,p);

    cout << ans;

    return 0;
}

输出结果:

125

请注意 ，pow() 函数采用 double 值而不是 int 作为参数。 但这并不意味着 pow() 函数不能用于整数。

但是，有时将 int 与 pow() 函数一起使用可能会在某些编译器中产生荒谬的输出。 例如，对于某些编译器，pow(4,2) 的输出可能为 15。

因此，建议使用具有双精度数据类型的 pow() 函数。

现在您已经了解了 pow() 函数的基础知识，让我们讨论一些在不使用 C++ 中的 pow() 函数的情况下计算数字指数的其他方法。

在 C++ 中使用 for 循环计算指数而不使用 pow() 函数

我们知道，在计算一个数的指数时，我们会使用重复的乘法。 重复此乘法的次数取决于指数或底数的幂。

这是一个相同的例子。

5^4 = 5 * 5 * 5 * 5 = 625

我们也可以在使用 for 循环的编程中应用这个概念。 这是相同的代码。

#include<iostream>
#include<math.h>
#include<stdio.h>

using namespace std;
int main()
{
    int i, e, b, ans=1;

    cout << "Enter the base: " << endl;
    cin >> b;

    cout << "Enter the exponent: " << endl;
    cin >> e;


    /*logic to calculate power*/

    for(i= 1; i <= e; ++i)
    {
        ans = ans*b;
    }

    cout << "The solution is: " << ans;

    return 0;
}

输出如下:

Enter the base:
5
Enter the exponent:
4
The solution is: 625

那么这段代码中发生了什么？

变量 b 和 e 分别指基数和指数。 此外，变量 ans 的值为 1，变量 i 定义了 for 循环运行的次数。

现在明白这里使用 pow() 函数的逻辑是从这段代码中的 for 块开始的。 因此，让我们分解一下 for 块中发生的事情。

你可以看到 i 被初始化为 1，它上升到指数的值，这里是 4。 此外，循环内的语句将 b 与 ans 相乘，并将结果存储在变量 ans 本身中。

这是变量 ans 在每次迭代中包含的内容。

i=1
ans = 1*5
ans = 5

i=2
ans = 5*5
ans = 25

i=3
ans = 25*5
ans = 125

i=4
ans = 125*5
ans = 625

显然，当循环终止时，变量 ans 的最终值作为输出返回。 这本质上就是如何在没有 pow() 函数的情况下使用 for 循环来计算数字的指数。

现在让我们使用 while 循环来执行相同的操作。

在 C++ 中使用 while 循环计算指数而不使用 pow() 函数

使用 while 循环计算数字指数的基本思想与 for 循环相同。 唯一改变的是计算重复次数的方法。

看看下面给出的代码。

在 while 块中，e 的初始值是用户输入的指数，每一步，该值减一。 最后，当 e 减少到 0 时，循环终止。

#include<iostream>
#include<math.h>
#include<stdio.h>

using namespace std;
int main()
{
    int i, e, b, ans=1;

    cout << "Enter the base: " << endl;
    cin >> b;

    cout << "Enter the exponent: " << endl;
    cin >> e;


    /*logic to calculate power*/

    while(e!=0){
        ans = ans * b;
        --e;
    }

    cout << "The solution is: " << ans;

    return 0;
}

输出结果:

Enter the base:
5
Enter the exponent:
4
The solution is: 625

您可以看到 while 循环内的语句将 b 与 ans 相乘，并将结果存储在变量 ans 本身中，其方式与 for 循环的情况相同。

这是变量 ans 在每次迭代中包含的内容。

e = 4
ans = 1 * 5
ans = 5

e = 3
ans = 5 * 5
ans = 25

e = 2
ans = 25 * 5
ans = 125

e = 1
ans = 125 * 5
ans = 625

因此，这就是您可以在不使用 pow() 函数的情况下使用 while 循环计算数字指数的方法。

如果您还想对输出执行任何其他操作，您可以按照下面的示例所示进行操作。

#include<iostream>
#include<math.h>
#include<stdio.h>

using namespace std;
int main()
{
    int i, e, b, ans=1;

    cout << "Enter the base: " << endl;
    cin >> b;

    cout << "Enter the exponent: " << endl;
    cin >> e;


    /*logic to calculate power*/

    while(e!=0){
        ans = ans * b;
        --e;
    }

    /*adding 500 to the result*/

    ans = ans + 500;
    cout << "The solution after addition is: " << ans;

    return 0;
}

输出结果如下:

Enter the base:
5
Enter the exponent:
4
The solution after addition is: 1125

请注意 ，当基数和指数为整数时，建议使用这些方法计算指数。 对于浮点值，使用 pow() 函数。

这两种方法的复杂度都是 O(n)，n 是指数。

到目前为止，我们已经讨论了求一个数的幂的常用循环方法。 现在让我们讨论一个非常有趣的递归解决方案来做同样的事情。

在 C++ 中不使用 pow() 函数使用递归计算指数

看看下面给出的代码。

#include<iostream>
#include<math.h>
#include<stdio.h>

using namespace std;

int product(int a, int b)
{
    if(b)
        return (a + product(a, b-1));
    else
        return 0;
}

int calculate_power(int x, int y)
{
    if(y)
        return product(x, calculate_power(x, y-1));
    else
        return 1;
}

int main()
{
    cout << calculate_power(5, 2);
    getchar();
    return 0;
}

输出结果:

25

此代码使用两个函数，用于重复乘法的 product 和计算 x^y 的 calculate_power。

当主块运行时，控制首先转到 calculate_power 函数。 在此函数内部，如果指数 y 的值为 0，则控制转到 if 块，函数返回 1。

否则，控制转到 if 块，函数调用 product 函数，递归调用 calculate_power 函数。 此外，在产品功能内部，当控制转到 if 块时，产品功能将再次递归调用。

下面可以帮助您更好地理解这段代码的工作原理。

Coming down:                       calculate_pow(5,2)
                                          ↓
                            product(5, calculate_pow(5,1))
                                              ↓
                                           product(5, calculate_pow(5, 0)
                                                              ↓
                                                           return 1


Going back, Step 1:                 product(5, 1)
                                         ↓
                                return 5 + product(5, 0)
                                                 ↓
                                              return 0
                                                 ↓
                                            return 5+0 = 5


Going back, Step 2:                 product(5, 5)
                                           ↓
                                         5 + product(5, 4)
                                                   ↓
                                                5 + 5 + product(5, 3)
                                                            ↓
                                                       5 + 5 + 5 + product(5, 2)
                                                                       ↓
                                                            5 + 5 + 5 + 5 + product(5, 1)
                                                                              ↓
                                                                      5 + 5 + 5 + 5 + 5
                                                                              ↓
                                                                              25

这就是递归计算一个数的幂的方式，时间复杂度为 O(n) ，其中 n 是指数。

总结

在本文中，我们讨论了如何在不使用 C++ 中的 pow() 函数的情况下计算数字的指数。 我们使用 for 和 while 循环来执行此操作，还了解了一旦我们获得数字的幂后如何进一步执行其他计算。

最有趣的是，我们讨论了计算一个数的幂的递归解决方案，还通过详细的流程图了解了该代码的工作原理。