How to Add Leading Zeros in C and C++

To add leading zeros to a number in C, use a zero flag and a width in the format string: printf("%05d", 42) prints 00042. In C++ the equivalent is std::cout << std::setw(5) << std::setfill('0') << 42, or std::format("{:05}", 42) if you can use C++20. Everything else in this guide is about the details: writing the padded value into a string instead of the console, handling negative numbers and hex, building zero padded file names, and the few cases where inserting characters into a string by hand is the right move.

Zero padding comes up in three places: fixed width console or log output, generated file names that must sort correctly (frame_0007.png), and identifiers such as invoice numbers or ZIP codes that are really strings of digits. The mechanism differs between C’s printf family and C++ streams, so this article covers both, with a table of the flags and a section on the edge cases that produce surprising output.

Leading zeros in C with printf

The 0 flag in a conversion specification tells printf to pad with zeros instead of spaces up to the given minimum field width. It works with every integer conversion (d, i, u, x, X, o) and with floating point conversions.

#include <stdio.h>

int main(void)
{
    printf("%05d\n", 42);        /* 00042 */
    printf("%05d\n", 123456);    /* 123456, never truncated */
    printf("%05d\n", -42);       /* -0042, the sign counts toward width */
    printf("%08.3f\n", 3.14159); /* 0003.142 */
    printf("%04x\n", 255);       /* 00ff */
    printf("%#06x\n", 255);      /* 0x00ff, # adds the prefix, width includes it */
    printf("%0*d\n", 6, 42);     /* 000042, width supplied as an argument */
    return 0;
}

Two rules explain every line. The width is a minimum, so larger values are printed in full. And the width counts every character the conversion emits, including a minus sign or the 0x prefix, so %05d with -42 gives four digits, not five.

Padding the digits and not the sign

If you want -00042 (five digits plus the sign), use a precision instead of a zero flag. For integer conversions, precision sets the minimum number of digits:

printf("%.5d\n", 42);    /* 00042  */
printf("%.5d\n", -42);   /* -00042 */
printf("%+.5d\n", 42);   /* +00042 */

The C standard specifies that when a precision is given for an integer conversion, the 0 flag is ignored, so pick one or the other. Precision based padding is the correct choice for anything where the digit count matters more than the column width.

Writing a zero padded string with snprintf

Most real code needs the padded value in a buffer rather than on stdout. Use snprintf, never sprintf, so the buffer size is enforced. The classic use is building file names in a loop:

#include <stdio.h>

int main(void)
{
    char name[64];
    for (int i = 0; i < 3; i++) {
        int n = snprintf(name, sizeof name, "frame_%04d.png", i);
        if (n < 0 || (size_t)n >= sizeof name) {
            fputs("name too long\n", stderr);
            return 1;
        }
        puts(name);   /* frame_0000.png, frame_0001.png, frame_0002.png */
    }
    return 0;
}

snprintf returns the number of characters it would have written, not counting the terminator. Checking that value against the buffer size is the difference between a warning and a silently truncated file name. If you go on to open and write those files, the walkthrough on how to write a file in C picks up from here.

Leading zeros in C++ with iostreams

C++ streams use manipulators from <iomanip>. std::setw(n) sets the field width for the next output only, and std::setfill(c) sets the fill character for the stream until you change it again.

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>

int main()
{
    std::cout << std::setfill('0') << std::setw(5) << 42 << '\n';   // 00042
    std::cout << std::setw(5) << -42 << '\n';                        // 00-42  (!)
    std::cout << std::internal << std::setw(5) << -42 << '\n';       // -0042

    std::ostringstream os;
    os << std::setfill('0') << std::setw(4) << 7;
    std::string s = os.str();                                          // "0007"

    std::cout << std::hex << std::setw(4) << 255 << '\n';             // 00ff
    return 0;
}

The second line shows the trap. By default the fill goes on the left of the entire value, sign included, so you get 00-42. Add std::internal to put the padding between the sign and the digits. Also remember that setw resets after one insertion while setfill, hex and internal persist on the stream; if you are padding inside a function that writes to a caller’s stream, save and restore the flags with std::ios::fmtflags or use a temporary std::ostringstream as shown.

std::format in C++20 and later

std::format (header <format>) uses the same mini language as Python’s str.format. The 0 before the width enables sign aware zero padding, which is exactly the std::internal behavior without having to ask for it. It is available in GCC 13, Clang 17 (with libc++) and MSVC 2019 16.10 or newer.

#include <format>
#include <iostream>
#include <string>

int main()
{
    std::string a = std::format("{:05}", 42);        // "00042"
    std::string b = std::format("{:05}", -42);       // "-0042"
    std::string c = std::format("{:06x}", 255);      // "0000ff"
    std::string d = std::format("{:#06x}", 255);     // "0x00ff"
    std::string e = std::format("{:0{}}", 42, 8);    // "00000042", runtime width
    std::string f = std::format("frame_{:04}.png", 7);
    std::cout << a << ' ' << b << ' ' << c << ' ' << d << ' ' << e << ' ' << f << '\n';
    return 0;
}

