C Variáveis

Todo programa precisa guardar coisas enquanto trabalha: a idade de uma pessoa, o preço de um caderno, quantas maçãs sobraram na lojinha da Ana. Em C, cada coisa guardada fica numa variável. Nesta aula você vai criar suas primeiras variáveis, mostrar o valor delas com printf, trocar esse valor e entender por que o compilador reclama (ou, pior, não reclama) quando uma variável fica sem valor.

Todos os programas desta aula foram compilados com o gcc 15.2 na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/c, com o comando padrão do guia: gcc -std=c23 -Wall -Wextra arquivo.c -o programa (cada opção é explicada em Compilar com gcc). Você pode repetir cada um no editor do guia, que compila C de verdade no navegador.

A ideia: uma caixa com etiqueta e formato

Pense numa mudança de casa. Você guarda as coisas em caixas e escreve uma etiqueta em cada uma: "LIVROS", "PANELAS". Quando quer as panelas, procura pela etiqueta.

Uma variável é isso: um pedacinho da memória do computador com uma etiqueta. A etiqueta é o nome; o que está dentro é o valor. O nome "variável" vem daí: o que está dentro pode variar.

Em C existe um detalhe a mais: cada caixa tem um formato, escolhido quando você a cria, e esse formato nunca muda. Uma caixa de ovos só guarda ovos; uma caixa de sapatos só guarda sapatos. Esse formato se chama tipo.

Os tipos têm aula própria (Tipos de Dados). Por enquanto, três bastam: int (de integer, "inteiro") para números sem vírgula, double ("duplo", de precisão dupla) para números com vírgula e char (de character, "caractere") para uma letra só. Textos inteiros, como "Ana", são um pouco mais trabalhosos em C e ficam para a aula Strings.

1. Declarar uma variável

Criar uma variável se chama declarar. A receita é sempre a mesma: tipo nome = valor;.

#include <stdio.h>

int main(void) {
    int idade = 29;
    printf("A Ana tem %d anos.\n", idade);
    return 0;
}

int

O tipo: esta caixa guarda um número inteiro.

idade

O nome da variável. As regras de nomes estão em Nomes de Variáveis.

=

Leia como "recebe": idade recebe 29. Não é o "igual" da matemática; quem compara valores é o == (aula Operadores de Comparação).

29

O valor inicial. Números não levam aspas.

;

O ponto e vírgula termina a declaração, como o ponto final de uma frase.

printf("… %d …", idade)

O printf (print formatted, "imprimir formatado") mostra o texto entre aspas. Onde aparece %d, ele encaixa o valor da variável que vem depois da vírgula. O d vem de decimal: "mostre um inteiro em base 10".

$ gcc -std=c23 -Wall -Wextra idade.c -o idade
$ ./idade
A Ana tem 29 anos.

O gcc não mostrou nada: isso quer dizer que compilou sem erros nem avisos. O ./idade rodou o programa, e o %d foi trocado por 29. Repare que o programa mostrou o valor, e não a palavra "idade": o nome é só a etiqueta, para você e para o compilador.

Outros tipos, outras letras

O %d serve para int. Cada tipo tem a sua letra no printf. Um texto pode ter vários %, e os valores entram na ordem, separados por vírgula:

#include <stdio.h>

