4.6 — Fixed-width integers and size_t

In this lesson, you'll learn about fixed-width integer types that have guaranteed sizes, and the special size_t type used throughout the C++ standard library.

The problem with standard integer sizes

Traditional integer types (int, long, etc.) don't guarantee specific sizes - they only provide minimum requirements:

#include <iostream>

int main()
{
    std::cout << "Traditional integer sizes (may vary by system):\n";
    std::cout << "int: " << sizeof(int) << " bytes (minimum 2)\n";
    std::cout << "long: " << sizeof(long) << " bytes (minimum 4)\n";
    std::cout << "long long: " << sizeof(long long) << " bytes (minimum 8)\n";
    
    std::cout << "\nThis can cause portability issues!\n";
    std::cout << "What if you need exactly 32 bits on all systems?\n";
    
    return 0;
}

Output (varies by system):

Traditional integer sizes (may vary by system):
int: 4 bytes (minimum 2)
long: 8 bytes (minimum 4)
long long: 8 bytes (minimum 8)

This can cause portability issues!
What if you need exactly 32 bits on all systems?

Fixed-width integer types

C++11 introduced fixed-width integer types in the <cstdint> header that guarantee specific sizes:

#include <iostream>
#include <cstdint>

int main()
{
    std::cout << "Fixed-width integer types:\n\n";
    
    // Signed fixed-width integers
    std::cout << "Signed types:\n";
    std::cout << "int8_t: " << sizeof(int8_t) << " byte (8 bits)\n";
    std::cout << "int16_t: " << sizeof(int16_t) << " bytes (16 bits)\n";
    std::cout << "int32_t: " << sizeof(int32_t) << " bytes (32 bits)\n";
    std::cout << "int64_t: " << sizeof(int64_t) << " bytes (64 bits)\n\n";
    
    // Unsigned fixed-width integers
    std::cout << "Unsigned types:\n";
    std::cout << "uint8_t: " << sizeof(uint8_t) << " byte (8 bits)\n";
    std::cout << "uint16_t: " << sizeof(uint16_t) << " bytes (16 bits)\n";
    std::cout << "uint32_t: " << sizeof(uint32_t) << " bytes (32 bits)\n";
    std::cout << "uint64_t: " << sizeof(uint64_t) << " bytes (64 bits)\n";
    
    return 0;
}

Output:

Fixed-width integer types:

Signed types:
int8_t: 1 byte (8 bits)
int16_t: 2 bytes (16 bits)
int32_t: 4 bytes (32 bits)
int64_t: 8 bytes (64 bits)

Unsigned types:
uint8_t: 1 byte (8 bits)
uint16_t: 2 bytes (16 bits)
uint32_t: 4 bytes (32 bits)
uint64_t: 8 bytes (64 bits)

Using fixed-width integers

These types are perfect when you need precise control over size and range:

#include <iostream>
#include <cstdint>

int main()
{
    // Exact 32-bit signed integer
    int32_t temperature = -40;          // Always 32 bits
    
    // Exact 16-bit unsigned integer
    uint16_t port = 8080;               // Always 16 bits, 0 to 65535
    
    // Exact 8-bit signed integer
    int8_t adjustment = -5;             // Always 8 bits, -128 to 127
    
    // Exact 64-bit unsigned integer
    uint64_t fileSize = 1099511627776ULL; // Always 64 bits, very large range
    
    std::cout << "Fixed-width integer values:\n";
    std::cout << "Temperature: " << temperature << " (int32_t)\n";
    std::cout << "Port: " << port << " (uint16_t)\n";
    std::cout << "Adjustment: " << static_cast<int>(adjustment) << " (int8_t)\n";
    std::cout << "File size: " << fileSize << " bytes (uint64_t)\n";
    
    // Show their exact ranges
    std::cout << "\nRanges:\n";
    std::cout << "int32_t: " << INT32_MIN << " to " << INT32_MAX << "\n";
    std::cout << "uint16_t: 0 to " << UINT16_MAX << "\n";
    std::cout << "int8_t: " << static_cast<int>(INT8_MIN) 
              << " to " << static_cast<int>(INT8_MAX) << "\n";
    
    return 0;
}

Output:

Fixed-width integer values:
Temperature: -40 (int32_t)
Port: 8080 (uint16_t)
Adjustment: -5 (int8_t)
File size: 1099511627776 bytes (uint64_t)

Ranges:
int32_t: -2147483648 to 2147483647
uint16_t: 0 to 65535
int8_t: -128 to 127

Fast and least-width types

C++ also provides "fast" and "least" width types for performance and space optimization:

#include <iostream>
#include <cstdint>

