¿Qué es size_t en C?

me estoy confundiendo con size_t en C. Sé que es devuelto por el sizeof operador. ¿Pero qué es exactamente? ¿Es un tipo de datos?

digamos que tengo un for círculo:

for(i = 0; i < some_size; i++)

debo usar int i; o size_t i;?

De Wikipedia:

Según la norma ISO C de 1999 (C99), size_t es un tipo entero sin signo de al menos 16 bits (consulte las secciones 7.17 y 7.18.3).

size_tes un tipo de datos sin firmar definido por varios estándares C/C++, por ejemplo, el estándar C99 ISO/IEC 9899, ​​que se define en stddef.h.1 Se puede importar aún más mediante la inclusión de
stdlib.h ya que este archivo incluye sub internamente stddef.h.

Este tipo se utiliza para representar el tamaño de un objeto. Las funciones de biblioteca que toman o devuelven tamaños esperan que sean de tipo o tengan el tipo de retorno de size_t. Además, el operador basado en compilador más utilizado, sizeof, debe evaluarse como un valor constante que sea compatible con
size_t.

Como implicación, size_t es un tipo garantizado para contener cualquier índice de matriz.

size_t es un tipo sin firmar. Por lo tanto, no puede representar ningún valor negativo (<0). Lo usa cuando está contando algo y está seguro de que no puede ser negativo. Por ejemplo, strlen() devuelve un size_t porque la longitud de una cadena tiene que ser al menos 0.

En su ejemplo, si su índice de bucle va a ser siempre mayor que 0, podría tener sentido usar size_to cualquier otro tipo de datos sin firmar.

Cuando usas un size_t objeto, debe asegurarse de que en todos los contextos en los que se usa, incluida la aritmética, desea valores no negativos. Por ejemplo, digamos que tienes:

size_t s1 = strlen(str1);
size_t s2 = strlen(str2);

y quieres encontrar la diferencia de las longitudes de str2 y str1. Tú no puedes hacer:

int diff = s2 - s1; /* bad */

Esto se debe a que el valor asignado a diff siempre va a ser un número positivo, incluso cuando s2 < s1, porque el cálculo se realiza con tipos sin firmar. En este caso, dependiendo de cuál sea su caso de uso, es mejor que use int (o long long) por s1 y s2.

Hay algunas funciones en C/POSIX que podrían/deberían usar size_t, pero no por razones históricas. Por ejemplo, el segundo parámetro a fgets idealmente debería ser size_tpero es int.

size_t es un tipo que puede contener cualquier índice de matriz.

Dependiendo de la implementación, puede ser cualquiera de:

unsigned char

unsigned short

unsigned int

unsigned long

unsigned long long

Así es cómo size_t se define en stddef.h de mi maquina:

typedef unsigned long size_t;

Para entrar en por qué size_t necesario para existir y cómo llegamos aquí:

En términos pragmáticos, size_t y ptrdiff_t se garantiza que tengan 64 bits de ancho en una implementación de 64 bits, 32 bits de ancho en una implementación de 32 bits, y así sucesivamente. No podían forzar ningún tipo existente para que significara eso, en cada compilador, sin romper el código heredado.

UN size_t o ptrdiff_t no es necesariamente lo mismo que un intptr_t o uintptr_t. Eran diferentes en ciertas arquitecturas que todavía estaban en uso cuando size_t y ptrdiff_t se agregaron al estándar a fines de la década de 1980 y se volvieron obsoletos cuando C99 agregó muchos tipos nuevos pero aún no se han ido (como Windows de 16 bits). El x86 en modo protegido de 16 bits tenía una memoria segmentada donde la matriz o estructura más grande posible podía tener solo 65 536 bytes de tamaño, pero un far el puntero debía tener 32 bits de ancho, más ancho que los registros. Sobre estos, intptr_t habría sido de 32 bits de ancho, pero size_t y ptrdiff_t podría tener 16 bits de ancho y caber en un registro. ¿Y quién sabía qué tipo de sistema operativo podría escribirse en el futuro? En teoría, la arquitectura i386 ofrece un modelo de segmentación de 32 bits con punteros de 48 bits que ningún sistema operativo ha utilizado nunca.

El tipo de un desplazamiento de memoria no pudo ser long porque demasiado código heredado asume que long tiene exactamente 32 bits de ancho. Esta suposición incluso se incorporó en las API de UNIX y Windows. Desafortunadamente, muchos otros códigos heredados también asumieron que un long es lo suficientemente ancho para contener un puntero, un desplazamiento de archivo, la cantidad de segundos que han transcurrido desde 1970, etc. POSIX ahora proporciona una forma estandarizada de forzar que la última suposición sea cierta en lugar de la primera, pero tampoco es una suposición portátil.

no puede ser int porque solo un pequeño puñado de compiladores en los años 90 hizo int 64 bits de ancho. Entonces realmente se pusieron raros al mantener long 32 bits de ancho. La siguiente revisión de la Norma la declaró ilegal para int ser más ancho que longpero int todavía tiene 32 bits de ancho en la mayoría de los sistemas de 64 bits.

no puede ser long long intque de todos modos se agregó más tarde, ya que se creó para tener al menos 64 bits de ancho incluso en sistemas de 32 bits.

Entonces, se necesitaba un nuevo tipo. Incluso si no lo fuera, todos esos otros tipos significaban algo más que un desplazamiento dentro de una matriz u objeto. Y si hubo una lección del fiasco de la migración de 32 a 64 bits, fue ser específico sobre qué propiedades debe tener un tipo, y no usar uno que significa cosas diferentes en diferentes programas.

size_t y int no son intercambiables. Por ejemplo, en Linux de 64 bits size_t tiene un tamaño de 64 bits (es decir, sizeof(void*)) pero int es de 32 bits.

También tenga en cuenta que size_t está sin firmar. Si necesita una versión firmada, entonces hay ssize_t en algunas plataformas y sería más relevante para su ejemplo.

Como regla general, sugeriría usar int para la mayoría de los casos generales y solo use size_t/ssize_t cuando hay una necesidad específica para ello (con mmap() por ejemplo).

Si eres del tipo empírico,

echo | gcc -E -xc -include 'stddef.h' - | grep size_t

Salida para Ubuntu 14.04 GCC 4.8 de 64 bits:

typedef long unsigned int size_t;

Tenga en cuenta que stddef.h es proporcionado por GCC y no por glibc bajo src/gcc/ginclude/stddef.h en CCG 4.2.

Interesantes apariciones del C99

• malloc acepta size_t como argumento, por lo que determina el tamaño máximo que se puede asignar.

  Y como también es devuelto por sizeofcreo que limita el tamaño máximo de cualquier matriz.

  Ver también: ¿Cuál es el tamaño máximo de una matriz en C?

La página de manual para tipos.h dice:

size_t debe ser un tipo entero sin signo