¿Cuándo usar std :: size_t?

Me pregunto si debería usar std::size_tbucles y otras cosas en lugar de int. Por ejemplo:

#include <cstdint>

int main()
{
    for (std::size_t i = 0; i < 10; ++i) {
        // std::size_t OK here? Or should I use, say, unsigned int instead?
    }
}

En general, ¿cuál es la mejor práctica con respecto a cuándo usar std::size_t?

Una buena regla general es para cualquier cosa que necesite comparar en la condición de bucle contra algo que es naturalmente un std::size_tsí mismo.

std::size_tes el tipo de cualquier sizeofexpresión y, como se garantiza, puede expresar el tamaño máximo de cualquier objeto (incluida cualquier matriz) en C ++. Por extensión, también se garantiza que sea lo suficientemente grande para cualquier índice de matriz, por lo que es un tipo natural para un bucle por índice sobre una matriz.

Si solo cuenta hasta un número, entonces puede ser más natural usar el tipo de la variable que contiene ese número o un into unsigned int(si es lo suficientemente grande) ya que estos deberían ser de un tamaño natural para la máquina.

size_tes el tipo de resultado del sizeofoperador.

Se usa size_tpara variables que modelan el tamaño o el índice en una matriz. size_ttransmite semántica: inmediatamente sabe que representa un tamaño en bytes o un índice, en lugar de simplemente otro entero.

Además, usar size_tpara representar un tamaño en bytes ayuda a hacer que el código sea portátil.

El size_ttipo está destinado a especificar el tamaño de algo, por lo que es natural usarlo, por ejemplo, obtener la longitud de una cadena y luego procesar cada carácter:

for (size_t i = 0, max = strlen (str); i < max; i++)
    doSomethingWith (str[i]);

Usted no tiene que estar atento a las condiciones de contorno, por supuesto, ya que es un tipo sin signo. El límite en el extremo superior no suele ser tan importante ya que el máximo suele ser grande (aunque es posible llegar allí). La mayoría de las personas simplemente usan un intpara ese tipo de cosas porque rara vez tienen estructuras o matrices que se vuelven lo suficientemente grandes como para exceder la capacidad de eso int.

Pero ten cuidado con cosas como:

for (size_t i = strlen (str) - 1; i >= 0; i--)

lo que causará un bucle infinito debido al comportamiento de ajuste de los valores sin signo (aunque he visto que los compiladores advierten sobre esto). Esto también puede ser aliviado por el (un poco más difícil de entender pero al menos inmune a los problemas de envoltura):

for (size_t i = strlen (str); i-- > 0; )

Al cambiar el decremento a un efecto secundario posterior a la verificación de la condición de continuación, esto verifica la continuación del valor antes del decremento, pero aún usa el valor decrementado dentro del bucle (por lo que el bucle se ejecuta en len .. 1lugar de len-1 .. 0).

Por definición, size_tes el resultado del sizeofoperador. size_tfue creado para referirse a los tamaños.

La cantidad de veces que haces algo (10, en tu ejemplo) no se trata de tamaños, entonces ¿por qué usarlo size_t? into unsigned intdebería estar bien.

Por supuesto, también es relevante lo que haces identro del bucle. Si lo pasa a una función que toma unsigned int, por ejemplo, pick unsigned int.

En cualquier caso, recomiendo evitar las conversiones de tipo implícito. Haga explícitas todas las conversiones de tipo.

