Números não assinados versus assinados como índices

Question

Qual é a justificativa para o uso de números assinados como índices no .NET?

No Python, você pode indexar a partir do final de uma matriz enviando números negativos, mas esse não é o caso no .NET. Não é fácil para o .NET adicionar esse recurso posteriormente, pois pode quebrar outro código, talvez usando regras especiais (sim, uma má idéia, mas acho que acontece) na indexação.

Não que eu tenha precisado indexar matrizes com mais de 2.147.483.647 de tamanho, mas realmente não consigo entender por que eles escolhem números assinados.

Pode ser porque é mais normal usar números assinados no código?

EDIT: Acabei de encontrar estes links:

Os perigos da iteração não assinada em C/C ++

Comprimentos e índices de palavras assinadas

Edit2: OK, algumas outras boas razões do tópico Matthew Flaschen postou:

• Razões históricas como uma linguagem do tipo C
• Interop com c

Answer 1

Para simplificar, é claro. Você gosta problema Fazendo tamanho aritmético com ints não assinados?

Answer 2

Pode ser para a longa tradição de usar um valor abaixo de 0 como um índice inválido. Métodos como String.IndexOf Return -1 Se o elemento não for encontrado. Portanto, o valor de retorno deve ser assinado. Se os consumidores de índices exigiriam valores não assinados, você precisaria a) Verifique e B) o valor para usá-lo. Com índices assinados, você só precisa do cheque.

Answer 3

Não assinado não é compatível com CLS.

Answer 4

A utilidade primária dos números não assinados surge ao compor números maiores de menores e vice -versa. Por exemplo, se alguém recebe quatro bytes não assinados de uma conexão e deseja considerar seu valor, tomado como um todo, como um número inteiro de 32 bits, usando tipos não assinados significa que se pode simplesmente dizer:

  value = byte0 | (byte1*256) | (byte2*65536) | (byte3*16777216);

Por outro lado, se os bytes fossem assinados, uma expressão como a acima seria mais complicada.

Não tenho certeza se realmente vejo qualquer motivo para um idioma projetado hoje em dia para não incluir versões não assinadas de todos os tipos mais curtos do que o tipo inteiro mais longo, com a semântica que todo número inteiro (significa ) Operações que se encaixam inteiramente dentro do maior tipo assinado serão executadas por padrão como se Eles estavam operando nesse tipo. Incluir uma versão não assinada do maior tipo assinado complicaria a especificação do idioma (já que seria necessário especificar quais operações deveriam se encaixar no alcance do tipo assinado e quais operações devem se encaixar dentro do alcance do tipo não assinado), mas, caso contrário, deve haver Não há problema em projetar um idioma para que if (unsigned1 - unsigned2 > unsigned3) produziria um resultado "numericamente correto", mesmo quando unsigned2 é melhor que unsigned1 Se alguém quer um envoltório não assinado, especificaria explicitamente if ((Uint32)(unsigned1 - unsigned2) > unsigned3)]. Um idioma que especificou esse comportamento certamente seria uma grande melhoria em relação à bagunça que existe em C (justificável, dada a sua história), C#ou VB.net.