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()

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>
# 

{
    std::vector<> values = {, , , , , };

    std:: count = values.();
    std::cout <<  << count << ;

     (std:: i = ; i < values.(); ++i) {
        std::cout <<  << i <<  << values[i] << ;
    }
}

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 .

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 .

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:

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

size_t vs unsigned int

size_t vs int

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);

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?

• 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.