Request a callback

or Chat with us on

# Power Function in C++ – Everything You Need to Know

Internship Assurance
DevOps & Cloud Engineering

In the C++ language, the cmath header is a crucial tool. It houses a collection of built-in functions that are essential for a variety of mathematical operations. These operations include finding the square root of a number and calculating the power of a number. In this article, we will delve into the power function, a key component of this header file. This function allows us to perform a range of operations on numbers, such as calculating the exponent of a given number x raised to another number y. This function, also known as the Power Function in C++, is a fundamental tool in any C++ programmer’s arsenal.

## Introduction

The power refers to the number of times a number is multiplied by itself, meaning the number you get when raising a number to an exponent, whereas an exponent can be defined as the number of times the number is used in multiplications.

```For Example 2 ^ 4 =  2 * 2 * 2* 2 = 16 ```

When it comes to calculating the power of a number, we have two options: manual calculation or using the pow function in C++. For manual calculation, we can initialise a variable called ‘answer’ as one and then multiply it by the base exponent number of times. This method is effective when the exponent is a positive integer. However, for more complex calculations, such as raising a number to any real number, we turn to the pow() function in C++. This function, defined in the <cmath> header file, is a practical and efficient solution for such scenarios.

Before using the pow function, you must include the <cmath> header file in your program.

## Syntax

The syntax of the power function in C++ language is as follows

```pow(double base, double exponent); ```

## Parameters

There are the two parameters in the pow() functions

• Base: This is the base value whose power will be calculated by us.
• Exponent: This is the exponent parameter where we pass the exponent value.

## pow() Return Value

The return value of the Power function in C++ is the result of the base, which is raised to the power exponent. It will be a double data type.

• If our base is zero, then the return value of the pow() function will be 0.0 since zero raised to the power of any number gives zero.
• If our exponent is zero, Then the return value of the pow() function will be 1.0. Any number raised to the power of zero gives me one.

## Example of pow() function

Input:  3.0, 5.0

Output: 32.00

Explanation: pow(3.0,5.0) executes  2.0 raised to the power 5.0, which equals 32

Input:  5.0, 2.0

Output:  25.00

Explanation: pow(5.0, 2.0) executes 5.0 raised to the power 2.0, which equals 25

The following program demonstrates the pow() function example in C++

Program

```#include <bits/stdc++.h> using namespace std; int main() { double x = 10.2, y = 5.3; double result = pow(x, y); cout << fixed << setprecision(2) << result << endl; return 0; } ```

Output

```221605.69 ```
Internship Assurance
DevOps & Cloud Engineering

## Working of pow() function with Integers

The pow() function takes double arguments as the parameters and returns a double value. However, the pow function does not always work for integers. For example, pow(5,2).  It gives 24 outputs on some compilers and works fine for some other compilers. But (5,2) gives 25 as an output.

We can also use the round function with the pow() function to assign it to the same integer value.

• It is because 5 ^ 2 might be stored as 9999999 or 25.0000001 because the return is double the pow function. When assigned to int,  25.0000000001 becomes 25, but 24.9999999 will give output 24.
• We can get an accurate answer by adding in the format. We can add 1e-9 or 0.000000001 to the result of the int. For example, (int) (pow(5,2)+1e-9) will give the correct answer (25, in the above example).

The following program demonstrates the behaviour of the pow function with integers.

Program

```#include <bits/stdc++.h> using namespace std; int main() { int a, b;  a = (int)(pow(5, 2) + 0.5); b = round(pow(5,2)); cout << a << endl << b ;  return 0; } ```

Output

```25 25 ```

## pow() with Different Arguments

In this section, we will be working on the pow() function with different arguments (double, float, and integers arguments) throughout the entire program.

The following program demonstrates the pow function with arguments

Progarm

```#include <iostream> #include <cmath> using namespace std;  int main () {  long double base = 343; int exponent = 6; long double result1 = pow(base, exponent); cout << result1 << endl;  int int_base = 2, int_exponent = 6; double result2; result2 = pow(int_base, int_exponent); cout << result2 << endl;  int int_base2 = 2, int_exponent2 = -6; double result3; result3 = pow(int_base2, int_exponent2); cout << result3 << endl;  float float_base = 1.1, float_exponent = 2.2, result4; result4 = pow(base, exponent); cout << result4 << endl;  return 0;  } ```

Output

```1.62841e+15 64 0.015625 1.62841e+15 ```

In the above example, We demonstrate the pow function with different arguments.

• In the first example, the type of our base is long double,  and the type of our exponent is an integer value.
• In the second example, the data type of our base is int, The exponent is a positive integer.
• In the third example, the data type of our base in the exponent is a negative integer value.
• In the Fourth example, the data type of our base and exponent is float.

## Conclusion

In this article, we learned about the pow() function, which calculates the value of a number x raised to the power of y. The pow function takes in double arguments and returns the answer of a data type value. This function is very useful in various mathematical and scientific computations. Whether you choose to create your own functions or use a library function like pow(). Understanding how to perform exponentiation is essential for many programming tasks in C++ language.

FAQs
A power function in C++ calculates the result of raising a base number to a given exponent. It is commonly used to raise a number to a certain power.
The syntax for using the pow() function in C++ language is here.               #include <cmath>              double result = pow(base,exponent) ;
Yes, you can create your own pow function in C++ language. It is common to implement using the pow function using the loop or recursion.
Yes, the pow() function can also handle negative exponents in the C++ language. It calculates the result as the reciprocal of the base raised to the positive exponent.

Book a free counselling session

Get tailored program recommendations

Explore industry trends and job opportunities

Popular

Data Science

Technology

Finance

Management

Future Tech

Upskill with expert articles
View all
Hero Vired is a leading LearnTech company dedicated to offering cutting-edge programs in collaboration with top-tier global institutions. As part of the esteemed Hero Group, we are committed to revolutionizing the skill development landscape in India. Our programs, delivered by industry experts, are designed to empower professionals and students with the skills they need to thrive in today’s competitive job market.

Blogs
Reviews
Events
In the News