resposta curta:
quase nunca
resposta longa:
Sempre que você precisar de um vetor de char maior que 2gb em um sistema de 32 bits. Em todos os outros casos de uso, usar um tipo assinado é muito mais seguro do que usar um tipo não assinado.
exemplo:
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]);
O equivalente assinado de size_t
é ptrdiff_t
, não int
. Mas o uso int
ainda é muito melhor na maioria dos casos do que size_t. ptrdiff_t
élong
em sistemas de 32 e 64 bits.
Isso significa que você sempre precisa converter de e para size_t sempre que interagir com um std :: containers, o que não é muito bonito. Mas em uma conferência nativa em andamento, os autores do c ++ mencionaram que projetar std :: vector com um size_t não assinado foi um erro.
Se o seu compilador fornecer avisos sobre conversões implícitas de ptrdiff_t para size_t, você poderá explicitá-lo com a sintaxe do construtor:
calc_something(data[size_t(i-1)], data[size_t(i)], data[size_t(i+1)]);
se quiser apenas iterar uma coleção, sem limites, use o intervalo com base em:
for(const auto& d : data) {
[...]
}
aqui algumas palavras de Bjarne Stroustrup (autor C ++) em nativo
Para algumas pessoas, esse erro de design assinado / não assinado no STL é motivo suficiente, para não usar o std :: vector, mas uma implementação própria.
size_t
quando necessário pode levar a erros de segurança .