C Struct Padding Calculator — offsets, padding and size

Paste a C struct to see member offsets, inserted padding and total size for 32-bit and 64-bit targets — and how to reorder it smaller.

Example: This struct is 32 bytes with 16 of padding, or 16 bytes if the members are reordered.

Inputs

Struct members

Semicolon-separated. A surrounding struct { } is fine — it is stripped.

Architecture

Result

sizeof(struct)

32 bytes

Wasted on padding: 16 bytes
Struct alignment: 8 bytes
Members: 5
Size if reordered: 16 bytes

Reordering the members largest-alignment-first drops the struct from 32 to 16 bytes — 50% smaller for no runtime cost. Order: d, b, e, a, c.
16 of 32 bytes are padding. In an array of these that waste multiplies — a million elements would lose 15.3 MB.
6 bytes of trailing padding exist so that an array of this struct keeps every element aligned. That is why sizeof is a multiple of 8, not the sum of the members.
This assumes standard alignment on a mainstream ABI. `#pragma pack` or `__attribute__((packed))` removes the padding entirely — at the cost of unaligned access, which is slower on x86 and a hard fault on some ARM cores.

Layout as written

Offset	Size	Align	Type	Name	Padding after
0	1	1	char	a	3
4	4	4	int	b	—
8	1	1	char	c	7
16	8	8	double	d	—
24	2	2	short	e	6

Reordered — 16 bytes

Offset	Size	Type	Name	Padding after
0	8	double	d	—
8	4	int	b	—
12	2	short	e	—
14	1	char	a	—
15	1	char	c	—

/* generated by urdb.io/tools/struct-padding */
struct example {   /* 32 bytes on 64-bit (LP64) */
    char a;                       /* offset 0, +3 padding */
    int b;                        /* offset 4 */
    char c;                       /* offset 8, +7 padding */
    double d;                     /* offset 16 */
    short e;                      /* offset 24, +6 padding */
};

_Static_assert(sizeof(struct example) == 32, "unexpected layout");

Check it against real silicon

Chiprun runs your firmware on an emulated microcontroller and hands back the UART output, so you can confirm these numbers rather than trusting them.

Chiprun docs

Formula

each member starts at a multiple of its alignment; the struct is padded to its strictest

Worked example

This struct is 32 bytes with 16 of padding, or 16 bytes if the members are reordered.

each member starts at a multiple of its own alignment
a @ 0, b @ 4, c @ 8, d @ 16, e @ 24
32 bytes total
struct size rounds up to its strictest alignment
round 26 up to a multiple of 8
32 bytes

Frequently asked questions

Why is my struct bigger than the sum of its members?

Padding. Each member must start at an offset that is a multiple of its own alignment, so the compiler inserts gaps. The struct is then padded at the end too, so that an array of them keeps every element aligned.

How do I make a struct smaller?

Reorder the members largest-alignment-first. It costs nothing at runtime and often removes most of the padding — this tool shows both layouts and the saving. Packing with a pragma also works but makes access unaligned, which is slower on x86 and faults on some ARM cores.

Why is there padding at the end of a struct?

So arrays work. If a struct contains an 8-byte member, every element in an array of it must start on an 8-byte boundary — which means the struct's size has to be a multiple of 8, even if the last member ends earlier.

Does this layout change between platforms?

Yes. `long` and pointers are 4 bytes on 32-bit and 8 on 64-bit, which shifts every subsequent offset. If a struct crosses a wire or a file format, use the fixed-width intN_t types and check the layout on both ends.

Related tools

Stack Size Estimator

Estimate worst-case stack depth from call nesting, locals and interrupt frames.

Firmware

Hex, Binary & Decimal Converter

Convert between hex, binary, decimal, octal and ASCII, with width-aware bit grids and endianness swapping.

Firmware

IEEE 754 Float Converter

Convert between decimal, hex and binary float32/float64, with the sign, exponent and mantissa fields broken out.

Firmware

Paste a register value and a field layout to get a decoded table — with presets for common STM32 and AVR registers.

Firmware

Bitwise Operation Calculator

AND, OR, XOR, NOT and shifts with a live bit grid so you can see exactly which bits moved.

Firmware

CRC Calculator

CRC-8, CRC-16 (CCITT, Modbus, XMODEM) and CRC-32 over hex or ASCII input, with the polynomial and shift steps explained.

Firmware