C Tipos de Dados

Toda variável em C tem um tipo, escolhido quando ela é criada: int idade, double altura. O tipo diz que espécie de valor cabe na caixa, quanto espaço ela ocupa na memória e qual letra o printf usa para mostrá-la. Esta aula é o mapa: mostra os tipos que você vai usar o tempo todo, o tamanho real de cada um e como escolher. Cada família tem depois a sua própria aula.

Todos os programas desta aula foram compilados com o gcc 15.2 na máquina fictícia da Ana (usuária ana, computador notebook, um PC comum de 64 bits), na pasta ~/c, com o comando padrão do guia: gcc -std=c23 -Wall -Wextra arquivo.c -o programa.

A ideia: cada coisa no seu recipiente

Na cozinha, cada coisa tem o seu recipiente: ovos vão na caixa de ovos, leite vai na garrafa, açúcar vai no pote. Você até consegue pôr leite na caixa de ovos, mas vai dar errado. E ninguém guarda uma colher de sal num balde.

Os tipos do C são esses recipientes. Escolher o tipo é responder três perguntas:

1. Que espécie de informação? Número inteiro, número com vírgula, uma letra, sim/não.
2. De que tamanho? A idade de uma pessoa cabe num recipiente pequeno; a população do mundo precisa de um grande.
3. Com que precisão? Um preço precisa de centavos; o número de alunos, não.

1. Os quatro tipos do dia a dia

#include <stdio.h>

