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_t
es ptrdiff_t
, no int
. Pero el uso int
sigue siendo mucho mejor en la mayoría de los casos que size_t. ptrdiff_t
está long
en 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.
size_t
cuando debería puede conducir a errores de seguridad .