What You Will Learn

• The general layout of a printf conversion: flags, width, precision and conversion letter
• How width right-justifies integers and why a too-small width never truncates
• How precision rounds floats and what the default of six decimals means
• How precision trims strings and how width pads them
• How to left-justify, zero-pad and take width from a variable with the star
• How to avoid classic mistakes such as float rounding surprises and format string bugs

Prerequisites

• The earlier lectures in this chapter on printf, conversion specifiers and escape sequences
• Knowledge of int, float, double and strings
• GCC installed (programs here were built with GCC 13 on Ubuntu 24.04 using -std=c11)

What Are printf Width and Precision in C?

A printf conversion has this general shape:

%[flags][width][.precision]conversion

Everything in square brackets is optional. The width is a whole number that sets the minimum number of characters the value occupies. The precision is a dot followed by a number, and its meaning depends on the type of the value.

printf Width with %d: Right-Justified by Default

When the width is larger than the number of characters in the value, printf adds blanks on the left, so numbers line up on their last digit. That is exactly what you want for a column of numbers. The program below wraps each result in square brackets so the blanks become visible.

#include <stdio.h>

int main(void)
{
    int a = 78, b = 9, c = 4096;

    printf("[%3d]\n", a);     /* shorter than width */
    printf("[%4d]\n", b);
    printf("[%4d]\n", c);     /* exactly equal      */
    printf("[%2d]\n", c);     /* longer: not cut    */
    printf("[%-6d]\n", a);    /* left-justified     */
    printf("[%06d]\n", a);    /* zero padded        */
    printf("[%+6d]\n", a);    /* sign always shown  */
    printf("[%08x]\n", 0xBEEFu); /* zero-padded hex   */

    int n = printf("%8d", 42);
    printf("  <- printf returned %d\n", n);
    return 0;
}

gcc -std=c11 -Wall -Wextra -o p_int p_int.c
./p_int

[ 78]
[   9]
[4096]
[4096]
[78    ]
[000078]
[   +78]
[0000beef]
      42  <- printf returned 8

Read the first four lines against the diagram. The value 78 has two characters but the width is three, so one blank appears. The value 9 has one character and a width of four, so three blanks appear. The value 4096 exactly fills %4d. And with %2d the width is too small, yet all four digits are printed. This is the behaviour that protects you from silently losing data in your output.

Flags That Work with Width

Zero padding is a favourite in embedded work: %08x prints a 32-bit register value with all eight hex digits, so 0xBEEF appears as 0000beef and columns of addresses stay aligned.

Using the Return Value to Measure Output

The last two lines of the program show something many students never notice: printf returns the number of characters it printed. With %8d the value 42 produced exactly 8 characters, six blanks and two digits. If you ever doubt how wide your output is, capture the return value and print it.

printf Width and Precision for Floats: %w.nf

For floating-point values the width counts the entire printed number: digits before the point, the point itself, digits after it and the sign. The precision, after the dot, decides how many digits appear after the point. If you omit the precision, printf uses six digits, which is why printf("%f", 3.14) shows 3.140000.

#include <stdio.h>

int main(void)
{
    float t = 8.0f, h = 5.9f;

    printf("[%4.1f] [%7.2f]\n", t, h);
    printf("[%4.1f] [%7.2f]\n", 25.3, 1635.92);
    printf("[%4.1f] [%7.2f]\n", 15.231, 65.875948);
    printf("[%f]\n", 3.14);               /* default: 6 decimals */
    printf("[%.0f] [%.0f] [%.0f] [%.0f]\n", 0.5, 1.5, 2.5, 3.5);
    printf("[%.1f] [%.1f] [%.2f]\n", 0.25, 0.35, 2.675);
    return 0;
}

gcc -std=c11 -Wall -Wextra -o p_float p_float.c
./p_float

[ 8.0] [   5.90]
[25.3] [1635.92]
[15.2] [  65.88]
[3.140000]
[0] [2] [2] [4]
[0.2] [0.3] [2.67]

Take the third line: [%4.1f] with 15.231 prints [15.2]. The width of four is exactly met by “15.2”, so no blanks. Then [%7.2f] with 65.875948 prints [ 65.88]. The precision of 2 rounded 65.875948 up to 65.88, and the remaining seven-character width added two blanks on the left.

Rounding Surprises You Should Know

The last two lines of the output look odd at first. %.0f turns 0.5 into 0, 1.5 into 2, 2.5 into 2 and 3.5 into 4. When a value sits exactly halfway, the C library on Linux rounds to the nearest even digit. And %.2f of 2.675 prints 2.67, not 2.68, because 2.675 cannot be stored exactly in binary; the stored value is a hair below 2.675. Neither is a bug. If you need decimal-style rounding for money, keep amounts in integers (for example paise or cents) and format them yourself.