int main(void) {
    int idade = 29;
    double altura = 1.65;
    char inicial = 'A';
    printf("%c. tem %d anos e %.2f m de altura.\n", inicial, idade, altura);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra ola.c -o ola
$ ./ola
A. tem 29 anos e 1.65 m de altura.

double altura = 1.65;

Número com vírgula se escreve com ponto, como nos Estados Unidos. 1,65 significaria outra coisa.

char inicial = 'A';

Um caractere vai entre aspas simples. Aspas duplas são para textos (aula Caracteres).

%c

Encaixa um char (o 1º valor da lista, inicial).

%d

Encaixa um int (o 2º valor, idade).

%.2f

Encaixa um double com 2 casas depois do ponto (o 3º valor, altura). Sem o .2, sairia 1.650000. Os detalhes estão em float e double e em Formatos do printf.

#include <stdio.h>

int main(void) {
    int quantidade = 6;
    printf("A Ana comprou %d maçãs.\n", quantidade);
    return 0;
}

#include <stdio.h>

int main(void) {
    int quantidade = 8;
    printf("A Ana comprou %d maçãs.\n", quantidade);
    return 0;
}

2. Mudar o valor

Depois de declarada, a variável é usada só pelo nome, sem repetir o tipo. Para trocar o valor, escreva nome = novo valor;. Isso se chama atribuição, e o valor antigo é jogado fora:

#include <stdio.h>

int main(void) {
    int macas = 6;
    printf("Antes: %d\n", macas);
    macas = 4;
    printf("Depois: %d\n", macas);
    macas = macas + 2;
    printf("Mais duas: %d\n", macas);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra mudar.c -o mudar
$ ./mudar
Antes: 6
Depois: 4
Mais duas: 6

O programa roda de cima para baixo. A linha macas = macas + 2; parece estranha para quem lembra da matemática, mas lembre que = é "recebe":

1. O C calcula primeiro o lado direito: lê o valor atual de macas (4) e soma 2, dando 6.
2. Depois guarda o resultado na caixa da esquerda, no lugar do 4.

Esse padrão tem um atalho, macas += 2;, explicado em Operadores de Atribuição.

Declarar, atribuir, inicializar

Três palavras aparecem o tempo todo em livros e mensagens de erro:

Copiar uma variável para outra

int b = a; copia o valor. Depois disso, as duas caixas são independentes:

#include <stdio.h>

int main(void) {
    int a = 1;
    int b = a;
    a = 5;
    printf("a=%d b=%d\n", a, b);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra copia.c -o copia
$ ./copia
a=5 b=1                  « mudar a depois não mexeu em b

O tipo nunca muda

Uma caixa de int continua sendo de int até o fim. Tentar guardar um texto nela é recusado pelo gcc:

#include <stdio.h>

int main(void) {
    int idade = 29;
    idade = "trinta";
    printf("%d\n", idade);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra tipo.c -o tipo
tipo.c: In function ‘main’:
tipo.c:5:11: error: assignment to ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
    5 |     idade = "trinta";
      |           ^

assignment to ‘int’ from ‘char *’

"Atribuição a um int a partir de um char *". O char * é o tipo que o C dá a um texto entre aspas: um ponteiro, o endereço onde as letras estão guardadas (aulas Ponteiros e Ponteiros e Strings).

makes integer from pointer without a cast

"Transforma um ponteiro em inteiro sem uma conversão explícita". Em outras palavras: isso é texto, e a caixa é de número.

[-Wint-conversion]

O nome da regra. Até o gcc 13 isso era só um aviso; desde o gcc 14 é um error, e o arquivo tipo nem foi criado. (A leitura da mensagem, parte por parte, está em Lendo Erros do Compilador.)

Já um número com vírgula numa caixa de int passa sem nenhum aviso no gcc, e a parte depois da vírgula some:

#include <stdio.h>

int main(void) {
    int idade = 29;
    idade = 29.9;
    printf("%d\n", idade);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra corta.c -o corta
$ ./corta
29                       « o .9 foi cortado (não arredondado), em silêncio

O C converte o 29.9 para int jogando fora a parte fracionária. Nem o -Wall -Wextra avisou. Existe uma opção que avisa, o -Wconversion (ela não faz parte do -Wall; a aula Avisos fala dela):

$ gcc -std=c23 -Wall -Wextra -Wconversion corta.c -o corta
corta.c: In function ‘main’:
corta.c:5:13: warning: conversion from ‘double’ to ‘int’ changes value from ‘2.9899999999999999e+1’ to ‘29’ [-Wfloat-conversion]
    5 |     idade = 29.9;
      |             ^~~~

O 2.9899999999999999e+1 é o seu 29.9 escrito do jeito que o computador o guarda de verdade: em notação científica (e+1 = "vezes 10 elevado a 1") e com um errinho lá no fim. Esse errinho é normal e é explicado em float e double. O Clang, o compilador do editor do guia, avisa esse caso mesmo sem -Wconversion, porque o número está escrito direto no código: implicit conversion from 'double' to 'int' changes value from 29.9 to 29 [-Wliteral-conversion]. A conversão de propósito, com (int), tem aula própria: Conversão de Tipos.

3. Várias variáveis numa linha

Variáveis do mesmo tipo podem ser declaradas juntas, separadas por vírgula:

#include <stdio.h>

int main(void) {
    int a = 1, b = 2, c = 3;
    printf("%d %d %d\n", a, b, c);
    int x, y = 5;
    printf("%d %d\n", x, y);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra linha.c -o linha
linha.c: In function ‘main’:
linha.c:7:5: warning: ‘x’ is used uninitialized [-Wuninitialized]
    7 |     printf("%d %d\n", x, y);
      |     ^~~~~~~~~~~~~~~~~~~~~~~
linha.c:6:9: note: ‘x’ was declared here
    6 |     int x, y = 5;
      |         ^
$ ./linha
1 2 3
0 5

A linha 4 está certa: três variáveis, cada uma com seu valor. A linha 6 é a armadilha: quem lê int x, y = 5; pode achar que as duas valem 5, mas o = 5 vale só para o y. O x ficou sem valor, e o compilador avisou. Aqui ele apareceu como 0 por acaso; a seção 4 mostra que ele poderia ser qualquer número.

Começar do zero com = {} C23

Além do = valor, o C aceita o valor entre chaves, = {20}. E desde o C23, chaves vazias dão o valor "zero" do tipo:

#include <stdio.h>

int main(void) {
    int a = 10;
    int b = {20};
    int c = {};
    printf("%d %d %d\n", a, b, c);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra zero.c -o zero
$ ./zero
10 20 0
$ gcc -std=c17 -Wall -Wextra -Wpedantic zero.c -o zero
zero.c: In function ‘main’:
zero.c:6:13: warning: ISO C forbids empty initializer braces before C23 [-Wpedantic]
    6 |     int c = {};
      |             ^

No C23 tudo certo. Pedindo o padrão antigo (-std=c17) com -Wpedantic ("seja exigente com o padrão"), o gcc lembra: "o ISO C proíbe chaves de inicialização vazias antes do C23". Para variáveis simples, a forma mais comum continua sendo int c = 0;, que funciona em todas as versões. As chaves brilham com Arrays e Structs, onde = {} zera tudo de uma vez.

4. Variável sem valor inicial: o "lixo"

O C deixa você criar uma variável sem valor: int pontos;. Ela existe, ocupa memória, mas o C não limpa essa memória. O que estiver lá, sobrado de outra parte do programa, vira o "valor". Programadores chamam isso de lixo (garbage).

Neste programa, a função prepara usa um pedaço da memória e termina; depois a função mostra cria pontos sem valor. (Funções são do Nível 2, em Funções; aqui elas só servem para "sujar" a memória antes.)

#include <stdio.h>

void prepara(void) {
    int numeros[4] = {1234, 5678, 9012, 3456};
    printf("prepara usou: %d\n", numeros[0]);
}

void mostra(void) {
    int pontos;
    printf("pontos vale: %d\n", pontos);
}

int main(void) {
    prepara();
    mostra();
    return 0;
}

$ gcc -std=c23 -Wall -Wextra lixo.c -o lixo
lixo.c: In function ‘mostra’:
lixo.c:10:5: warning: ‘pontos’ is used uninitialized [-Wuninitialized]
   10 |     printf("pontos vale: %d\n", pontos);
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lixo.c:9:9: note: ‘pontos’ was declared here
    9 |     int pontos;
      |         ^~~~~~
$ ./lixo
prepara usou: 1234
pontos vale: 1864013119
$ ./lixo
prepara usou: 1234
pontos vale: -1087482880
$ ./lixo
prepara usou: 1234
pontos vale: -716709242  « três execuções, três valores diferentes

warning:

"Aviso". Diferente de error, o programa foi gerado. Mas este aviso é sério.

‘pontos’ is used uninitialized

"pontos é usada sem ter sido inicializada": você leu o valor de uma caixa onde nunca guardou nada.

[-Wuninitialized]

A regra de aviso que pegou o problema. Ela vem ligada pelo -Wall. Sem -Wall, o gcc compila esse programa calado.

note: ‘pontos’ was declared here

"Nota: pontos foi declarada aqui": o compilador aponta a linha da criação, onde está o conserto.

O número muda a cada execução e não tem nenhum significado. Num jogo, a Ana começaria a partida com 1,8 bilhão de pontos. Ler uma variável sem valor é um comportamento indefinido: a linguagem não promete nada sobre o que acontece, nem que sai um número (aula Comportamento Indefinido). Às vezes o lixo é 0, como na seção 3, e o erro passa despercebido nos testes para aparecer depois. No editor do guia, o mesmo programa costuma mostrar um número que sobrou da função prepara: outra máquina, outro lixo.

"Talvez sem valor": -Wmaybe-uninitialized

Às vezes a variável recebe valor só em alguns caminhos do programa. Aqui, desconto só recebe valor se a Ana fez mais de 5 compras. (O if tem aula própria, if e else; o scanf lê um número do teclado, aula Entrada com scanf. Por enquanto, leia o código como uma frase.)

#include <stdio.h>

int main(void) {
    int compras = 0;
    if (scanf("%d", &compras) != 1) {
        return 1;
    }
    int desconto;
    if (compras > 10) {
        desconto = 5;
    } else if (compras > 5) {
        desconto = 2;
    }
    int pagar = 100 - desconto;
    printf("Você paga: %d reais\n", pagar);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra talvez.c -o talvez     « nenhum aviso!
$ gcc -std=c23 -Wall -Wextra -O2 talvez.c -o talvez
talvez.c: In function ‘main’:
talvez.c:14:9: warning: ‘desconto’ may be used uninitialized [-Wmaybe-uninitialized]
   14 |     int pagar = 100 - desconto;
      |         ^~~~~
talvez.c:8:9: note: ‘desconto’ was declared here
    8 |     int desconto;
      |         ^~~~~~~~
$ echo 3 | ./talvez
Você paga: 95 reais      « 3 compras não dão desconto, mas saiu 95

• May be used uninitialized = "pode ser usada sem valor". O compilador não tem certeza (depende do número digitado), mas achou um caminho em que nenhum valor é guardado: 5 compras ou menos.
• No gcc, esse aviso só aparece quando você também pede otimização (-O2, "otimize, nível 2"), porque a análise que encontra esses caminhos roda junto com a otimização. Sem -O2, o mesmo erro passou calado.
• O resultado 95 com 3 compras é o comportamento indefinido em ação: o otimizador supôs que o caminho sem valor nunca acontece e usou o desconto de 5.
• O conserto é o mesmo: int desconto = 0;.

#include <stdio.h>

int main(void) {
    int pontos;
    int bonus = 10;
    pontos = pontos + bonus;
    printf("Pontos: %d\n", pontos);
    return 0;
}

#include <stdio.h>

int main(void) {
    int pontos = 0;
    int bonus = 10;
    pontos = pontos + bonus;
    printf("Pontos: %d\n", pontos);
    return 0;
}

Esse programa com defeito pode até mostrar Pontos: 10, se o lixo daquela vez for zero, mas o aviso continua lá. "Deu o número certo" não quer dizer que está certo.

5. Usar antes de declarar e declarar duas vezes

O compilador lê o arquivo de cima para baixo. Uma variável só existe da linha da declaração para baixo:

#include <stdio.h>

int main(void) {
    printf("%d\n", total);
    int total = 50;
    return 0;
}

$ gcc -std=c23 -Wall -Wextra antes.c -o antes
antes.c: In function ‘main’:
antes.c:4:20: error: ‘total’ undeclared (first use in this function)
    4 |     printf("%d\n", total);
      |                    ^~~~~
antes.c:4:20: note: each undeclared identifier is reported only once for each function it appears in
antes.c:5:9: warning: unused variable ‘total’ [-Wunused-variable]
    5 |     int total = 50;
      |         ^~~~~

‘total’ undeclared (first use in this function)

"total não declarada (primeiro uso nesta função)". Na linha 4, total ainda não existe. O mesmo erro aparece quando o nome está escrito diferente (Total, totla).

note: each undeclared identifier is reported only once…

"Cada identificador não declarado é avisado só uma vez por função". Se você usar total dez vezes, o erro aparece só na primeira.

warning: unused variable ‘total’

"Variável total não usada": a da linha 5 foi criada e ninguém leu o valor dela depois. É um efeito do mesmo engano.

O Clang, no editor, diz use of undeclared identifier 'total' ("uso de identificador não declarado").

E criar duas variáveis com o mesmo nome no mesmo bloco também é erro:

#include <stdio.h>

int main(void) {
    int total = 50;
    int total = 80;
    printf("%d\n", total);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra dupla.c -o dupla
dupla.c: In function ‘main’:
dupla.c:5:9: error: redefinition of ‘total’
    5 |     int total = 80;
      |         ^~~~~
dupla.c:4:9: note: previous definition of ‘total’ with type ‘int’
    4 |     int total = 50;
      |         ^~~~~

Redefinition = "definição repetida"; previous definition of ‘total’ with type ‘int’ = "definição anterior de total, com tipo int". Para mudar o valor, escreva sem o tipo: total = 80;. Repetir o int pede uma caixa nova com uma etiqueta que já existe. (No editor, o Clang escreve redefinition of 'total' e previous definition is here.)

#include <stdio.h>

int main(void) {
    int total = 50;
    int total = 80;
    printf("Total: %d\n", total);
    return 0;
}

#include <stdio.h>

int main(void) {
    int total = 50;
    total = 80;
    printf("Total: %d\n", total);
    return 0;
}

Quando dá errado

$ gcc -std=c23 -Wall -Wextra pontovirgula.c -o pontovirgula
pontovirgula.c: In function ‘main’:
pontovirgula.c:5:5: error: expected ‘,’ or ‘;’ before ‘printf’
    5 |     printf("%d\n", total);
      |     ^~~~~~
pontovirgula.c:4:9: warning: unused variable ‘total’ [-Wunused-variable]
    4 |     int total = 50
      |         ^~~~~

$ gcc -std=c23 -Wall -Wextra formato.c -o formato
formato.c: In function ‘main’:
formato.c:5:21: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘double’ [-Wformat=]
    5 |     printf("Preço: %d\n", preco);
      |                    ~^     ~~~~~
      |                     |     |
      |                     int   double
      |                    %f
$ ./formato
Preço: 294781608         « preco valia 2.5

Referência rápida

Exercícios

Missão final: o caixa da lojinha

Total: 15 reais
Total: 20 reais

#include <stdio.h>

int main(void) {
    // declare quantidade, preco e total aqui

    // mostre o total

    // mude a quantidade, recalcule e mostre de novo

    return 0;
}

#include <stdio.h>

int main(void) {
    int quantidade = 3;
    int preco = 5;
    int total = quantidade * preco;
    printf("Total: %d reais\n", total);

    quantidade = 4;
    total = quantidade * preco;
    printf("Total: %d reais\n", total);
    return 0;
}

Repare que o total não muda sozinho quando a quantidade muda: a conta quantidade * preco é feita na hora em que a linha roda, e o resultado é guardado. Por isso a missão pede para calcular de novo.

Resumo

• Variável = caixa com tipo (formato), nome (etiqueta) e valor. Declare com tipo nome = valor;.
• Mostre com printf: %d para int, %f para double, %c para char. A letra tem de combinar com o tipo (-Wformat avisa).
• Para mudar o valor: nome = novo;, sem repetir o tipo. O lado direito é calculado primeiro. O tipo nunca muda; um 29.9 guardado num int vira 29 em silêncio.
• Várias numa linha: int a = 1, b = 2;. Em int x, y = 5;, só o y vale 5. Prefira uma por linha. = {} dá zero C23.
• Variável sem valor guarda lixo, e lê-la é comportamento indefinido. -Wall avisa com -Wuninitialized; o -Wmaybe-uninitialized do gcc aparece com -O2. Regra: toda variável nasce com valor.
• A variável só existe da declaração para baixo (undeclared), e o mesmo nome não pode ser declarado duas vezes no mesmo bloco (redefinition).