What is the C++ function to raise a number to a power?

How do I raise a number to a power?

2^1

2^2

2^3

etc...

pow() in the cmath library. More info here. Don't forget to put #include<cmath> at the top of the file.

std::pow in the <cmath> header has these overloads:

pow(float, float);
pow(float, int);
pow(double, double); // taken over from C
pow(double, int);
pow(long double, long double);
pow(long double, int);

Now you can't just do

pow(2, N)

with N being an int, because it doesn't know which of float, double, or long double version it should take, and you would get an ambiguity error. All three would need a conversion from int to floating point, and all three are equally costly!

Therefore, be sure to have the first argument typed so it matches one of those three perfectly. I usually use double

pow(2.0, N)

Some lawyer crap from me again. I've often fallen in this pitfall myself, so I'm going to warn you about it.

In C++ the "^" operator is a bitwise XOR. It does not work for raising to a power. The x << n is a left shift of the binary number which is the same as multiplying x by 2 n number of times and that can only be used when raising 2 to a power, and not other integers. The POW function is a math function that will work generically.

Use the pow(x,y) function: See Here

Just include math.h and you're all set.

You should be able to use normal C methods in math.

#include <cmath>

pow(2,3)

if you're on a unix-like system, man cmath

Is that what you're asking?

Sujal

While pow( base, exp ) is a great suggestion, be aware that it typically works in floating-point.

This may or may not be what you want: on some systems a simple loop multiplying on an accumulator will be faster for integer types.

And for square specifically, you might as well just multiply the numbers together yourself, floating-point or integer; it's not really a decrease in readability (IMHO) and you avoid the performance overhead of a function call.

I don't have enough reputation to comment, but if you like working with QT, they have their own version.

    #include <QtCore/qmath.h>
    qPow(x, y); // returns x raised to the y power.

Or if you aren't using QT, cmath has basically the same thing.

    #include <cmath>
    double x = 5, y = 7; //As an example, 5 ^ 7 = 78125
    pow(x, y); //Should return this: 78125
    

if you want to deal with base_2 only then i recommend using left shift operator << instead of math library.

sample code :

int exp = 16;
for(int base_2 = 1; base_2 < (1 << exp); (base_2 <<= 1)){
std::cout << base_2 << std::endl;
}

sample output :

1	2	4	8	16	32	64	128	 256  512  1024  2048  4096  8192  16384  32768

#include <iostream>
#include <conio.h>

using namespace std;

double raiseToPow(double ,int) //raiseToPow variable of type double which takes arguments (double, int)

void main()
{
	double x; //initializing the variable x and i 
	int i;
	cout<<"please enter the number"; 
	cin>>x;
	cout<<"plese enter the integer power that you want this number raised to";
	cin>>i;
	cout<<x<<"raise to power"<<i<<"is equal to"<<raiseToPow(x,i);
}

//definition of the function raiseToPower

double raiseToPow(double x, int power)
{
	double result;
	int i;
	result =1.0;
	for (i=1, i<=power;i++)
	{
		result = result*x;
	}
	return(result);
}

It's pow or powf in <math.h>

There is no special infix operator like in Visual Basic or Python

Many answers have suggested pow() or similar alternatives or their own implementations. However, given the examples (2^1, 2^2 and 2^3) in your question, I would guess whether you only need to raise 2 to an integer power. If this is the case, I would suggest you to use 1 << n for 2^n.

pow(2.0,1.0)
pow(2.0,2.0)
pow(2.0,3.0)

Your original question title is misleading. To just square, use 2*2.

Note that the use of pow(x,y) is less efficient than x*x*x y times as shown and answered here https://stackoverflow.com/a/2940800/319728.

So if you're going for efficiency use x*x*x.

First add #include <cmath> then you can use pow methode in your code for example :

pow(3.5, 3);

Which 3.5 is base and 3 is exp

int power (int i, int ow) // works only for ow >= 1
{ // but does not require <cmath> library!=)
    if (ow > 1)
    {
         i = i * power (i, ow - 1);
    }
    return i;
}

cout << power(6,7); //you can enter variables here

I am using the library cmath or math.h in order to make use of the pow() library functions that takes care of the powers

#include<iostream>
#include<cmath>

int main()
{
    double number,power, result;
    cout<<"\nEnter the number to raise to power: ";
    cin>>number;
    cout<<"\nEnter the power to raise to: ";
    cin>>power;
    
    result = pow(number,power);
    
    cout<<"\n"<< number <<"^"<< power<<" = "<< result;

	return 0;
}

use pow() function in cmath, tgmath or math.h library.

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
int a,b;
cin >> a >> b;
cout << pow(a,b) << endl; // this calculates a^b

return 0;
}

do note that if you give input to power as any data type other than long double then the answer will be promoted to that of double. that is it will take input and give output as double. for long double inputs the return type is long double. for changing the answer to int use, int c=(int)pow(a,b)

But, do keep in mind for some numbers this may result in a number less than the correct answer. so for example you have to calculate 5^2, then the answer can be returned as 24.99999999999 on some compilers. on changing the data type to int the answer will be 24 rather than 25 the correct answer. So, do this

int c=(int)(pow(a,b)+0.5)

Now, your answer will be correct. also, for very large numbers data is lost in changing data type double to long long int. for example you write

long long int c=(long long int)(pow(a,b)+0.5);

and give input a=3 and b=38 then the result will come out to be 1350851717672992000 while the correct answer is 1350851717672992089, this happens because pow() function return 1.35085e+18 which gets promoted to int as 1350851717672992000. I suggest writing a custom power function for such scenarios, like:-

long long int __pow (long long int a, long long int b)
{
long long int q=1;
for (long long int i=0;i<=b-1;i++)
{
q=q*a;
}

return q;
}

and then calling it whenever you want like,

int main()
{
long long int a,b;
cin >> a >> b;

long long int c=__pow(a,b);
cout << c << endl;

return 0;
}

For numbers greater than the range of long long int, either use boost library or strings.