int main()
{
    std::cout << "Fast and least-width integer types:\n\n";
    
    // Least-width types (smallest type with at least N bits)
    std::cout << "Least-width types (smallest with at least N bits):\n";
    std::cout << "int_least8_t: " << sizeof(int_least8_t) << " bytes\n";
    std::cout << "int_least16_t: " << sizeof(int_least16_t) << " bytes\n";
    std::cout << "int_least32_t: " << sizeof(int_least32_t) << " bytes\n";
    std::cout << "int_least64_t: " << sizeof(int_least64_t) << " bytes\n\n";
    
    // Fast-width types (fastest type with at least N bits)
    std::cout << "Fast-width types (fastest with at least N bits):\n";
    std::cout << "int_fast8_t: " << sizeof(int_fast8_t) << " bytes\n";
    std::cout << "int_fast16_t: " << sizeof(int_fast16_t) << " bytes\n";
    std::cout << "int_fast32_t: " << sizeof(int_fast32_t) << " bytes\n";
    std::cout << "int_fast64_t: " << sizeof(int_fast64_t) << " bytes\n\n";
    
    // Example usage
    int_fast32_t counter = 0;          // Fast 32-bit operations
    int_least16_t compactData = 1000;  // Space-efficient 16-bit minimum
    
    std::cout << "Fast counter: " << counter << "\n";
    std::cout << "Compact data: " << compactData << "\n";
    
    return 0;
}

Typical Output:

Fast and least-width integer types:

Least-width types (smallest with at least N bits):
int_least8_t: 1 bytes
int_least16_t: 2 bytes
int_least32_t: 4 bytes
int_least64_t: 8 bytes

Fast-width types (fastest with at least N bits):
int_fast8_t: 1 bytes
int_fast16_t: 8 bytes
int_fast32_t: 8 bytes
int_fast64_t: 8 bytes

Fast counter: 0
Compact data: 1000

The size_t type

size_t is a special unsigned integer type used to represent sizes and counts:

#include <iostream>
#include <cstddef>  // For size_t
#include <vector>
#include <string>

int main()
{
    std::cout << "Understanding size_t:\n\n";
    
    // size_t is used for sizes and indices
    std::cout << "size_t properties:\n";
    std::cout << "Size: " << sizeof(size_t) << " bytes\n";
    std::cout << "Max value: " << SIZE_MAX << "\n\n";
    
    // Common uses of size_t
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::string text = "Hello, World!";
    
    size_t vectorSize = numbers.size();    // Container sizes
    size_t stringLength = text.length();   // String lengths
    
    std::cout << "Vector size: " << vectorSize << " (type: size_t)\n";
    std::cout << "String length: " << stringLength << " (type: size_t)\n\n";
    
    // Using size_t for array indexing
    std::cout << "Vector contents:\n";
    for (size_t i = 0; i < vectorSize; ++i)
    {
        std::cout << "numbers[" << i << "] = " << numbers[i] << "\n";
    }
    
    // size_t with sizeof
    size_t intSize = sizeof(int);
    size_t totalArraySize = vectorSize * intSize;
    
    std::cout << "\nMemory calculations:\n";
    std::cout << "Size of int: " << intSize << " bytes\n";
    std::cout << "Array memory usage: " << totalArraySize << " bytes\n";
    
    return 0;
}

Output:

Understanding size_t:

size_t properties:
Size: 8 bytes
Max value: 18446744073709551615

Vector size: 10 (type: size_t)
String length: 13 (type: size_t)

Vector contents:
numbers[0] = 1
numbers[1] = 2
numbers[2] = 3
numbers[3] = 4
numbers[4] = 5
numbers[5] = 6
numbers[6] = 7
numbers[7] = 8
numbers[8] = 9
numbers[9] = 10

Memory calculations:
Size of int: 4 bytes
Array memory usage: 40 bytes

Why size_t is important

size_t is designed to be large enough to represent the size of any object in bytes:

#include <iostream>
#include <cstddef>
#include <climits>

void demonstrateSizeLimits()
{
    std::cout << "Why size_t matters:\n\n";
    
    // size_t can represent the largest possible object size
    std::cout << "Maximum object sizes:\n";
    std::cout << "size_t max: " << SIZE_MAX << "\n";
    std::cout << "unsigned int max: " << UINT_MAX << "\n";
    std::cout << "unsigned long max: " << ULONG_MAX << "\n\n";
    
    // On 64-bit systems, size_t is usually 64-bit
    if (sizeof(size_t) > sizeof(unsigned int))
    {
        std::cout << "size_t (" << sizeof(size_t) << " bytes) is larger than unsigned int (" 
                  << sizeof(unsigned int) << " bytes)\n";
        std::cout << "This allows addressing larger memory ranges\n\n";
    }
    
    // Example: Large array sizes
    std::cout << "Theoretical maximum array sizes:\n";
    std::cout << "char array: " << SIZE_MAX << " elements\n";
    std::cout << "int array: " << SIZE_MAX / sizeof(int) << " elements\n";
    std::cout << "double array: " << SIZE_MAX / sizeof(double) << " elements\n";
}

int main()
{
    demonstrateSizeLimits();
    return 0;
}

Working with size_t safely

Be careful when mixing size_t with signed types:

#include <iostream>
#include <vector>