int main(void) {
    int idade = 29;
    double altura = 1.65;
    char inicial = 'A';
    bool cliente_vip = true;
    printf("Idade: %d\n", idade);
    printf("Altura: %.2f\n", altura);
    printf("Inicial: %c\n", inicial);
    printf("VIP: %d\n", cliente_vip);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra tipos.c -o tipos
$ ./tipos
Idade: 29
Altura: 1.65
Inicial: A
VIP: 1                   « true aparece como 1 (a aula bool explica)

Com esses quatro você escreve quase todos os programas do Nível 1. Os outros tipos são variações de tamanho e de precisão dos mesmos números. O bool sem #include é novidade do C23; em código mais antigo você vai ver #include <stdbool.h> no topo (a aula Booleanos conta a história).

#include <stdio.h>

int main(void) {
    int idade = 29;
    double altura = 1.65;
    char inicial = 'A';
    printf("Idade: %d\n", idade);
    printf("Altura: %.2f\n", altura);
    printf("Inicial: %c\n", inicial);
    return 0;
}

#include <stdio.h>

int main(void) {
    int idade = 29;
    double altura = 1.65;
    char inicial = 'A';
    bool pago = false;
    printf("Idade: %d\n", idade);
    printf("Altura: %.2f\n", altura);
    printf("Inicial: %c\n", inicial);
    printf("Pago: %d\n", pago);
    return 0;
}

2. Medir o tamanho: sizeof

A memória do computador é medida em bytes. Um byte é um pedacinho de memória com 8 bits (cada bit é um 0 ou 1) e consegue guardar 256 valores diferentes. Quanto mais bytes um tipo tem, maiores (ou mais precisos) os números que ele guarda.

O operador sizeof ("tamanho de") responde quantos bytes um tipo ocupa. O resultado é de um tipo especial para tamanhos, o size_t, que o printf mostra com %zu (z de size, u de unsigned, "sem sinal"; detalhes em Tamanho dos Tipos):

#include <stdio.h>

int main(void) {
    printf("bool:        %zu\n", sizeof(bool));
    printf("char:        %zu\n", sizeof(char));
    printf("short:       %zu\n", sizeof(short));
    printf("int:         %zu\n", sizeof(int));
    printf("long:        %zu\n", sizeof(long));
    printf("long long:   %zu\n", sizeof(long long));
    printf("float:       %zu\n", sizeof(float));
    printf("double:      %zu\n", sizeof(double));
    printf("long double: %zu\n", sizeof(long double));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra tamanhos.c -o tamanhos
$ ./tamanhos
bool:        1
char:        1
short:       2
int:         4
long:        8
long long:   8
float:       4
double:      8
long double: 16

Os espaços depois dos nomes ("int: ") estão lá só para alinhar a saída em colunas.

A tabela completa

Os limites exatos de cada inteiro (com limits.h) estão em Inteiros; a precisão dos números com vírgula, em float e double. A referência de tipos junta tudo numa página de consulta, e Formatos do printf explica cada letra.

Os valores escritos também têm tipo

Um número escrito direto no código (um literal) também tem tipo. O C decide pelo jeito de escrever:

#include <stdio.h>

int main(void) {
    printf("%zu %zu %zu %zu %zu %zu\n",
           sizeof(42), sizeof(4.5), sizeof(4.5f), sizeof('A'), sizeof(true), sizeof("Ana"));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra literais.c -o literais
$ ./literais
4 8 4 4 1 4

3. E o texto? O C não tem tipo string

Quem vem de Python, JavaScript ou mesmo do C++ procura um tipo string para guardar nomes e frases. Em C, ele não existe:

#include <stdio.h>

int main(void) {
    string nome = "Ana";
    printf("%s\n", nome);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra semstring.c -o semstring
semstring.c: In function ‘main’:
semstring.c:4:5: error: unknown type name ‘string’; did you mean ‘stdin’?
    4 |     string nome = "Ana";
      |     ^~~~~~
      |     stdin
semstring.c:4:19: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
    4 |     string nome = "Ana";
      |                   ^~~~~
semstring.c:5:14: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int’ [-Wformat=]
    5 |     printf("%s\n", nome);
      |             ~^     ~~~~
      |              |     |
      |              |     int
      |              char *
      |             %d

unknown type name ‘string’

"Nome de tipo desconhecido: string". O did you mean ‘stdin’? é um chute do gcc por um nome parecido; não tem nada a ver com o seu problema.

initialization of ‘int’ from ‘char *’

Sem saber o que é string, o gcc imaginou que nome fosse um int e reclamou do texto. É um erro em cascata: conserte o primeiro e este some.

Em C, um texto é uma fileira de char, um array, com o '\0' no fim. Por enquanto, basta reconhecer o formato; ele tem várias aulas próprias a partir de Arrays e Strings:

#include <stdio.h>

int main(void) {
    char nome[] = "Ana";
    printf("Nome: %s\n", nome);
    printf("Tamanho: %zu bytes\n", sizeof(nome));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra texto.c -o texto
$ ./texto
Nome: Ana
Tamanho: 4 bytes         « 'A', 'n', 'a' e o '\0'

Os colchetes [] dizem "uma fileira de", e o %s (string) mostra o texto todo. Isso é o mais longe que o guia vai com textos antes da aula certa.

4. void: o tipo "nenhum valor"

O void ("vazio") é um tipo que quer dizer nada. Não existe variável void: não há o que guardar. Ele aparece em dois lugares que você já viu:

int main(void)

Dentro dos parênteses, void diz "esta função não recebe nada".

void prepara(void)

Antes do nome, diz "esta função não devolve nada" (aula Funções). Você viu uma assim em Variáveis.

Mais adiante ele volta como void *, um "endereço de qualquer coisa" (aula Ponteiro void*).

5. Escolher o tipo certo

Na dúvida, a pergunta é "o que eu quero guardar?". Esta tabela resolve quase todos os casos:

O 8'100'000'000 usa o separador de dígitos do C23: os apóstrofos só ajudam a ler e são ignorados pelo compilador (aula Inteiros).

O que acontece com o tipo errado

O tipo errado raramente dá erro de compilação. Na maioria das vezes, o programa roda e dá a resposta errada:

#include <stdio.h>

int main(void) {
    int preco = 4.99;
    int peso_kg = 2.5;
    double total = preco * peso_kg;
    printf("Total: %.2f\n", total);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra errado.c -o errado
$ ./errado
Total: 8.00              « 4 × 2: os centavos e o meio quilo sumiram

O int jogou fora a parte depois do ponto (4.99 virou 4; 2.5 virou 2), e o gcc não avisou com -Wall -Wextra. O Clang do editor avisa, porque os números estão escritos direto no código: implicit conversion from 'double' to 'int' changes value from 4.99 to 4 [-Wliteral-conversion].

#include <stdio.h>

int main(void) {
    int preco = 4.99;
    int peso_kg = 2.5;
    double total = preco * peso_kg;
    printf("Total: %.2f\n", total);
    return 0;
}

#include <stdio.h>

int main(void) {
    double preco = 4.99;
    double peso_kg = 2.5;
    double total = preco * peso_kg;
    printf("Total: %.2f\n", total);
    return 0;
}

A conta exata é 4,99 × 2,5 = 12,475. O %.2f arredondou para duas casas e mostrou 12.48. (Com %.3f sairia 12.475.)

Quando dá errado

$ gcc -std=c23 -Wall -Wextra aspas.c -o aspas
aspas.c: In function ‘main’:
aspas.c:4:20: error: initialization of ‘char’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
    4 |     char inicial = "A";
      |                    ^~~

$ gcc -std=c23 -Wall -Wextra longd.c -o longd
longd.c: In function ‘main’:
longd.c:5:14: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘long int’ [-Wformat=]
    5 |     printf("%d\n", habitantes);
      |             ~^     ~~~~~~~~~~
      |              |     |
      |              int   long int
      |             %ld
$ ./longd
213000000                « desta vez saiu certo, por sorte

Referência rápida

Exercícios

Missão final: a ficha do produto

Produto B: 12 unidades a 3.75 (disponível: 1)

#include <stdio.h>

int main(void) {
    // declare as quatro variáveis aqui

    printf("Produto ...\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    char codigo = 'B';
    int quantidade = 12;
    double preco = 3.75;
    bool disponivel = true;

    printf("Produto %c: %d unidades a %.2f (disponível: %d)\n",
           codigo, quantidade, preco, disponivel);
    return 0;
}

Resumo

• O tipo diz o que cabe na caixa, quanto espaço ela ocupa e qual letra o printf usa.
• Do dia a dia: int (%d), double (%f), char (%c) e bool (%d, sem #include no C23).
• Parentes: short, long (%ld), long long (%lld), float, long double (%Lf). void é "nenhum valor".
• sizeof mede em bytes (mostre com %zu). A norma só garante mínimos: long tem 8 bytes no gcc do Linux 64 bits e 4 no editor e no Windows.
• Literais têm tipo: 42 é int, 4.5 é double, 4.5f é float e, em C, 'A' é int.
• O C não tem tipo string: texto é um array de char terminado em '\0'.
• O tipo errado quase nunca dá erro; dá resposta errada. Escolha pelo que você quer guardar.