O que é size_t em C?

Estou me confundindo com size_tC. Sei que ele é retornado pelo sizeofoperador. Mas o que exatamente é isso? É um tipo de dados?

Digamos que eu tenho um forloop:

for(i = 0; i < some_size; i++)

Devo usar int i;ou size_t i;?

Da Wikipedia :

De acordo com a norma ISO C de 1999 (C99), size_té um tipo inteiro não assinado de pelo menos 16 bits (consulte as seções 7.17 e 7.18.3).

size_té um tipo de dados não assinado definido por vários padrões C / C ++, por exemplo, o padrão C99 ISO / IEC 9899, ​​definido em stddef.h. 1 Pode ser importado ainda mais pela inclusão de stdlib.hcomo este arquivo inclui internamente stddef.h.

Este tipo é usado para representar o tamanho de um objeto. As funções de biblioteca que aceitam ou retornam tamanhos esperam que sejam do tipo ou tenham o tipo de retorno size_t. Além disso, o tamanho do operador baseado em compilador usado com mais freqüência deve ser avaliado como um valor constante compatível com size_t.

Como implicação, size_té um tipo garantido para manter qualquer índice de matriz.

size_té um tipo não assinado. Portanto, não pode representar valores negativos (<0). Você o usa quando está contando algo e tem certeza de que não pode ser negativo. Por exemplo, strlen()retorna a size_tporque o comprimento de uma string deve ser pelo menos 0.

No seu exemplo, se seu índice de loop sempre for maior que 0, pode fazer sentido usar size_tou qualquer outro tipo de dados não assinado.

Ao usar um size_tobjeto, você deve garantir que, em todos os contextos em que ele é usado, incluindo aritmética, deseja valores não negativos. Por exemplo, digamos que você tenha:

size_t s1 = strlen(str1);
size_t s2 = strlen(str2);

e você deseja encontrar a diferença dos comprimentos de str2e str1. Você não pode fazer:

int diff = s2 - s1; /* bad */

Isso ocorre porque o valor atribuído diffsempre será um número positivo, mesmo quando s2 < s1, porque o cálculo é feito com tipos não assinados. Nesse caso, dependendo do seu caso de uso, é melhor usar int(ou long long) para s1e s2.

Existem algumas funções no C / POSIX que podem / devem usar size_t, mas não por motivos históricos. Por exemplo, o segundo parâmetro para fgetsideal deve ser size_t, mas é int.

size_t é um tipo que pode conter qualquer índice de matriz.

Dependendo da implementação, pode ser um dos seguintes:

unsigned char

unsigned short

unsigned int

unsigned long

unsigned long long

Veja como size_té definido na stddef.hminha máquina:

typedef unsigned long size_t;

Se você é do tipo empírico ,

echo | gcc -E -xc -include 'stddef.h' - | grep size_t

Saída para o Ubuntu 14.04 GCC 4.8 de 64 bits:

typedef long unsigned int size_t;

Observe que stddef.hé fornecido pelo GCC e não glibc src/gcc/ginclude/stddef.hno GCC 4.2.

Aparições C99 interessantes

• malloctoma size_tcomo argumento, portanto, determina o tamanho máximo que pode ser alocado.

  E como também é retornado por sizeof, acho que limita o tamanho máximo de qualquer matriz.

  Consulte também: Qual é o tamanho máximo de uma matriz em C?

A página de manual do types.h diz:

size_t deve ser um tipo inteiro não assinado

Como ninguém ainda o mencionou, a principal significância linguística de size_té que o sizeofoperador retorna um valor desse tipo. Da mesma forma, o significado primário de ptrdiff_té que subtrair um ponteiro de outro produzirá um valor desse tipo. As funções de biblioteca que o aceitam fazem isso porque permitirão que essas funções funcionem com objetos cujo tamanho exceda UINT_MAX em sistemas onde esses objetos possam existir, sem forçar os chamadores a desperdiçarem o código que passa um valor maior que "int não assinado" em sistemas onde o tipo maior seria suficiente para todos os objetos possíveis.

Para explicar por que é size_tnecessário existir e como chegamos aqui:

Em termos pragmáticos, size_te ptrdiff_tsão garantidos para ser 64 bits de largura em uma implementação de 64 bits, 32 bits de largura em uma implementação de 32 bits, e assim por diante. Eles não podiam forçar nenhum tipo existente a significar isso, em todos os compiladores, sem quebrar o código legado.

Um size_tou ptrdiff_tnão é necessariamente o mesmo que um intptr_tou uintptr_t. Eles eram diferentes em algumas arquiteturas que ainda estavam em uso quando size_te ptrdiff_tforam adicionados ao padrão no final dos anos 80, e tornando-se obsoleto quando C99 acrescentou muitos novos tipos, mas ainda não passaram (como Windows de 16 bits). O x86 no modo protegido de 16 bits tinha uma memória segmentada em que a maior matriz ou estrutura possível podia ter apenas 65.536 bytes de tamanho, mas um farponteiro precisava ter 32 bits de largura, mais largo que os registros. Nesses, intptr_tteria 32 bits de largura, mas size_teptrdiff_tpode ter 16 bits de largura e caber em um registro. E quem sabia que tipo de sistema operacional poderia ser escrito no futuro? Em teoria, a arquitetura i386 oferece um modelo de segmentação de 32 bits com ponteiros de 48 bits que nenhum sistema operacional jamais usou.

