**Problem Statement: **We have to write C++ programs/code which can effectively and efficiently calculate the power of any number.

There are mainly two prerequisites to calculate the power of any number which are:

**Base**(the number whose power, we have to calculate)**Exponent/Power**(the number up to which, power is to be calculated)

The mathematical expression to calculate the power of any number is as follows:

(a

^{b}) or (a ^ b); whereais called the base andbis called the power or exponent.

**Now we will perform this mathematical calculation of power through the following C++ code/programs.**

**Method 1:**

Using the ** pow() **function, It is a library function that is used to calculate the power in C++. In order to use the pow() function have to import or include this library

**<maths.h>**or

**<cmath>**in our C++ program/code.

```
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
int x, y;
// taking inputs for two Nos x & y
cin>>x>>y;
// calling the pow function
cout<<pow(x, y);
return 0;
}
```

**Output:**

5

4

625

**Method 2:**

In this method, we will design our own* power()* function to calculate the power in C++. For doing this fundamental knowledge of

*functions*and

*loops*(either

*for*loop or

*while*loop) in C++ is required. This method is known as the

**iterative method**to calculate power. The time complexity of this method to calculate power is

**O(N)**as the for loop will be executed N times which is quite slow.

```
#include<iostream>
using namespace std;
// defining the iterative power function
int power(int a, int n)
{
int val = 1;
for(int i = n; i > 0; i--)
val = val * a;
return val;
}
int main()
{
int x, y;
// taking inputs for two Nos x & y
cin>>x>>y;
// calling the iterative power function
cout<<power(x, y);
return 0;
}
```

**Output:**

5

3

125

**Also Read Basic Calculation Based Java Programs**

**Method 3:**

In this method, we will design our own ** power()** function to calculate the power in C++ using the

*while*loop. This method is also an

**iterative method**only to calculate the power. But the time complexity of this iterative method to calculate power is

**O(logN)**which is quite fast.

```
#include <iostream>
using namespace std;
// defining the optimized iterative power function
int power(int x, int y)
{
int val = 1;
while (y > 0)
{
// If y is odd then multiply x with val
if (y % 2 != 0)
val = val * x;
y = y / 2;
x = x * x;
}
return val;
}
int main()
{
int x, y;
// taking inputs for two Nos x & y
cin>>x>>y;
// calling the optimized iterative power function
cout<<power(x, y);
return 0;
}
```

**Output:**

7

5

16807

**Method 4:**

In this method, we will use the concept of *recursion* and try to design a ** power()** function in C++ that will calculate the power without using any

*for*loop or

*while*loop. This is known as the

**recursive**

**method**to calculate the power. But the time complexity of this recursive method is

**O(N)**which is quite slow as discussed above in method 2. In this method, we are simply dividing the calculations into two halves as the power() function is called two times within the return statement (two recursive calls).

```
#include<iostream>
using namespace std;
// defining the recursive power function
int power(int x, int y)
{
if(y == 0)
return 1;
else if(y % 2 == 0)
return (power(x, y / 2) * power(x, y / 2));
else
return (power(x, y / 2) * power(x, y / 2) * x);
}
int main()
{
int a, b;
// taking inputs for two Nos a & b
cin>>a>>b;
// calling the recursive power function
cout<<power(a, b);
return 0;
}
```

**Output:**

2

10

1024

**Method 5:**

In this method also we will use the concept of *recursion* and try to design a ** power() **function in C++ that will calculate the power. This is again a

**recursive**

**method**to calculate the power. But the time complexity of this recursive method is

**O(logN)**which is quite fast as discussed above in method 3. In this method, we are calling the power function only once within the function body (only one recursive call).

```
#include<iostream>
using namespace std;
// defining the optimized recursive power function
int power(int x, int y)
{
if(y == 0)
return 1;
int val = power(x, y/2);
if(y % 2 == 0)
return (val * val);
else
return (val * val * x);
}
int main()
{
int a, b;
// taking inputs for two Nos a & b
cin>>a>>b;
// calling the optimized recursive power function
cout<<power(a, b);
return 0;
}
```

**Output:**

3

5

243

**NOTE: **Till now whatever we have discussed, is valid or true only for the integral bases (i.e. -2, 0, 3, 5) and positive powers or exponents (i.e. 0, 1, 3, 4, 5).

**Bonus: Generalizing the power() function in C++**

Let’s extend our approach to design a ** power() **function that can calculate the power where bases can be

*floating-point*numbers and

*exponents*can be

*negative*. Let’s code it using the

*recursive method*. We can call it a generic method to calculate power in C++.

```
#include<iostream>
using namespace std;
// defining the generic recursive power function
float power(float x, int y)
{
float val;
if(y == 0)
return 1;
val = power(x, y / 2);
if (y % 2 == 0)
return val * val;
else
{
if(y > 0)
return x * val * val;
else
return (val * val) / x;
}
}
int main()
{
float a;
int b;
// taking inputs for two Nos a & b
cin>>a>>b;
// calling the generic recursive power function
cout<<power(a, b);
return 0;
}
```

**Output:**

9

3

729

A lot of valuable information at one place and in such an organized manner…

You provide very informative articles we are looking forward to these such articles in future