C Math round() Function

What You’ll Learn

The round() function rounds a floating-point number to the nearest integer. Values exactly halfway between two integers round away from zero. Use it when you want classic “closest whole number” behavior, not always-down or always-up rounding.

Definition and Usage

round(x) picks the integer closest to x. If x is already whole, it returns unchanged (as a double, e.g. 5.0).

For ties at exactly .5, C rounds away from zero: round(2.5) = 3.0 and round(-2.5) = -3.0. This is not banker's rounding (round-to-even).

📝 Syntax

Standard C declaration:

double round(double x);

Related variants

float roundf(float x);             /* <math.h> */
long double roundl(long double x); /* <math.h> */

Parameters

• x — the floating-point value to round.

Return Value

• Nearest integer to x, as double.
• round(15.67) returns 16.0.
• round(15.32) returns 15.0.
• Halfway cases round away from zero.

Headers and linking

• #include <math.h>
• Compile: gcc round.c -std=c11 -o round -lm
• For round-to-even ties, see nearbyint() / rint().

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Rounding shows up everywhere—prices, scores, pixel coordinates, and statistics.

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

int main(void) {
    double number = 15.67;
    double rounded = round(number);

    printf("Original: %.2f\n", number);
    printf("Rounded:  %.0f\n", rounded);

    return 0;
}

Original: 15.67
Rounded:  16

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

int main(void) {
    printf("round( 2.5) = %.0f\n", round(2.5));
    printf("round(-2.5) = %.0f\n", round(-2.5));
    printf("round( 3.5) = %.0f\n", round(3.5));
    printf("round(-3.5) = %.0f\n", round(-3.5));

    return 0;
}

round( 2.5) = 3
round(-2.5) = -3
round( 3.5) = 4
round(-3.5) = -4

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

int main(void) {
    double x = -2.3;

    printf("x = %.1f\n", x);
    printf("round(x) = %.1f  (nearest)\n", round(x));
    printf("floor(x) = %.1f  (toward -inf)\n", floor(x));
    printf("ceil(x)  = %.1f  (toward +inf)\n", ceil(x));
    printf("trunc(x) = %.1f  (toward zero)\n", trunc(x));

    return 0;
}

x = -2.3
round(x) = -2.0  (nearest)
floor(x) = -3.0  (toward -inf)
ceil(x)  = -2.0  (toward +inf)
trunc(x) = -2.0  (toward zero)

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

int main(void) {
    double subtotal = 47.50;
    double tax_rate = 0.08;
    double total = subtotal * (1.0 + tax_rate);
    double rounded_total = round(total);

    printf("Subtotal: $%.2f\n", subtotal);
    printf("Total:    $%.2f\n", total);
    printf("Rounded:  $%.0f\n", rounded_total);

    return 0;
}

Subtotal: $47.50
Total:    $51.30
Rounded:  $51

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

int main(void) {
    double pixels = 127.6;
    int rounded_pixels = (int)round(pixels);

    printf("pixels = %.1f\n", pixels);
    printf("rounded_pixels (int) = %d\n", rounded_pixels);

    return 0;
}

pixels = 127.6
rounded_pixels (int) = 128

🚀 Common Use Cases

• Display formatting — show whole numbers from calculated decimals.
• Pixel coordinates — snap sub-pixel positions to nearest pixel.
• Statistics — report rounded averages or percentages.
• Game scores — nearest-integer health, damage, or timers.
• Survey results — round response averages for charts.

📝 Notes

• Returns double, not int—cast explicitly when needed.
• Halfway ties round away from zero (not round-to-even).
• round(2.5) = 3; round(-2.5) = -3.
• For always-down: floor. For always-up: ceil. For toward zero: trunc.
• NaN input → NaN output; ±∞ → ±∞.
• Link with -lm on GCC/Clang Unix-like builds.

⚡ Optimization

round() is fine for most code. If you only need truncation toward zero and the value is positive, (int)x may suffice (with range checks). In tight loops processing millions of values, profile before replacing round—correct rounding rules matter more than micro-seconds in most apps.

💡 Best Practices