O tipo de deslocamento de memória não pode ser longporque muito código legado supõe que longseja exatamente 32 bits de largura. Essa suposição foi incorporada às APIs do UNIX e do Windows. Infelizmente, muitos outros códigos herdados também assumiram que a longé grande o suficiente para conter um ponteiro, um deslocamento de arquivo, o número de segundos decorridos desde 1970 e assim por diante. O POSIX agora fornece uma maneira padronizada de forçar a última suposição a ser verdadeira, em vez da anterior, mas nenhuma é uma suposição portátil a ser feita.

Não poderia ser intporque apenas um punhado de compiladores nos anos 90 tinham int64 bits de largura. Então eles realmente ficaram estranhos mantendo long32 bits de largura. A próxima revisão do Padrão declarou ilegal intque fosse maior do que long, mas intainda tem 32 bits de largura na maioria dos sistemas de 64 bits.

Não poderia ser long long int, o que de qualquer maneira foi adicionado mais tarde, pois foi criado para ter pelo menos 64 bits de largura, mesmo em sistemas de 32 bits.

Portanto, era necessário um novo tipo. Mesmo que não fosse, todos esses outros tipos significavam algo diferente de um deslocamento dentro de uma matriz ou objeto. E se houvesse uma lição do fiasco da migração de 32 para 64 bits, seria específico sobre quais propriedades um tipo precisava ter, e não usar uma que significasse coisas diferentes em programas diferentes.

size_te intnão são intercambiáveis. Por exemplo, no Linux de size_t64 bits, o tamanho é de 64 bits (ou seja sizeof(void*)), mas inté de 32 bits.

Observe também que size_tnão está assinado. Se você precisar de uma versão assinada, existe ssize_tem algumas plataformas e isso seria mais relevante para o seu exemplo.

Como regra geral, eu sugeriria o uso intpara a maioria dos casos gerais e somente o uso size_t/ ssize_tquando houver uma necessidade específica (com, mmap()por exemplo).

Em geral, se você está começando em 0 e subindo, sempre use um tipo não assinado para evitar um estouro levando você a uma situação de valor negativo. Isso é extremamente importante, porque se os limites de sua matriz forem inferiores ao máximo do seu loop, mas o loop máximo for superior ao máximo do seu tipo, você contornará negativo e poderá ocorrer uma falha de segmentação (SIGSEGV ) Portanto, em geral, nunca use int para um loop começando em 0 e subindo. Use um não assinado.

size_t é um tipo de dados inteiro não assinado. Nos sistemas que usam a GNU C Library, isso será int sem sinal ou int longo sem sinal. size_t é comumente usado para indexação de array e contagem de loop.

size_t ou qualquer tipo não assinado pode ser visto como variável de loop, pois as variáveis ​​de loop geralmente são maiores ou iguais a 0.

Quando usamos um objeto size_t , precisamos garantir que, em todos os contextos em que ele é usado, incluindo aritmética, desejemos apenas valores não negativos. Por exemplo, o programa a seguir daria definitivamente o resultado inesperado:

// C program to demonstrate that size_t or
// any unsigned int type should be used 
// carefully when used in a loop

#include<stdio.h>
int main()
{
const size_t N = 10;
int a[N];

// This is fine
for (size_t n = 0; n < N; ++n)
a[n] = n;

// But reverse cycles are tricky for unsigned 
// types as can lead to infinite loop
for (size_t n = N-1; n >= 0; --n)
printf("%d ", a[n]);
}

Output
Infinite loop and then segmentation fault

size_té um tipo de dados inteiro não assinado que pode atribuir apenas 0 e valores maiores que 0. Ele mede bytes do tamanho de qualquer objeto e retorna pelo sizeofoperador. consté a representação da sintaxe de size_t, mas sem constvocê pode executar o programa.

const size_t number;

size_tusado regularmente para indexação de array e contagem de loop. Se o compilador é 32-bitque iria trabalhar unsigned int. Se o compilador é 64-bitque iria trabalhar unsigned long long inttambém. Existe para o tamanho máximo de size_tacordo com o tipo de compilador.

size_tjá definem no <stdio.h>arquivo de cabeçalho, mas também pode definir por <stddef.h>, <stdlib.h>, <string.h>, <time.h>, <wchar.h>cabeçalhos.

• Exemplo (com const)

#include <stdio.h>

int main()
{
    const size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

Resultado -: size = 800

• Exemplo (sem const)

#include <stdio.h>

int main()
{
    size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

Resultado -: size = 800

Do meu entendimento, size_té um unsignednúmero inteiro cujo tamanho de bit é grande o suficiente para armazenar um ponteiro da arquitetura nativa.

Assim:

sizeof(size_t) >= sizeof(void*)