setprecision() Function in C++ with Examples

What is setprecision in C++?

setprecision () in C++ is part of the <iomanip> library, which allows you to control the number of significant digits displayed for floating-point numbers when outputting to the console. It manipulates the output format to ensure the numbers are displayed with the desired precision.

It takes an integer parameter n specifying the number of significant digits to display. It doesn't round the number itself; instead, it dictates how many digits, including those before and after the decimal point, will be displayed.

Syntax of setprecision in C++

The basic syntax looks like this:

• setprecision(int n)

Where n is the number of digits to be displayed, which is either the total significant digits or digits after the decimal point, depending on the combination with other flags. Here are a few more things to remember from the beginning:

• Setprecision C++ only changes the way numbers are displayed, not how they are stored in memory
• The effect is persistent on the stream until you explicitly change it
• Without a formatting flag like fixed, it counts significant digits, not decimal places

Become a Full Stack Developer in Just 9 Months!AI-Powered Full Stack Developer ProgramEXPLORE COURSE

How setprecision Works With Fixed and Scientific?

This is the part that trips up most learners. Set precision C++ does not behave the same way in every context. Its output depends entirely on which formatting mode the stream is in.

Without fixed: Significant Digits Mode

By default, setprecision(n) affects the total number of significant digits after the decimal point, not the whole number. It counts from the first non-zero digit, so setprecision(3) on 0.00456789 gives you 0.00457, not 0.005.

With fixed: Decimal Places Mode

When you add fixed to the stream before calling setprecision C++, the behavior shifts completely. Now, it can control how many digits to display after the decimal point, regardless of the number's size. It is used for prices, totals, percentages, and other numeric data that must have the same number of decimal places.

With scientific: Scientific Notation Mode

Pair it with scientific notation, and the precision applies to the digits after the decimal in the scientific notation output. How it affects scientific notation in C++ makes it a strong choice for engineering applications, physics simulations, and sensor data logging, where values span several orders of magnitude.

From C++ to Java and Beyond! Take your programming skills to the next level with our Java Certification Course. Join Now!

Examples of setprecision in C++

Here are three examples demonstrating the usage of setprecision in C++:

Example 1: Basic Precision Adjustment

In this code, setprecision is used to control the total number of significant digits displayed for a floating-point number.

#include <iostream>
#include <iomanip>
using namespace std;
int main() {
double num = 123.456789;
// Set precision to 4 significant digits
cout << "Precision 4: " << setprecision(4) << num << endl;
// Set precision to 6 significant digits
cout << "Precision 6: " << setprecision(6) << num << endl; 
return 0;
}

Output:

• Precision 4: 123.5
• Precision 6: 123.457

Example 2: Using fixed with setprecision

In this example, setprecision is combined with the fixed manipulator to specify the exact number of decimal places.

#include <iostream>
#include <iomanip>
using namespace std;
int main() {
double num = 123.456789;
// Use fixed to control decimal places, set precision to 2 decimal places
cout << fixed << setprecision(2) << num << endl;
// Use fixed to control decimal places, set precision to 4 decimal places
cout << fixed << setprecision(4) << num << endl;
return 0;
}

Output:

• 123.46
• 123.4568

Example 3: Using scientific with setprecision

Here, setprecision is used with the scientific manipulator to control the number of significant digits displayed in scientific notation.

#include <iostream>
#include <iomanip>
using namespace std;
int main() {
double num = 12345.6789;
// Use scientific notation and set precision to 4 significant digits
cout << scientific << setprecision(4) << num << endl;
// Use scientific notation and set precision to 6 significant digits
cout << scientific << setprecision(6) << num << endl; 
return 0;
}

Output:

• 1.2346e+04
• 1.234568e+04

Common Mistakes When Using setprecision in C++

Even developers who have been working with C++ for years trip over setprecision C++ from time to time. Most of the issues come from how it interacts with other iostream settings, rather than the function itself.

Mistake 1: Forgetting <iomanip>

It's easy to write a quick cout << setprecision(3) and then wonder why the compiler is suddenly angry. That's because setprecision() is in <iomanip> and not <iostream>.

When you forget this inclusion, you will receive a cryptic error and could waste time in the wrong place. A good principle to follow is: add #include <iomanip> before formatting manipulators are used.

Mistake 2: Expecting “2” to Mean “Two Decimal Places”

A lot of people assume setprecision(2) will always produce something like 12.34. In reality, without a fixed point, it controls the total number of significant digits, not the number of decimals. That is why a number such as 1234.5678 can suddenly show up as 1.2e+03.

When you want to control decimal places in a calculation (such as a price or percentage), be sure to combine fixed with setprecision in C++ so the output matches what you have in mind.

Mistake 3: Forgetting That the Setting Sticks

Another surprise is how long the setting lasts. Once you apply setprecision() to a stream, it uses that precision for all subsequent floating-point values. You might set two decimal places for one print, then wonder why numbers printed much later are still rounded the same way. 

To avoid this, either reset the formatting when you are done or store and restore the original precision and flags so you know exactly what state the stream is in.

Mistake 4: Treating Formatting as Real Rounding

On the surface, it looks like setprecision C++ is “rounding” your values. The output changes, after all. Under the hood, nothing about the stored number is touched. The variable keeps its full precision; only the printed version is shortened.

If your business logic depends on rounded values, you need to call functions like round(), floor(), or ceil(), then print those results. Relying on formatted output alone can hide calculation errors.

Mistake 5: Using setprecision on Integers

Finally, there is the use of setprecision() on integer types. Since it only affects floating‑point formatting, applying it to an int or long will not change anything you see on screen.

That can make you think it is “not working” when in fact it is simply not meant for that job. For lining up integer columns or padding values, reach for setw and related formatting tools instead of setprecision().

Strong knowledge of C, debugging, and system design creates an excellent foundation for software engineering. Learn how modern applications are built using JavaScript, APIs, databases, cloud technologies, and AI tools through the AI-Powered Full Stack Developer Program.

Setprecision vs fixed vs setw: C++ Output Formatting Comparison

These three tools all affect how output looks, but each controls something completely different. Understanding the distinction is essential for getting setprecision C++ output formatting right.

Manipulator	What It Controls	Best Used For
setprecision(n)	Significant digits (default) or decimal places (with fixed)	Float precision, scientific output
fixed	Forces decimal-point notation; activates decimal-place mode for setprecision	Currency, financial reports, fixed output
setw(n)	Minimum field width; pads output with spaces or a fill character	Column alignment in tables and reports

Get the Coding Skills You Need to SucceedAI-Powered Full Stack Developer ProgramExplore Program