# Difference between size_t and unsigned int?

if it is use to represent non negative value so why we not using

`unsigned int`

instead of`size_t`

Because `unsigned int`

is not the only unsigned integer type. `size_t`

could be any of `unsigned char`

, `unsigned short`

, `unsigned int`

, `unsigned long`

or `unsigned long long`

, depending on the implementation.

Second question is that

`size_t`

and`unsigned int`

are interchangeable or not and if not then why?

They aren't interchangeable, for the reason explained above `^^`

.

And can anyone give me a good example of size_t and its brief working ?

I don't quite get what you mean by "its brief working". It works like any other unsigned type (in particular, like the type it's typedeffed to). You are encouraged to use `size_t`

when you are describing the size of an object. In particular, the `sizeof`

operator and various standard library functions, such as `strlen()`

, return `size_t`

.

Bonus: here's a good article about `size_t`

(and the closely related `ptrdiff_t`

type). It reasons very well why you should use it.

There are 5 standard unsigned integer types in C:

`unsigned char`

`unsigned short`

`unsigned int`

`unsigned long`

`unsigned long long`

with various requirements for their sizes and ranges (briefly, each type's range is a subset of the next type's range, but some of them may have the same range).

`size_t`

is a `typedef`

(i.e., an alias) for some unsigned type, (probably one of the above but possibly an *extended unsigned integer type*, though that's unlikely). It's the type yielded by the `sizeof`

operator.

On one system, it might make sense to use `unsigned int`

to represent sizes; on another, it might make more sense to use `unsigned long`

or `unsigned long long`

. (`size_t`

is unlikely to be either `unsigned char`

or `unsigned short`

, but that's permitted).

The purpose of `size_t`

is to relieve the programmer from having to worry about *which* of the predefined types is used to represent sizes.

Code that assumes `sizeof`

yields an `unsigned int`

would not be portable. Code that assumes it yields a `size_t`

is more likely to be portable.

`size_t`

has a specific restriction.

Quoting from http://www.cplusplus.com/reference/cstring/size_t/ :

Alias of one of the fundamental unsigned integer types.

It is a type able to represent the size of any object in bytes: size_t is the type returned by the sizeof operator and is widely used in the standard library to represent sizes and counts.

It is not interchangeable with `unsigned int`

because the size of `int`

is specified by the data model. For example LLP64 uses a 32-bit `int`

and ILP64 uses a 64-bit `int`

.