unsigned int vs. size_t

Percebo que o código C e C ++ moderno parece usar em size_tvez de int/ unsigned intpraticamente em todos os lugares - desde parâmetros para funções de string C até o STL. Estou curioso para saber o motivo e os benefícios que isso traz.

O size_ttipo é o tipo inteiro não assinado que é o resultado do sizeofoperador (e do offsetofoperador); portanto, é garantido que seja grande o suficiente para conter o tamanho do maior objeto que seu sistema pode manipular (por exemplo, uma matriz estática de 8 GB).

O size_ttipo pode ser maior que, igual a ou menor que um unsigned int, e seu compilador pode fazer suposições sobre isso para otimização.

Você pode encontrar informações mais precisas no padrão C99, seção 7.17, cujo rascunho está disponível na Internet em formato pdf , ou no padrão C11, seção 7.19, também disponível como rascunho em pdf .

O clássico C (o dialeto inicial de C descrito por Brian Kernighan e Dennis Ritchie em The C Programming Language, Prentice-Hall, 1978) não forneceu size_t. O comitê de padrões C apresentado size_tpara eliminar um problema de portabilidade

Explicado em detalhes no site incorporado.com (com um exemplo muito bom)

Em resumo, size_tnunca é negativo e maximiza o desempenho porque é typedef para ser o tipo inteiro não assinado que é grande o suficiente - mas não muito grande - para representar o tamanho do maior objeto possível na plataforma de destino.

Os tamanhos nunca devem ser negativos e, de fato, size_tsão do tipo não assinado. Além disso, como size_tnão é assinado, é possível armazenar números aproximadamente duas vezes maiores que o tipo assinado correspondente, porque podemos usar o bit de sinal para representar a magnitude, como todos os outros bits do número inteiro não assinado. Quando ganhamos mais um bit, multiplicamos o intervalo de números que podemos representar por um fator de cerca de dois.

Então, você pergunta, por que não usar apenas um unsigned int? Pode não ser capaz de armazenar números grandes o suficiente. Em uma implementação com unsigned int32 bits, o maior número que pode representar é 4294967295. Alguns processadores, como o IP16L32, podem copiar objetos maiores que 4294967295bytes.

Então, você pergunta, por que não usar um unsigned long int? Exige um pedágio de desempenho em algumas plataformas. O padrão C exige que um longocupe pelo menos 32 bits. Uma plataforma IP16L32 implementa cada comprimento de 32 bits como um par de palavras de 16 bits. Quase todos os operadores de 32 bits nessas plataformas exigem duas instruções, se não mais, porque trabalham com os 32 bits em dois pedaços de 16 bits. Por exemplo, mover um comprimento de 32 bits geralmente requer duas instruções da máquina - uma para mover cada pedaço de 16 bits.

O uso size_tevita esse custo de desempenho. De acordo com este artigo fantástico , "Type size_té um typedef que é um apelido para algum tipo de número inteiro não assinado, normalmente unsigned intou unsigned long, mas possivelmente até unsigned long long. Cada implementação do Standard C deve escolher o número inteiro não assinado que é grande o suficiente - mas não maior que o necessário - para representar o tamanho do maior objeto possível na plataforma de destino ".

O tipo size_t é o tipo retornado pelo operador sizeof. É um número inteiro não assinado capaz de expressar o tamanho em bytes de qualquer intervalo de memória suportado na máquina host. É (normalmente) relacionado a ptrdiff_t, em que ptrdiff_t é um valor inteiro assinado, de modo que sizeof (ptrdiff_t) e sizeof (size_t) sejam iguais.

Ao escrever o código C, você sempre deve usar size_t sempre que lidar com intervalos de memória.

O tipo int, por outro lado, é basicamente definido como o tamanho do valor inteiro (assinado) que a máquina host pode usar para executar com eficiência a aritmética inteira. Por exemplo, em muitos computadores mais antigos do tipo PC, o valor sizeof (size_t) seria 4 (bytes), mas sizeof (int) seria 2 (byte). A aritmética de 16 bits era mais rápida que a aritmética de 32 bits, embora a CPU pudesse lidar com um espaço de memória (lógico) de até 4 GiB.

Use o tipo int somente quando você se preocupa com a eficiência, pois sua precisão real depende muito das opções do compilador e da arquitetura da máquina. Em particular, o padrão C especifica os seguintes invariantes: sizeof (char) <= sizeof (short) <= sizeof (int) <= sizeof (long) não colocando outras limitações na representação real da precisão disponível ao programador para cada um dos esses tipos primitivos.

Nota: NÃO é o mesmo que em Java (que realmente especifica a precisão de bits para cada um dos tipos 'char', 'byte', 'short', 'int' e 'long').

Digite size_t deve ser grande o suficiente para armazenar o tamanho de qualquer objeto possível. Int não assinado não precisa atender a essa condição.

Por exemplo, nos sistemas de 64 bits, int e unsigned int podem ter 32 bits de largura, mas size_t deve ser grande o suficiente para armazenar números maiores que 4G

Este trecho do manual glibc 0.02 também pode ser relevante ao pesquisar o tópico:

Há um problema em potencial com o tipo size_t e as versões do GCC anteriores à liberação 2.4. O ANSI C exige que size_t sempre seja um tipo não assinado. Para compatibilidade com os arquivos de cabeçalho dos sistemas existentes, o GCC define size_t em stddef.h' to be whatever type the system'ssys / types.h 'como ele é. A maioria dos sistemas Unix que definem size_t em `sys / types.h ', definem como um tipo assinado. Algum código na biblioteca depende do tamanho_t ser um tipo não assinado e não funcionará corretamente se estiver assinado.

O código da biblioteca GNU C que espera que size_t não seja assinado está correto. A definição de size_t como um tipo assinado está incorreta. Planejamos que na versão 2.4, o GCC sempre defina size_t como um tipo não assinado e o fixincludes' script will massage the system'ssys / types.h 'para não entrar em conflito com isso.

Enquanto isso, resolvemos esse problema dizendo ao GCC explicitamente para usar um tipo não assinado para size_t ao compilar a biblioteca GNU C. O `configure 'detectará automaticamente o tipo que o GCC usa para size_t organizar para substituí-lo, se necessário.

Se meu compilador estiver definido como 32 bits, size_tnão será outro senão um typedef para unsigned int. Se meu compilador estiver definido como 64 bits, size_tnada mais será do que um typedef para unsigned long long.

size_t é o tamanho de um ponteiro.

Portanto, em 32 bits ou no modelo comum ILP32 (inteiro, longo, ponteiro) size_t é 32 bits. e em 64 bits ou no modelo LP64 (longo, ponteiro) comum size_t é de 64 bits (números inteiros ainda são 32 bits).

Existem outros modelos, mas esses são os que o g ++ usa (pelo menos por padrão)