Because std::format returns a std::string, it replaces the ostringstream dance completely. With C++23 you can write std::println("{:05}", n) for direct output. If your toolchain is older, the fmt library provides the same API under the fmt:: namespace and is what std::format was standardized from.

Which method to use

When to use std::to_string plus insert

Sometimes the number is already a string: it came from a database, a form field, or a parser, and you need to normalize it to a fixed length. Converting back to an integer and reformatting loses information if the input has leading zeros that matter or exceeds the integer range. In that case pad the string directly:

#include <string>

std::string zero_pad(std::string s, std::size_t width)
{
    if (s.size() < width) {
        s.insert(0, width - s.size(), '0');
    }
    return s;
}

// zero_pad(std::to_string(42), 5)  -> "00042"
// zero_pad("7", 3)                 -> "007"
// zero_pad("123456", 3)            -> "123456" (unchanged)

The same shape works for a signed value if you strip the leading '-' first, pad the remainder, and reattach the sign. For a plain integer you own, std::format or snprintf is shorter and faster; reach for insert only when the source is text. In C, the equivalent is memset the front of a buffer with '0' and memcpy the digits behind it, which is rarely worth the effort over a second snprintf.

Edge cases that bite

Numbers stored in an enum or a packed struct field print exactly like any other integer once you cast them to int; the article on using an enum inside a struct covers the cast. The situations below are the ones that produce bug reports.

Reading padded input back. atoi("0042") and std::stoi("0042") both return 42, but strtol(s, NULL, 0) with base 0 treats a leading zero as octal. Pass base 10 explicitly when parsing zero padded decimal strings.

Width versus size types. printf("%05d", some_size_t) is undefined behavior on platforms where size_t is not int. Use %05zu for size_t, %05lld for long long, and the PRId64 macros from <inttypes.h> for fixed width types. Compiling with -Wall -Wformat catches most of these.

Floating point. %08.3f pads the whole field including the decimal point. If you want a fixed number of integer digits, format the integer and fractional parts separately.

Locale. Neither the zero flag nor setfill is affected by locale, but the ' flag (thousands grouping, a POSIX extension) and stream imbue can insert separators that push your digits past the width. Keep formatting and localization in separate steps.

Troubleshooting

Output shows 00-42 instead of -0042 in C++

The stream’s adjustment is right by default, which pads before the sign. Insert std::internal before setw, or switch to std::format("{:05}", n), which pads after the sign automatically.

Only the first number is padded

std::setw applies to the next insertion only and then resets to zero. Repeat setw before every value you want padded. setfill does persist, so you set it once.

printf prints spaces, not zeros

The format is %5d instead of %05d, or you combined the 0 flag with - (left justify), which cancels zero padding by definition. Check for a precision as well, since %05.3d ignores the zero flag.

std::format does not compile

Your compiler or standard library predates support, or you forgot -std=c++20. GCC 13 and newer ship <format> in libstdc++; for older toolchains, install the fmt library and use fmt::format with the identical syntax. Errors thrown for a malformed format string at runtime are std::format_error, which you can handle as described in how to catch exceptions in C++.

Frequently asked questions

How do I add leading zeros in C printf?

Put a 0 flag and a width between the percent sign and the conversion: printf("%05d", n) prints at least five characters, padding on the left with zeros. Larger values are never cut off. For a variable width pass an asterisk, as in printf("%0*d", width, n).

How do I zero pad a number into a string in C?

Use snprintf with the same format: snprintf(buf, sizeof buf, "%05d", n). Check the return value against the buffer size to catch truncation. This is the standard way to build zero padded file names, log tags, and fixed width identifiers without risking a buffer overflow.

How do I add leading zeros in C++ cout?

Include <iomanip> and write std::cout << std::setfill('0') << std::setw(5) << n. Add std::internal if the value may be negative so the sign stays in front. Remember that setw only applies to the very next value written to the stream.

What is the C++20 way to add leading zeros?

std::format("{:05}", n) returns a padded std::string, and std::println("{:05}", n) in C++23 prints it directly. The zero before the width is sign aware, so negative numbers come out as -0042. Hex works with {:04x} and a runtime width with {:0{}}.

Why does %05d give me -0042 and not -00042?

The width counts every character including the sign, so five columns leaves four for digits. If you need exactly five digits regardless of sign, use precision instead: %.5d guarantees a minimum digit count and places the sign in front of them.

Wrapping up

Leading zeros are a formatting concern, and both languages give you a one line answer for the common case: %05d in C and std::format("{:05}") or setfill plus setw in C++. The details that matter are whether the sign counts toward the width, whether you are writing to a stream or a buffer, and whether the “number” is really a string.

Pick precision over the zero flag when digit count matters more than column width, always use snprintf over sprintf, and pad strings with insert only when converting to an integer would lose information. Get those three habits right and you will not think about zero padding again.