size_t vs unsigned int in C and C++: What’s the Difference?

By the end of this page, you will understand what size_t is, why it is commonly used for sizes and array/container indexes, and how it differs from unsigned int. You will also learn when size_t is the correct type, what problems it helps avoid, and what mistakes beginners often make when mixing it with signed integers.

size_t is a type used to represent the size of objects in memory. In both C and C++, it is the standard type returned by the sizeof operator.

That matters because object sizes, array lengths, buffer capacities, and many indexes are naturally tied to memory size. The language and standard libraries therefore use size_t anywhere a value must be able to represent the size of any object that can exist on the platform.

Why not just use unsigned int?

Because unsigned int is not guaranteed to be large enough to hold every possible object size.

For example:

• On some systems, unsigned int may be 32 bits.
• On a 64-bit system, object sizes and address-related values may require a 64-bit type.
• size_t is chosen by the implementation specifically to be able to represent the size of any object.

So size_t is about portability and correctness.

What size_t is used for

Common uses include:

• return value of sizeof
• string lengths like strlen
• container sizes like vector::size()
• memory allocation sizes like malloc
• array indexing in many APIs

Example:

std::vector<int> numbers = {10, 20, 30};
std::size_t count = numbers.size();

numbers.size() returns std::size_t, not unsigned int, because the vector may be able to hold more elements than an unsigned int can represent on some systems.

Why this matters in real programming

Using the right type helps avoid:

• overflow when storing sizes
• warnings when comparing signed and unsigned values
• bugs on 64-bit platforms
• incorrect assumptions about platform-specific integer sizes

In short:

• Use size_t for sizes, counts, capacities, and indexes when working with standard library containers or memory sizes.
• Use int when the value can reasonably be negative and is not specifically a memory size.

Think of size_t as the official measuring tape for memory-related quantities.

If you are measuring the length of a table, you use a ruler designed for measurement. You do not use a random tool just because it can sometimes give a number.

In the same way:

• int is a general-purpose number type
• unsigned int is a non-negative general-purpose number type
• size_t is the type specifically meant for measuring sizes of objects and containers

So if you are asking questions like:

• "How many bytes does this object use?"
• "How many characters are in this string?"
• "How many elements are in this vector?"

then size_t is usually the right measuring tool.

Another way to think about it:

• int answers: "a number"
• size_t answers: "a size"

The most common place you see size_t is with sizeof and standard library size functions.

Basic syntax

#include <cstddef>
#include <cstring>
#include <vector>

std::size_t a = sizeof(int);
std::size_t b = std::strlen("hello");

In C, you will often write:

#include <stddef.h>
#include <string.h>

size_t a = sizeof(int);
size_t b = strlen("hello");

Example: using size_t with a vector

#include <iostream>
#include <vector>

int main() {
    std::vector<int> values = {4, 8, 15, 16, 23, 42};

    std::size_t count = values.size();
    std::cout << "Number of elements: " << count << "\n";

    for (std::size_t i = 0; i < values.size(); ++i) {
        std::cout << "Index " << i << ": " << values[i] << "\n";
    }
}

Why this example uses std::size_t

• values.size() returns std::size_t
• i is also std::size_t, so the comparison is type-consistent
• this avoids signed/unsigned mismatch warnings

Example: what not to do

std::vector<int> values = {1, 2, 3};

for (int i = 0; i < values.size(); ++i) {
    // may produce a warning: comparing int with size_t
}

This often works for small cases, but it mixes int with size_t, which can lead to warnings and subtle bugs.

Consider this example:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> data = {10, 20, 30};
    std::size_t n = data.size();

    for (std::size_t i = 0; i < n; ++i) {
        std::cout << data[i] << "\n";
    }
}

Step-by-step

1. Create the vector

std::vector<int> data = {10, 20, 30};

The vector stores 3 integers.

2. Ask for its size

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

data.size() returns the number of elements in the vector. That return type is std::size_t. So n becomes 3.

3. Start the loop

for (std::size_t i = 0; i < n; ++i)

• i starts at 0
• condition: i < 3
• i increases by 1 each time

4. First iteration

• i = 0
• 0 < 3 is true
• print data[0], which is 10

5. Second iteration

• i = 1
• 1 < 3 is true
• print data[1], which is 20

6. Third iteration

• i = 2
• 2 < 3 is true
• print data[2], which is 30

7. Stop

• i = 3
• 3 < 3 is false
• loop ends

Key detail

The important part is not just the loop. It is that both:

• n
• i

use the same size-related type as the container API. That keeps the code consistent and portable.

size_t appears in many practical situations.

1. Buffer and memory management

char buffer[256];
size_t capacity = sizeof(buffer);

This is common in C code that works with raw memory, strings, files, and network data.

2. String processing

std::string name = "Alice";
std::size_t len = name.size();

String lengths are sizes, so libraries use size_t.

3. Loops over containers

for (std::size_t i = 0; i < items.size(); ++i) {
    // process items[i]
}

This is common when indexing arrays, vectors, or strings.

4. Dynamic memory allocation

int *arr = malloc(100 * sizeof(int));

The number passed to malloc is a size in bytes, so the API uses size_t.

5. File and binary data processing

When reading data into a buffer, code often tracks:

• bytes read
• buffer size
• remaining bytes

These are all naturally represented by size_t.

6. Library and framework APIs

Standard containers and many low-level APIs use size_t so they can work correctly across 32-bit and 64-bit systems.

