# 13. Tamanho de Tipo

Cada tipo de dado possui um tamanho, que é o número de bytes (veja [*Armazenamento e Dados*](https://mentebinaria.gitbook.io/manual-da-linguagem-gnu-c/3.-armazenamento-e-dados)) que ele ocupa na memória. Para referenciar esse tamanho em um programa C, usa-se `sizeof`. Existem duas formas de utilizá-lo:

**`sizeof expressão`**\
Essa forma retorna o tamanho da **expressão**, com base em seu tipo de dado. Ela **não** calcula o valor da expressão — apenas seu tamanho —, então, se a expressão contiver efeitos colaterais ou chamadas de função, eles **não** serão executados. Portanto, `sizeof` é sempre uma operação em tempo de compilação e não tem custo em tempo de execução.

Não é permitido usar como operando de `sizeof` um valor que seja um campo de bits (veja [*Campos de Bits*](#user-content-fn-1)[^1]).

Por exemplo:

```c
double a;
i = sizeof a + 10;
```

inicializa `i` com 18 na maioria dos computadores, porque `a` ocupa 8 bytes.

Veja como determinar o número de elementos de um array `array`:

```c
(sizeof array / sizeof array[0])
```

A expressão `sizeof array` retorna o tamanho do array, e **não** o tamanho de um ponteiro para um elemento. No entanto, se a expressão for um parâmetro de função declarado como array, essa variável na verdade tem tipo de ponteiro (veja [*Parâmetro de Array como Ponteiro*](#user-content-fn-1)[^1]), portanto o resultado será o tamanho desse ponteiro.

**`sizeof (tipo)`**\
Essa forma retorna o tamanho de **tipo**. Por exemplo:

```c
i = sizeof (double) + 10;
```

é equivalente ao exemplo anterior.

Não é permitido aplicar `sizeof` a um tipo incompleto (veja [*Tipos Incompletos*](#user-content-fn-1)[^1]), nem a `void`. Aplicá-lo a um tipo de função retorna 1 no GNU C, o que permite que a adição de um inteiro a um ponteiro de função funcione como desejado (veja [*Aritmética com Ponteiros*](#user-content-fn-1)[^1]).

***

**Aviso:** Ao usar `sizeof` com um **tipo** em vez de uma expressão, é obrigatório escrever parênteses em torno do tipo.

**Aviso:** Ao aplicar `sizeof` ao resultado de um cast (veja [*Conversão Explícita de Tipo*](#user-content-fn-1)[^1]), também é necessário colocar parênteses ao redor da expressão de cast para evitar ambiguidade na gramática da linguagem C. Especificamente:

```c
sizeof (int) -x
```

é interpretado como:

```c
(sizeof (int)) - x
```

Se o que se deseja é:

```c
sizeof ((int) -x)
```

deve-se escrever exatamente assim, com os parênteses adicionais.

***

O tipo do valor retornado por `sizeof` é sempre um tipo inteiro **sem sinal**; qual exatamente depende da máquina. O cabeçalho `stddef.h` define o nome `size_t` como um alias (`typedef`) para esse tipo. Veja [*Definindo Nomes com Typedef*](#user-content-fn-1)[^1].

[^1]: Pendente de tradução