If you just want to round the number for output purposes, then the "%.2f" format string is indeed the correct answer. However, if you actually want to round the floating point value for further computation, something like the following works:

#include <math.h>

float val = 37.777779;

float rounded_down = floorf(val * 100) / 100;   /* Result: 37.77 */
float nearest = roundf(val * 100) / 100;  /* Result: 37.78 */
float rounded_up = ceilf(val * 100) / 100;      /* Result: 37.78 */

Notice that there are three different rounding rules you might want to choose: round down (ie, truncate after two decimal places), rounded to nearest, and round up. Usually, you want round to nearest.

As several others have pointed out, due to the quirks of floating point representation, these rounded values may not be exactly the "obvious" decimal values, but they will be very very close.

For much (much!) more information on rounding, and especially on tie-breaking rules for rounding to nearest, see the Wikipedia article on Rounding.

To round a double up to 2 decimal places, you can use:

#include <iostream>
#include <cmath>

int main() {
    double value = 0.123;
    value = std::ceil(value * 100.0) / 100.0;
    std::cout << value << std::endl; // prints 0.13
    return 0;
}

To round up to n decimal places, you can use:

double round_up(double value, int decimal_places) {
    const double multiplier = std::pow(10.0, decimal_places);
    return std::ceil(value * multiplier) / multiplier;
}

This method won't be particularly fast, if performance becomes an issue you may need another solution.

@Rashmi solution provides a nicely rounded display of a floating point value.
It does not change the value of the original number.

If one wants to round a floating point value to the nearest 0.01 use round()

#include <math.h>
double d = 1.2345;
d = round(d * 100.0)/100.0;

Notes:

Due to FP limitations, the rounded value may not be exactly a multiple of 0.01, but will be the closest FP number a given platform allows.

When d is very close to x.xx5, (x is various digits 0-9) d * 100.0 introduces a rounding in the product before the round() call. Code may round the wrong way.

You can use the following algorithm:

• multiply with 100
• round to nearest integer
• divide by 100

This algorithm has problems with big values that are very close to maximum representable as the multiplication may overflow.

Another approach is to use the stream manipulators as you would with std::cout but stream into a string, and then convert that string back into a floating point number. This is much slower, but has no caveat mentioned above.

Using recursion (which is going to be slow for some values of digits)

#include <math.h>
double my_round(double x, unsigned int digits) {
  if (digits > 0) {
    return my_round(x*10.0, digits-1)/10.0;
  }
  else {
    return round(x);
  }
}

A method likely to be somewhat faster, but which relies on a single call to the slow pow function:

#include <math.h>

double my_round(double x, unsigned int digits) {
    double fac = pow(10, digits);
    return round(x*fac)/fac;
}

An even faster method is to precompute a lookup table with the likely powers and use that instead of pow.

#include <math.h>

double fac[];  // population of this is left as an exercise for the reader

double my_round(double x, unsigned int digits) {
    return round(x*fac[digits])/fac[digits];
}

It is necessary that the number be stored in a variable as number = 136.25

But that would be the incorrect result. The precise result of number + number * 0.1 is 136.26787141. When you round that downwards to 2 decimal places, the number that you would get is 136.26, and not 136.25.

However, there is no way to store 136.26 in a float because it simply isn't a representable value (on your system). Best you can get is a value that is very close to it. You have successfully produced a floating point number that is very close to 136.26. If you cannot accept the slight error in the value, then you shouldn't be using finite precision floating point arithmetic.

If you wish to print the value of a floating point number up to limited number of decimals, you must understand that not all values can be represented by floating point numbers, and that you must use %.2f to get desired output.

Round float to 2 decimal places in C language?

Just like you did:

• multiply with 100
• round
• divide by 100