In real codebases, developers use size_t mainly where the value comes from the standard library or represents a memory-related quantity.

Common patterns

Use it for .size() results

std::size_t count = users.size();
if (count == 0) {
    return;
}

This avoids unnecessary casts.

Use it for indexes when indexing containers

for (std::size_t i = 0; i < users.size(); ++i) {
    process(users[i]);
}

Use guard clauses with size checks

if (buffer.size() < 4) {
    return false;
}

buffer.size() is size-based, so comparing it with other size values is natural.

Use range-based loops when indexing is not needed

In modern C++, developers often avoid manual indexes entirely:

for (const auto& user : users) {
    process(user);
}

This is often better than worrying about whether the index should be int or size_t.

Use explicit conversions only when needed

Sometimes an API expects int:

int count = static_cast<int>(users.size());

This should be done carefully, and only if you know the size fits into int.

Practical rule from real projects

• If the value comes from sizeof, .size(), strlen, malloc, or byte counts, use size_t.
• If the value represents something that may be negative, use a signed type.
• If you do not need indexes, prefer range-based loops or iterators.

1. Using int for container size

Broken example:

std::vector<int> items = {1, 2, 3};
int n = items.size();

Why it is a problem:

• items.size() returns std::size_t
• converting to int may lose data on large containers

Better:

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

2. Comparing signed and unsigned values

Broken example:

std::vector<int> items = {1, 2, 3};
for (int i = 0; i < items.size(); ++i) {
    // ...
}

Why it is a problem:

• i is signed
• items.size() is unsigned
• the comparison can produce warnings or surprising behavior

Better:

for (std::size_t i = 0; i < items.size(); ++i) {
    // ...
}

3. Assuming unsigned means safer

Beginners often think unsigned int is always a good replacement for int. That is not true.

Broken example:

unsigned int x = 0;
std::cout << (x - 1) << "\n";

This does not become -1. It wraps around to a very large value.

Lesson:

• unsigned types are not automatically safer
• use size_t only for genuine size-related values

4. Counting backward with size_t incorrectly

Broken example:

for (std::size_t i = items.size() - 1; i >= 0; --i) {
    // infinite loop risk
}

Why it is broken:

• size_t cannot be negative
• when i becomes 0 and is decremented, it wraps to a very large value

Safer alternatives:

for (std::size_t i = items.size(); i > 0; --i) {
    std::cout << items[i - 1] << "\n";
}

Or use reverse iterators.

5. Casting away warnings without thinking

Broken example:

for (int i = 0; i < (int)items.size(); ++i) {
    // ...
}

Why it is risky:

• the cast hides the warning
• it does not fix the underlying type mismatch
• large sizes may still overflow int

Better:

• use std::size_t
• or redesign the loop to avoid indexing

size_t vs unsigned int

size_t vs int

size_t vs ptrdiff_t

Important takeaway

• Use size_t for values that represent a size or count from the standard library.
• Use int or another signed type when negative values are meaningful.
• Do not treat unsigned int as a universal replacement for both.

Quick reference

• size_t is the standard type for object sizes.
• sizeof returns size_t.
• strlen returns size_t.
• std::string::size() and std::vector::size() return std::size_t.
• size_t is unsigned.
• size_t is implementation-defined, but guaranteed to hold the size of any object.

Include headers

C:

#include <stddef.h>

C++:

#include <cstddef>

Typical usage

std::size_t n = values.size();
std::size_t bytes = sizeof(buffer);

Prefer size_t when

• storing the result of sizeof
• storing string length
• storing container size
• passing byte counts to memory-related functions
• indexing with values tied directly to container size

Be careful

• size_t cannot represent negative values
• subtracting from 0 wraps around
• reverse loops need special care
• mixing int and size_t may cause warnings

Reverse loop pattern

for (std::size_t i = items.size(); i > 0; --i) {
    use(items[i - 1]);
}

Good rule of thumb

• size/count/length/capacity -> size_t
• values that may be negative -> signed type

Why does sizeof return size_t?

Because sizeof reports the size of an object in bytes, and size_t is the standard type meant to store object sizes safely.

Is size_t always the same as unsigned int?

No. On some systems they may be the same size, but the language does not guarantee that. size_t may be wider.

Should I always use size_t for loop counters?

Not always. Use it when the loop variable is tied to a container size or memory size. If negative values are useful, use a signed type instead.

Why do I get warnings when comparing int and size_t?

Because int is signed and size_t is unsigned. The compiler warns you because the comparison can behave unexpectedly.

Can size_t hold negative values?

No. size_t is an unsigned type.

Is unsigned int obsolete?

No. It still has valid uses. It is just not the best choice for values specifically representing object sizes or standard library container sizes.

What should I use for reverse iteration if size_t is unsigned?

Use a pattern like for (std::size_t i = v.size(); i > 0; --i) and access v[i - 1], or use reverse iterators.

• sizeof — size_t comes directly from the result type of sizeof.
• signed vs unsigned integers — understanding this helps explain warnings and wraparound behavior.
• integer overflow and underflow — important when subtracting or converting numeric types.
• ptrdiff_t — related signed type for pointer differences and negative index differences.
• STL containers — many container methods such as .size() return std::size_t.
• iterators — often a better alternative than manual indexing.
• range-based for loop — avoids index type issues when you only need the elements.
• type conversions in C and C++ — useful for understanding casts between size_t, int, and other integer types.