C++ Fundamental Type Sizes: What the Standard Guarantees About int, long, char, float, and double

By the end of this page, you will understand what the C++ standard actually guarantees about fundamental type sizes, what it leaves implementation-defined, why int and long do not have fixed sizes, and how to write portable C++ code when exact widths matter.

In C++, the sizes of fundamental types are not fully fixed by the language standard. Instead, the standard defines:

• minimum guarantees
• relative ordering rules between integer types
• broad properties of floating-point types
• the rule that char is always exactly 1 byte

The important idea is that in C++, a byte does not necessarily mean 8 bits. A byte is the size of char, and its number of bits is given by CHAR_BIT from <climits>.

Integer types

For the standard integer types, the language guarantees an ordering like this:

sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

More precisely, the standard guarantees that each type can represent at least a certain range:

• signed char: at least -127 to 127
• short: at least to

Think of C++ fundamental types as container labels with minimum capacity, not exact box dimensions.

• short means: "a small integer type, at least this capable"
• int means: "the natural integer type for the machine"
• long means: "an integer type at least as capable as int"

The standard does not say, "This box must always be exactly 4 bytes wide." It says more like, "This box must hold at least this much, and these boxes must be ordered from no larger to no smaller."

So if you ask for an int, you are asking for a general-purpose integer type chosen by the implementation. If you ask for std::int32_t, you are asking for a box with exactly 32 bits, if the implementation provides it.

That is the key distinction:

• language types like int are about general-purpose programming
• fixed-width types like std::int32_t are about exact storage requirements

Checking type sizes in C++

You can inspect sizes with sizeof:

#include <iostream>

int main() {
    std::cout << "char: " << sizeof(char) << "\n";
    std::cout << "short: " << sizeof(short) << "\n";
    std::cout << "int: " << sizeof(int) << "\n";
    std::cout << "long: " << sizeof(long) << "\n";
    std::cout << "long long: " << sizeof(long long) << "\n";
    std::cout << "float: " << sizeof(float) << "\n";
    std::cout << "double: " << sizeof(double) << "\n";
    std::cout << "long double: " << sizeof(long double) << "\n";
}

Example program

#include <iostream>
#include <climits>

int main() {
    std::cout << sizeof(char) << "\n";
    std::cout << sizeof(int) << "\n";
    std::cout << CHAR_BIT << "\n";
}

What happens step by step

1. #include <iostream> makes std::cout available.
2. #include <climits> makes constants like CHAR_BIT available.
3. The program starts in main().
4. sizeof(char) is evaluated.
   • This is always 1 by definition in C++.
   • It means one byte.
5. sizeof(int) is evaluated.
   • The compiler provides the actual size for the current platform.
   • On many systems, this is 4, but the standard does not require that.

Binary file formats

If you read or write binary files, exact widths matter. A file format may require a 32-bit integer or a 16-bit field. In that case, use fixed-width types like std::uint32_t.

Network protocols

Protocols often define packet fields with exact sizes. Assuming int is 32 bits can break communication on other systems.

Embedded systems

On small devices, int may not match desktop expectations. Code that assumes desktop sizes may fail or waste memory.

Cross-platform libraries

Portable libraries avoid hardcoding assumptions about long and int. They use standard limits, sizeof, and fixed-width types where needed.

Memory-sensitive applications

Sometimes developers choose smaller types to reduce memory usage in large arrays or data structures. To do that safely, they must know what the implementation guarantees.

Serialization and deserialization

When converting objects to bytes for storage or transmission, exact widths and layout rules become important. Using plain int in serialized formats is often a portability bug.

In real projects, developers usually follow a few practical rules.

1. Use int for ordinary arithmetic and loop counters

for (int i = 0; i < count; ++i) {
    // work
}

Why? Because int is usually the implementation's natural general-purpose integer type.

2. Use fixed-width types for external data

#include <cstdint>

struct PacketHeader {
    std::uint32_t length;
    std::uint16_t type;
};

This is common in networking, storage, and APIs.

3. Use std::size_t for object sizes and indexing

std::size_t n = values.size();

This is the correct type for sizes returned by the standard library.

4. Use guard checks instead of assumptions

static_assert(sizeof(std::uint32_t) == , );

Mistake 1: Assuming int is always 32 bits

Broken example:

int userId = 2147483647;

This value fits on common systems, but the assumption that int is always 32 bits is not guaranteed by the standard.

Avoid it by using:

std::int32_t userId = 2147483647;

when exact width matters.

Mistake 2: Assuming long is always bigger than int

Broken assumption:

// Not necessarily larger than int on every system
long value = 10;

long is guaranteed to be at least as wide as int, but it may be the same size.

Mistake 3: Treating a byte as always 8 bits

Broken assumption:

int bits = sizeof() * ;

General-purpose types vs exact-width types

Core guarantees

• sizeof(char) == 1
• sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)
• sizeof(float) <= sizeof(double) <= sizeof(long double)
• a byte is the size of char
• bits per byte are given by CHAR_BIT

Minimum integer widths

• short: at least 16 bits
• int: at least 16 bits
• long: at least 32 bits
• long long: at least 64 bits

Important reminders

• int is not guaranteed to be 32 bits
• long is not guaranteed to be 64 bits
• char is always 1 byte, but a byte is not guaranteed to be 8 bits
• char, signed char, and unsigned char are distinct types

Useful headers

Is int always 4 bytes in C++?

No. The standard only guarantees that int is at least 16 bits. Many modern systems use 4-byte int, but not all.

Is long always 8 bytes on 64-bit systems?

No. On 64-bit Linux and macOS, long is often 8 bytes. On 64-bit Windows, long is usually 4 bytes.

Why is sizeof(char) always 1?

Because C++ defines a byte as the size of char. That does not mean a byte must contain 8 bits.

How can I get an exact 32-bit integer in C++?

Use std::int32_t from <cstdint>.

How do I check type limits portably?

Use std::numeric_limits<T> from <limits> or constants such as INT_MAX from <climits>.

Is double always 8 bytes?

Often yes in practice, but the standard does not require that exact size on every implementation.

• sizeof — used to query the size of types and objects.
• std::numeric_limits — used to inspect value ranges and numeric properties portably.
• <cstdint> fixed-width integer types — important when exact bit width is required.
• CHAR_BIT — tells you how many bits are in a byte on the current implementation.
• signed vs unsigned integers — affects numeric range even when sizes match.
• data models (ILP32, LP64, LLP64) — explain why type sizes differ across platforms.
• std::size_t — the standard type for object sizes and indexing.
• serialization — exact type widths matter when writing data to files or networks.