C Math pow() Function

What You’ll Learn

The pow() function raises a base to an exponent—it computes base^exponent. Use it for squares, cubes, compound growth, square roots via fractional exponents, and any general power calculation in C.

Definition and Usage

Exponentiation repeats multiplication: 2³ = 2 × 2 × 2 = 8. pow(2.0, 3.0) computes that in one call.

Both arguments are double. The result is also double, so expect normal floating-point rounding. For integer powers of small integers, a loop may be exact—but pow handles fractional and negative exponents too.

📝 Syntax

Standard C declaration:

double pow(double base, double exponent);

Related variants

float powf(float base, float exponent);             /* <math.h> */
long double powl(long double base, long double exponent); /* <math.h> */

Parameters

• base — the number being raised to a power.
• exponent — the power to raise the base to.

Return Value

• baseexponent as double.
• pow(2.0, 3.0) returns 8.0.
• pow(x, 0.0) returns 1.0 for any x, including 0.
• Negative base with non-integer exponent → NaN (not a real result).

Headers and linking

• #include <math.h>
• Compile: gcc pow.c -std=c11 -o pow -lm
• Large results may overflow to INFINITY; check with isinf() if needed.

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. pow is the go-to function when you need a general exponent, not just squares or natural exponentials.

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

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

    printf("%.0f ^ %.0f = %.0f\n", base, exponent, result);

    return 0;
}

2 ^ 3 = 8

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

int main(void) {
    double x = 9.0;

    printf("x = %.0f\n", x);
    printf("pow(x, 0.5) = %.1f\n", pow(x, 0.5));
    printf("sqrt(x)     = %.1f  (preferred)\n", sqrt(x));

    return 0;
}

x = 9
pow(x, 0.5) = 3.0
sqrt(x)     = 3.0  (preferred)

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

int main(void) {
    double result = pow(2.0, -2.0);

    printf("2^(-2) = %.2f\n", result);
    printf("1/4    = %.2f\n", 1.0 / 4.0);

    return 0;
}

2^(-2) = 0.25
1/4    = 0.25

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

int main(void) {
    double principal = 1000.0;
    double rate = 0.05;
    int years = 10;
    double future = principal * pow(1.0 + rate, (double)years);

    printf("Principal: $%.0f at %.0f%% for %d years\n",
           principal, rate * 100, years);
    printf("Future value: $%.2f\n", future);

    return 0;
}

Principal: $1000 at 5% for 10 years
Future value: $1628.89

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

int main(void) {
    double x = 2.0;

    printf("x = %.1f\n", x);
    printf("exp(x)        = %.4f\n", exp(x));
    printf("pow(M_E, x)   = %.4f\n", pow(M_E, x));
    printf("pow(2.0, x)   = %.4f  (2^x, not e^x)\n", pow(2.0, x));

    return 0;
}

x = 2.0
exp(x)        = 7.3891
pow(M_E, x)   = 7.3891
pow(2.0, x)   = 4.0000  (2^x, not e^x)

🚀 Common Use Cases

• Polynomials and geometry — areas, volumes (e.g. r², side³).
• Compound interest — pow(1 + rate, years).
• Scientific formulas — inverse-square laws, half-life scaling.
• Unit conversion — powers of ten for metric prefixes.
• Graphics — gamma correction, distance falloff curves.

📝 Notes

• Results are floating-point—small rounding errors are normal (e.g. pow(2, 10) may not print exactly 1024 in all formats).
• pow(x, 0) returns 1.0 even when x is 0 (per C standard).
• Negative base + non-integer exponent → NaN.
• pow(0, negative) → infinity (division by zero).
• Prefer exp, sqrt, cbrt when they match your need.
• Link with -lm on GCC/Clang Unix-like builds.

⚡ Optimization

pow() is slower than specialized functions like exp or sqrt because it handles the general case. For small integer exponents, a simple loop (result *= base) can be faster. For squaring, x * x beats pow(x, 2). Profile hot paths before micro-optimizing.

💡 Best Practices