How to Raise to a Power in C

Q: Does C have an exponentiation operator?

No. The ^ operator is bitwise XOR for integer operands. Use pow() from <math.h> for powers.

Q: How do I raise an integer to a power?

You can pass integer arguments to pow(); they are converted to floating-point values and the result is a double. If you need an integer result, verify that it fits the chosen integer type and convert deliberately.

Q: How do I square a number in C?

Use pow(x, 2.0), or multiply the value by itself with x * x. Direct multiplication is often clearer for a simple square.

How to Raise to a Power in C

To raise a number to a power in C, use the standard library function pow(). For example, pow(2.0, 3.0) returns 8.0. The ^ symbol is not exponentiation in C: it performs bitwise exclusive OR on integer operands. The guide below shows how to call pow(), build and run a small program, and handle common type and precision issues.

What You’ll Need

A C compiler, such as GCC, Clang, or a compiler included with an IDE.
A source file ending in .c.
The standard math header, <math.h>, which declares pow().
If you use GCC on a typical Unix-like system, add -lm when linking. Other compilers and environments may link the math library automatically or use different settings.

Step-by-Step

Include the math header. Add #include <math.h> near the top of your source file. This gives the compiler the declaration for pow(), so it can check the call correctly.
Choose the base and exponent. The first argument is the number being raised, and the second is the exponent. Both arguments are passed as floating-point values; integer values are converted to double when passed. For instance, the base 5 raised to exponent 2 is written pow(5.0, 2.0).
Store the result as a floating-point value. The function returns a double. Assign it to a double variable if you need to use it later. The returned value may have a fractional part, even when the inputs look like whole numbers.
Print the result appropriately. Use %f with printf() to display a double. The printf() format %.0f displays no digits after the decimal point, but it only changes how the value is shown; it does not convert the result to an integer.
Compile and link the program. With GCC on many Linux and other Unix-like systems, a command such as gcc power.c -o power -lm compiles the file and links the math library. Put -lm after the source or object files so the linker can resolve the math functions. If your environment does not need that option, follow its compiler instructions.
Run and check a simple example. Try base 2 and exponent 3; the result should display as 8. Use a known small example first to verify that the program builds and that the arguments are in the intended order.

Here is a complete program:

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

int main(void)
{
    double base = 2.0;
    double exponent = 3.0;
    double result = pow(base, exponent);

    printf("%.0f to the power of %.0f is %.0f\n",
           base, exponent, result);
    return 0;
}

Save it as power.c. With GCC on a system that requires explicit math-library linking, build it with gcc power.c -o power -lm, then run the generated program. It should print 2 to the power of 3 is 8.

Common Mistakes

Using ^ for powers: In C, 2 ^ 3 means bitwise XOR, not 2 raised to 3. Use pow(2.0, 3.0) for exponentiation.
Forgetting <math.h>: Without the header, the compiler may report a missing or incorrect declaration. Include it in the source file that calls pow().
Omitting the link option when required: A build can compile but fail at the linking stage with an unresolved reference to pow. On GCC systems that need it, add -lm at the end of the command.
Expecting an integer return: pow() returns double, not int. Assigning its result directly to an integer discards any fractional part through conversion, which may produce an unexpected value.
Assuming decimal results are always exact: Floating-point arithmetic has finite precision. Some values may be represented approximately, so a printed result can include a small rounding difference.

Tips

Write floating-point constants clearly, such as 2.0, to make the intended numeric type easy to see.
Use pow() when the exponent may be fractional or is not known until the program runs. It handles general real-valued exponentiation within the limits of floating-point math.
For a small, fixed nonnegative integer exponent, multiplication can be simpler: double square = x * x;. This avoids a function call and makes the operation explicit.
For integer powers where overflow behavior matters, choose an appropriate integer type and check the multiplication bounds. C integer overflow is not a safe substitute for a wider result.
When comparing computed floating-point values, consider a tolerance rather than relying on exact equality, particularly when calculations involve several operations.

Troubleshooting

“Undefined reference to pow” or a similar linker error: The source compiled, but the linker did not find the math function. With GCC on a system that requires it, put -lm after your source or object files, for example gcc power.c -o power -lm. IDEs may have a separate linker configuration.

“Implicit declaration” or an unknown function warning: Check that #include <math.h> is present before the function is used, and compile the file as C. Fix warnings rather than suppressing them; a missing declaration can lead to incorrect assumptions about types.

The answer is not a whole number: Check whether the exponent produces a fractional result and whether your variable is a double. If you only want a rounded display, use a suitable formatting precision; if you need an integer, decide how rounding should work before converting.

The result is unexpected for negative inputs: A negative base raised to a fractional exponent may not have a real-valued result. Also check the sign and order of the arguments: pow(base, exponent), not the reverse. For special cases or invalid domains, math functions can report errors through the floating-point environment and may return a non-finite value, so check your program’s inputs when those cases are possible.

Frequently Asked Questions

Does C have an exponentiation operator?

No. The ^ operator is bitwise XOR for integer operands. Use pow() from <math.h> for powers.

How do I raise an integer to a power?

You can pass integer arguments to pow(); they are converted to floating-point values and the result is a double. If you need an integer result, verify that it fits the chosen integer type and convert deliberately.

Do I always need to add `-lm`?

No. Some compilers and environments link the math library automatically. GCC on many Unix-like systems requires -lm; if linking fails with an unresolved pow reference, try adding it after the source or object files.

How do I square a number in C?

Use pow(x, 2.0), or multiply the value by itself with x * x. Direct multiplication is often clearer for a simple square.

Can `pow()` calculate a negative exponent?

Yes. A negative exponent generally gives the reciprocal power, such as pow(2.0, -3.0), which is 0.125. The result is still a double.

Further reading: cppreference. Details can change, so check the official page for anything that matters to you. Spotted a mistake? Tell us. How we write an answer.