float, double and the Right Conversion

In printf both float and double arguments use %f, because a float is promoted to double when passed through the variable argument list. A %lf is also accepted and means the same. This is different from scanf, where %f is for float and %lf is for double.

printf Width and Precision for Strings: %w.ns

For strings, the precision is a cut-off: only the first n characters are printed. Then the width pads the result. So a conversion such as %8.3s first trims the text to three characters, then right-justifies those three characters in eight columns, giving five blanks.

#include <stdio.h>

int main(void)
{
    const char *fw = "firmware";

    printf("[%3s]\n", fw);       /* width smaller: whole string */
    printf("[%10s]\n", "uart");  /* right-justified             */
    printf("[%-10s]\n", "uart"); /* left-justified              */
    printf("[%.3s]\n", fw);      /* precision: first 3 chars    */
    printf("[%8.3s]\n", fw);     /* width and precision         */
    printf("[%-8.3s]\n", fw);
    printf("[%.0s]\n", fw);      /* precision 0: nothing        */
    return 0;
}

gcc -std=c11 -Wall -Wextra -o p_str p_str.c
./p_str

[firmware]
[      uart]
[uart      ]
[fir]
[     fir]
[fir     ]
[]

The number of blanks is always the width minus the number of characters actually printed. In this case that is 8 minus 3, which is 5. Notice also that %3s with an eight-letter word printed the whole word, because width never truncates, while %.3s did cut it. Width and precision are different tools, and mixing them up is the most common mistake with strings.

Dynamic Width with the Star: Building Aligned Tables

Sometimes the width is not known until the program runs. Replace the number with * and pass the value as an extra argument before the thing being printed. The same works for precision. This is a printf feature only; scanf uses the star for something else, as you will see in the next lecture.

#include <stdio.h>

struct reading {
    const char *name;
    int adc;            /* 12-bit raw value, 0..4095 */
};

int main(void)
{
    struct reading ch[] = {
        { "VBAT",  3012 },
        { "TEMP",   871 },
        { "LIGHT",   45 },
        { "MIC",   4095 },
    };

    printf("%-8s %6s %8s\n", "CHANNEL", "ADC", "VOLTS");
    for (int i = 0; i < 4; i++)
        printf("%-8s %6d %8.3f\n",
               ch[i].name, ch[i].adc, ch[i].adc * 3.3 / 4095.0);

    int w = 10, p = 4;
    printf("[%*d]\n", w, 42);          /* width from a variable     */
    printf("[%*.*f]\n", w, p, 3.14159); /* width and precision, both */
    return 0;
}

gcc -std=c11 -Wall -Wextra -o p_table p_table.c
./p_table

CHANNEL     ADC    VOLTS
VBAT       3012    2.427
TEMP        871    0.702
LIGHT        45    0.036
MIC        4095    3.300
[        42]
[    3.1416]

The header and every row use the same widths (%-8s for names, %6d for raw counts and %8.3f for volts), so the columns stay aligned no matter what values appear. The voltage column is the 12-bit raw ADC value scaled against a 3.3 V reference. The last two lines show the star in action: %*d takes the width from w, and %*.*f takes width and then precision, in that order, before the value.

Real-World Uses in Embedded Programming

• Sensor dashboards on a serial terminal: fixed-width columns make trends visible while you tweak a control loop.
• Register and memory dumps: %08x keeps addresses and values aligned when you debug a peripheral.
• Log timestamps: %02d:%02d:%02d gives 07:05:09 instead of 7:5:9.
• Safe string display: %.16s shows at most 16 characters of a device name that might arrive without a terminator.

Common Mistakes and Troubleshooting

Best Practices, Performance and Security

• Use the same format string for headers and rows so columns match.
• Prefer snprintf with a buffer size over sprintf when building text.
• Never pass untrusted text as the format: write printf("%s", text), not printf(text). A stray %n or %x in user data can leak or corrupt memory. This is called a format string vulnerability.
• Performance: printf pulls in a lot of code and stack on small microcontrollers and formats slowly. For hot paths, print raw integers or use a lighter logging routine.
• Let the compiler help: build with -Wall -Wextra and it warns when a conversion and argument do not match.

Quick Quiz: Predict the Output

Click each question to reveal the answer after you have tried it.

Interview Questions

Summary and Key Takeaways

Once you understand printf width and precision in C, your output stops being a stream of numbers and starts being a readable report. The three small ideas in this lecture, padding with width, rounding or trimming with precision and measuring with the return value, will serve you in every debug session. Run the programs, change the numbers, and predict each result before you press Enter.

Next we return to the input side with the scanf suppression character, a tiny star that tells scanf to read something and throw it away.

Frequently Asked Questions