void demonstrateSizeTProblems()
{
    std::cout << "size_t mixing problems:\n\n";
    
    std::vector<int> numbers = {1, 2, 3};
    
    // Problem: Comparing size_t with signed int
    int target = 5;
    std::cout << "Looking for index " << target << " in vector of size " 
              << numbers.size() << "\n";
    
    // This can be problematic if target is negative
    if (target < numbers.size())  // Mixing signed and unsigned
    {
        std::cout << "Index is within bounds (but this check isn't safe for negative values)\n";
    }
    
    // Safer approach: Convert to same type
    if (target >= 0 && static_cast<size_t>(target) < numbers.size())
    {
        std::cout << "Safe bounds check passed\n";
    }
    else
    {
        std::cout << "Index out of bounds or negative\n";
    }
}

void demonstrateSafeIteration()
{
    std::cout << "\nSafe iteration patterns:\n";
    
    std::vector<int> data = {10, 20, 30, 40, 50};
    
    // Method 1: Use size_t for index
    std::cout << "Using size_t index:\n";
    for (size_t i = 0; i < data.size(); ++i)
    {
        std::cout << "data[" << i << "] = " << data[i] << "\n";
    }
    
    // Method 2: Range-based for loop (preferred)
    std::cout << "\nUsing range-based for loop (preferred):\n";
    for (int value : data)
    {
        std::cout << "value = " << value << "\n";
    }
    
    // Method 3: Convert size to signed (when you need signed arithmetic)
    std::cout << "\nUsing signed conversion for countdown:\n";
    int size = static_cast<int>(data.size());
    for (int i = size - 1; i >= 0; --i)
    {
        std::cout << "data[" << i << "] = " << data[i] << "\n";
    }
}

int main()
{
    demonstrateSizeTProblems();
    demonstrateSafeIteration();
    return 0;
}

When to use fixed-width types

✅ Use fixed-width types when:

1. Interfacing with hardware or file formats

#include <iostream>
#include <cstdint>

struct BMPHeader
{
    uint16_t fileType;      // Must be exactly 2 bytes
    uint32_t fileSize;      // Must be exactly 4 bytes
    uint16_t reserved1;     // Must be exactly 2 bytes
    uint16_t reserved2;     // Must be exactly 2 bytes
    uint32_t offsetData;    // Must be exactly 4 bytes
};

int main()
{
    std::cout << "BMP header size: " << sizeof(BMPHeader) << " bytes\n";
    std::cout << "This size is guaranteed across all systems\n";
    return 0;
}

2. Cross-platform compatibility

#include <iostream>
#include <cstdint>

void processNetworkData(uint32_t ipAddress, uint16_t port)
{
    // These sizes are consistent across all platforms
    std::cout << "Processing IP: " << ipAddress << ", Port: " << port << "\n";
}

int main()
{
    processNetworkData(0x7F000001, 8080);  // 127.0.0.1:8080
    return 0;
}

3. When you need exact bit counts

#include <iostream>
#include <cstdint>

void demonstrateBitManipulation()
{
    uint32_t flags = 0;
    
    // We know exactly how many bits we have
    std::cout << "32-bit flag register:\n";
    for (int i = 0; i < 32; ++i)
    {
        if (i % 8 == 0) std::cout << " ";
        std::cout << ((flags >> (31 - i)) & 1);
    }
    std::cout << "\n";
}

int main()
{
    demonstrateBitManipulation();
    return 0;
}

❌ Don't use fixed-width types for:

1. General-purpose counters and loops

// Prefer this:
for (int i = 0; i < 10; ++i)  // Simple, clear

// Over this:
for (int32_t i = 0; i < 10; ++i)  // Unnecessarily specific

2. When standard types are sufficient

// Prefer this for general calculations:
int calculateSum(int a, int b)
{
    return a + b;
}

// Avoid unless you specifically need 32 bits:
int32_t calculateSum(int32_t a, int32_t b)
{
    return a + b;
}

Summary

Fixed-width integers and size_t provide precise control when needed:

Fixed-width types (int32_t, uint64_t, etc.):

• Guarantee exact sizes across all platforms
• Perfect for hardware interfaces, file formats, and network protocols
• Use when you need precise bit counts or cross-platform consistency

size_t:

• Unsigned type for sizes, counts, and array indices
• Large enough to represent any object size
• Returned by sizeof, container .size(), string .length()
• Be careful when mixing with signed types

Best practices:

• Use int for general-purpose programming
• Use fixed-width types when you need guaranteed sizes
• Use size_t for sizes and indices when working with standard library containers
• Be cautious when mixing signed and unsigned types

Quiz

1. What's the difference between int and int32_t?
2. When would you use int_fast32_t instead of int32_t?
3. What is size_t and why is it important?
4. What problems can occur when mixing size_t with signed integers?
5. When should you prefer fixed-width integer types over standard types?

Practice exercises

Try these exercises with fixed-width integers and size_t:

1. Create a program that defines a network packet structure using appropriate fixed-width types
2. Write a function that safely converts between size_t and signed integers for array indexing
3. Implement a bit manipulation program that uses exact-width types for flag operations
4. Create a memory calculation program that uses size_t to determine array sizes and memory usage