Correct Format Specifier for double in printf in C

By the end of this page, you will understand how printf handles double values in C, when %f and %lf are valid, and why printf and scanf behave differently for floating-point types. You will also see common mistakes, practical examples, and a small project to reinforce the idea.

In C, the correct and standard format specifier for printing a double with printf is %f.

For printf-style functions:

• %f prints a floating-point value
• double arguments are expected for %f
• %lf in printf is typically treated the same as %f by modern compilers and libraries, but the important thing to learn is that %f is the normal specifier for double in printf

Why this happens

The reason is based on default argument promotions in variadic functions like printf.

When you pass arguments to printf, there is no fixed parameter type information for the extra arguments, so C applies promotions:

• float becomes double

Think of printf as a display clerk who receives all decimal numbers in one standard delivery box: double.

Even if you send a float, it gets repackaged into a double before arriving. So the clerk expects the %f label when printing normal floating-point values.

Now think of scanf as a storage clerk who must place the value into the correct size box in memory:

• %f means “store into a float*”
• %lf means “store into a double*”

So:

• printf cares about the promoted value type it receives
• scanf cares about the exact pointer type where it will write the value

Core syntax

printf("%f", value);

For a double:

double d = 1.4;
printf("%f", d);

Example: printing a double

#include <stdio.h>

int main(void)
{
    double d = 1.4;
    printf("%f\n", d);
    return 0;
}

Output:

1.400000

By default, %f prints 6 digits after the decimal point.

Example: controlling precision

#include <stdio.h>

int main
{
     pi = ;

    (, pi);
    (, pi);
    (, pi);

     ;
}

Consider this example:

#include <stdio.h>

int main(void)
{
    double d = 1.4;
    printf("Value = %.2f\n", d);
    return 0;
}

Step-by-step

1. A double variable is created

double d = 1.4;

• d stores a floating-point number
• its type is double

2. printf is called

printf("Value = %.2f\n", d);

The format string contains:

• Value = -> printed as plain text
• %.2f -> print a floating-point value with 2 digits after the decimal point

Floating-point output appears in many real programs.

Common examples

• Finance tools: printing totals, tax, interest, or exchange rates
• Sensor applications: showing temperature, pressure, or voltage readings
• Scientific programs: printing measurements and computed results
• Game development: displaying coordinates, speed, or frame timing
• APIs and logs: recording decimal values for debugging or monitoring

Example: temperature logger

#include <stdio.h>

int main(void)
{
    double temperature = 23.6789;
    printf("Temperature: %.1f C\n", temperature);
    return 0;
}

Example: price display

#include <stdio.h>

int main(void)
{
    double price = 19.99;
    printf("Price: $%.2f\n", price);
    return 0;
}

In these cases, choosing the right precision is often as important as choosing the right format specifier.

In real codebases, developers rarely use printf with just bare %f everywhere. They usually combine it with formatting decisions, validation, and readability patterns.

Common patterns

Fixed precision for user-facing output

printf("Average response time: %.2f ms\n", avg);

This avoids noisy output like many unnecessary decimal places.

Debug logging

printf("x=%f, y=%f, z=%f\n", x, y, z);

Useful in small tools or command-line programs.

Guarding calculations before printing

if (count == 0)
{
    printf("No data available.\n");
    return 0;
}

printf("Average: %.2f\n", total / count);

This is a simple guard clause pattern: check invalid conditions early.

Input/output pairing

Developers often read a double with scanf("%lf", &value) and later print it with .

1. Mixing up printf and scanf

This is the most common mistake.

Wrong idea

• %lf must always be used for double

That is not the rule.

Correct rule

• printf uses %f for double
• scanf uses %lf for double

2. Using %d for a floating-point value

Broken code:

double d = 1.4;
printf("%d\n", d);

Why it is wrong:

• %d is for int
• d is a

printf vs scanf for floating-point values

%f vs in

Quick rules

• Use %f to print a double with printf
• float also uses %f in printf
• Use %lf to read a double with scanf
• Use %f to read a float with scanf

Common syntax

printf("%f", d);
printf("%.2f", d);
printf("%e", d);
printf("%g", d);

Examples

double d = 1.4;
printf("%f\n", d);    // 1.400000
printf("%.1f\n", d);  
(, d);  

Is %lf wrong in printf?

In practice, %lf is treated the same as %f in printf on standard C implementations. But %f is the usual and clearer choice for printing a double.

Why does scanf use %lf for double but printf does not?

Because printf receives promoted arguments, while scanf writes into memory through pointers and must know the exact destination type.

Can I print a float using %f in printf?

Yes. A float is promoted to double when passed to printf, so %f is correct.

What does print by default?

• printf format specifiers- Understanding%d, %s, %c, %f`, and others helps you print values correctly.
• scanf format specifiers- Closely related because%fand%lf` differ significantly when reading input.
• default argument promotions - Explains why float becomes double in variadic functions like printf.
• float vs double - Helps you understand precision and storage differences between floating-point types.
• variadic functions - printf is variadic, which is why promotions affect how arguments are handled.
• precision in printf - Useful for controlling how many digits appear after the decimal point.
• scientific notation formatting - Related to %e and %g when %f is not the best display format.