size_tes una forma muy legible de especificar la dimensión de tamaño de un elemento: longitud de una cadena, cantidad de bytes que ocupa un puntero, etc. También es portátil en todas las plataformas: encontrará que 64 bits y 32 bits se comportan bien con las funciones del sistema y size_t- algo que unsigned intpodría no hacer (por ejemplo, cuándo debe usarunsigned long

respuesta corta:

casi nunca

respuesta larga:

Siempre que necesite tener un vector de carbón más grande que 2 gb en un sistema de 32 bits. En cualquier otro caso de uso, usar un tipo con signo es mucho más seguro que usar un tipo sin signo.

ejemplo:

std::vector<A> data;
[...]
// calculate the index that should be used;
size_t i = calc_index(param1, param2);
// doing calculations close to the underflow of an integer is already dangerous

// do some bounds checking
if( i - 1 < 0 ) {
    // always false, because 0-1 on unsigned creates an underflow
    return LEFT_BORDER;
} else if( i >= data.size() - 1 ) {
    // if i already had an underflow, this becomes true
    return RIGHT_BORDER;
}

// now you have a bug that is very hard to track, because you never 
// get an exception or anything anymore, to detect that you actually 
// return the false border case.

return calc_something(data[i-1], data[i], data[i+1]);

El equivalente firmado de size_tes ptrdiff_t, no int. Pero el uso intsigue siendo mucho mejor en la mayoría de los casos que size_t. ptrdiff_testá longen sistemas de 32 y 64 bits.

Esto significa que siempre debe convertir ay desde size_t cada vez que interactúa con un std :: container, lo que no es muy bonito. Pero en una conferencia nativa en curso, los autores de c ++ mencionaron que diseñar std :: vector con un size_t sin signo fue un error.

Si su compilador le da advertencias sobre conversiones implícitas de ptrdiff_t a size_t, puede hacerlo explícito con la sintaxis del constructor:

calc_something(data[size_t(i-1)], data[size_t(i)], data[size_t(i+1)]);

si solo desea iterar una colección, sin límites, utilice el rango basado en:

for(const auto& d : data) {
    [...]
}

aquí algunas palabras de Bjarne Stroustrup (autor de C ++) al volverse nativo

Para algunas personas, este error de diseño firmado / no firmado en el STL es motivo suficiente para no utilizar el std :: vector, sino una implementación propia.

Use std :: size_t para indexar / contar matrices de estilo C.

Para los contenedores STL, tendrá (por ejemplo) vector<int>::size_type, que debe usarse para indexar y contar elementos vectoriales.

En la práctica, generalmente son ints sin signo, pero no está garantizado, especialmente cuando se usan asignadores personalizados.

Pronto, la mayoría de las computadoras serán arquitecturas de 64 bits con SO de 64 bits que ejecutan programas que operan en contenedores de miles de millones de elementos. A continuación, se debe utilizar size_ten lugar de intcomo índice del bucle, de lo contrario su índice va a envolver alrededor de la 2 ^ 32: ésimo elemento, tanto en sistemas de 32 y 64 bits.

¡Prepárate para el futuro!

Cuando use size_t tenga cuidado con la siguiente expresión

size_t i = containner.find("mytoken");
size_t x = 99;
if (i-x>-1 && i+x < containner.size()) {
    cout << containner[i-x] << " " << containner[i+x] << endl;
}

Obtendrá falso en la expresión if, independientemente del valor que tenga para x. Me tomó varios días darme cuenta de esto (el código es tan simple que no hice la prueba de la unidad), aunque solo me llevó unos minutos determinar el origen del problema. No estoy seguro de que sea mejor hacer un lanzamiento o usar cero.

if ((int)(i-x) > -1 or (i-x) >= 0)

Ambas formas deberían funcionar. Aquí está mi prueba de funcionamiento

size_t i = 5;
cerr << "i-7=" << i-7 << " (int)(i-7)=" << (int)(i-7) << endl;

La salida: i-7 = 18446744073709551614 (int) (i-7) = - 2

Me gustaría los comentarios de otros.

size_t es devuelto por varias bibliotecas para indicar que el tamaño de ese contenedor no es cero. Lo usas cuando regresas: 0

Sin embargo, en el ejemplo anterior, hacer un loop en size_t es un error potencial. Considera lo siguiente:

for (size_t i = thing.size(); i >= 0; --i) {
  // this will never terminate because size_t is a typedef for
  // unsigned int which can not be negative by definition
  // therefore i will always be >= 0
  printf("the never ending story. la la la la");
}

El uso de enteros sin signo tiene el potencial de crear este tipo de problemas sutiles. Por lo tanto, prefiero usar size_t solo cuando interactúo con contenedores / tipos que lo requieren.

size_tes un tipo sin signo que puede contener el valor entero máximo para su arquitectura, por lo que está protegido contra desbordamientos de enteros debido al signo (el signo int 0x7FFFFFFFincrementado en 1 le dará -1) o el tamaño corto (el signo corto sin signo int 0xFFFF incrementado en 1 le dará 0).

Se utiliza principalmente en indexación de matrices / bucles / aritmética de direcciones, etc. Funciones como memset()y por igual size_tsolo aceptan , porque teóricamente puede tener un bloque de memoria de tamaño 2^32-1(en la plataforma de 32 bits).

Para tales bucles simples, no se moleste y use solo int.

size_t es un tipo integral sin signo, que puede representar el número entero más grande en su sistema. Úselo solo si necesita matrices muy grandes, matrices, etc.

Algunas funciones devuelven un size_t y su compilador le avisará si intenta hacer comparaciones.

Evite eso utilizando el tipo de datos firmado / sin firmar apropiado o simplemente escribiendo para un hack rápido.

size_t es unsigned int. así que cuando quieras int sin firmar puedes usarlo.

Lo uso cuando quiero especificar el tamaño de la matriz, el contador ect ...

void * operator new (size_t size); is a good use of it.