Why do we specify size_t array size in C rather than just using integers? And what are the advantages to do so?

size_t can store the maximum size of a theoretically possible object of any type (including array).

size_t is commonly used for array indexing and loop counting. Programs that use other types, such as unsigned int, for array indexing may fail on, e.g. 64-bit systems when the index exceeds UINT_MAX or if it relies on 32-bit modular arithmetic.

(source)

What this means is that size_t is guaranteed to be able to hold any size/index count on any platform you compile for.

It is usually defined based on the target platform you compile for. For example the intsafe.h header included in the Windows SDK defines it as follows:

#ifdef _WIN64
typedef __int64             ptrdiff_t;
typedef unsigned __int64    size_t;
#else
typedef int            ptrdiff_t;
typedef unsigned int   size_t;
#endif

Using size_t directly means that you don't have to worry about changing the data type you use for indexing or holding object sizes when you recompile for a different architecture (for example, x86 vs x86-64).

EDIT: As @Eric Postpischil mentions in the comments, that actual wording of the C standard is different from the explanation I linked from cppreference.

Looking at the standard we can see a few mentions regarding size_t:

6.5.3.4 The sizeof and alignof operators

[...]

5 The value of the result of both operators is implementation-defined, and its type (an unsigned integer type) is size_t, defined in <stddef.h> (and other headers)

[...]

7.19 Common definitions <stddef.h>

[...]

size_t which is the unsigned integer type of the result of the sizeof operator;

The fact that size_t is the type of the value returned by the sizeof operator is the reason for which we can assume that "size_t can store the maximum size of a theoretically possible object of any type", but nowhere in the standard is this actually mandated. The standard also says the following about sizeof:

The sizeof operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type. The size is determined from the type of the operand. The result is an integer. If the type of the operand is a variable length array type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an integer constant

My interpretation (which may be wrong) is that you can't have an object for which the size does not fit into a size_t because in that case you can't have a working sizeof operator.

EDIT 2:

I'll just quote Eric Postpischil here:

There are simply limits as to what we can do with computers, and sometimes calculations go out of bounds. It is generally easy on modern hardware to define size_t so that sizeof always works, and you obviously cannot malloc a larger object, but you might construct one with a static array, in some esoteric C implementation with 16-bit size_t but 22-bit addresses.