Variáveis: Gavetas com Nome para Guardar Valores

Até agora, nossos programas apenas exibiram textos que escrevemos de antemão. Eles falavam, mas não lembravam de nada. Um programa verdadeiramente útil precisa guardar informações para usá-las depois: o nome que o usuário digitou, o resultado de uma conta, a quantidade de itens numa lista. Para isso existe o conceito mais fundamental de toda a programação — tão fundamental que, sem ele, nada mais se constrói. Esse conceito é a variável. Nesta aula, você entenderá o que é uma variável, como criá-la, como guardar valores nela e como recuperá-los. É um passo modesto na aparência, mas é a porta de entrada para programas que de fato pensam.

A metáfora da gaveta

Imagine uma cômoda cheia de gavetas. Cada gaveta pode guardar um objeto, e cada uma tem uma etiqueta com um nome, para que você saiba o que há dentro sem precisar abri-la. Você pode colocar algo numa gaveta, olhar depois o que guardou, e até trocar o conteúdo por outro. Uma variável é exatamente isso, dentro da memória do computador: um espaço com um nome onde o programa guarda um valor, podendo consultá-lo e alterá-lo depois. O nome é a etiqueta; o valor é o que está guardado dentro.

Essa metáfora, embora simples, já contém as três operações que você fará com variáveis o tempo todo: criar a gaveta (dar-lhe um nome), guardar um valor nela, e ler o valor que está lá. Vamos ver cada uma em C#.

Criando e guardando: a declaração

Criar uma variável em C# se chama declarar a variável. A forma básica exige que você diga duas coisas: que tipo de valor a gaveta vai guardar, e qual será o seu nome. Veja um primeiro exemplo:

int idade;

Essa linha declara uma variável. A palavra int diz o tipo — aqui, um número inteiro (do inglês integer); estudaremos os tipos em detalhe na próxima aula, mas por ora saiba que int significa "esta gaveta guardará um número inteiro". A palavra idade é o nome que escolhemos para a variável — a etiqueta da gaveta. E o ponto e vírgula, como você já sabe, encerra a instrução. Neste momento, criamos a gaveta idade, mas ainda não guardamos nada nela.

Para guardar um valor, usamos o sinal de igual (=), chamado operador de atribuição:

idade = 30;

Aqui é preciso um cuidado importante, porque este é um ponto onde a intuição da matemática engana. O sinal =, em programação, não significa "é igual a" no sentido matemático. Ele significa "guarde, na variável à esquerda, o valor à direita". Leia idade = 30 não como "idade é igual a 30", mas como "guarde o valor 30 na gaveta chamada idade". A seta mental correta aponta da direita para a esquerda: o valor 30 vai para dentro de idade. Compreender isso desde já evitará muita confusão adiante.

Podemos fazer as duas coisas — declarar e guardar — numa única linha, o que é o mais comum:

int idade = 30;   // cria a gaveta 'idade' e já guarda 30 nela

(O texto após // é um comentário: uma anotação para humanos que o computador ignora completamente. Comentários servem para explicar o código a quem o lê — inclusive a você mesmo, no futuro. Use-os para esclarecer suas intenções.)

Lendo o valor: usando a variável

Guardar um valor só é útil se pudermos recuperá-lo. Para ler uma variável, basta usar o seu nome onde você quer o valor que ela guarda. Por exemplo, podemos exibi-lo:

int idade = 30;
Console.WriteLine(idade);   // exibe: 30

Repare numa diferença sutil e crucial. Na aula anterior, escrevíamos Console.WriteLine("idade") — com aspas — e apareceria a palavra literal idade. Agora escrevemos Console.WriteLine(idade) — sem aspas — e aparece o valor guardado, 30. As aspas fazem toda a diferença: com aspas, é texto literal; sem aspas, é o nome de uma variável, e o C# substitui esse nome pelo valor guardado. Essa distinção entre "a palavra em si" e "o que a variável guarda" é fundamental, e vale fixá-la desde já.

Trocando o conteúdo: variáveis variam

O nome "variável" não é gratuito: o valor guardado pode variar ao longo do programa. Você pode guardar um novo valor na mesma gaveta, e o antigo é substituído:

int idade = 30;
Console.WriteLine(idade);   // exibe: 30

idade = 31;                 // guarda um novo valor; o 30 é substituído
Console.WriteLine(idade);   // exibe: 31

Note que, na segunda atribuição, não repetimos o int — o tipo é dito apenas uma vez, na declaração. Depois disso, a gaveta já existe, e apenas trocamos o que há dentro. Repetir int idade = 31 seria tentar criar uma segunda gaveta com o mesmo nome, o que o C# não permite. Declara-se uma vez; atribui-se quantas vezes quiser.

O valor à direita da atribuição pode, inclusive, envolver a própria variável. Isto é perfeitamente válido e muito comum:

int idade = 30;
idade = idade + 1;          // lê o valor atual (30), soma 1, e guarda o resultado (31)
Console.WriteLine(idade);   // exibe: 31

Leia idade = idade + 1 com a regra que aprendemos: "calcule o valor à direita (idade + 1, que é 30 + 1 = 31) e guarde-o na gaveta idade". Primeiro o lado direito é calculado usando o valor atual da variável; depois o resultado é guardado, substituindo o antigo. Se você tentasse ler isso como uma equação matemática ("idade é igual a idade mais um"), pareceria absurdo — e é por isso que insisti que = não é igualdade, e sim atribuição.

As regras dos nomes

Você tem liberdade para nomear suas variáveis, mas há regras e convenções. As regras (obrigatórias): um nome pode conter letras, números e o sublinhado (_), mas não pode começar com número, não pode conter espaços, e não pode ser uma palavra reservada da linguagem (como int, que já tem significado próprio). As convenções (fortemente recomendadas, embora não obrigatórias): dê nomes descritivos, que revelem o propósito da variável. Uma variável chamada idade ou precoTotal conta o que guarda; uma chamada x ou a, salvo em casos muito específicos, obriga quem lê a adivinhar. Em C#, a convenção para nomes de variáveis é começar com letra minúscula e, se o nome tiver várias palavras, iniciar cada palavra seguinte com maiúscula — um estilo chamado camelCase (precoTotal, nomeDoUsuario, quantidadeDeItens). Bons nomes são uma cortesia com quem lê seu código, e o principal leitor será você mesmo, semanas depois, tentando entender o que fez.

A variável é o primeiro conceito sem o qual nada mais se constrói, e ele já está assentado. Você sabe declarar uma variável dizendo seu tipo e seu nome, guardar um valor nela com o sinal de igual, ler esse valor usando o nome, e trocar o conteúdo quantas vezes quiser — afinal, variáveis variam.

O ponto que mais confunde quem começa também ficou resolvido: o sinal de igual não afirma uma igualdade matemática, ele ordena um armazenamento. A seta mental aponta da direita para a esquerda. É por isso que uma instrução como x = x + 1, absurda como equação, é perfeitamente sensata como atribuição.

Fontes e leituras recomendadas

• Variáveis e tipos em C# (fundamentos) — o material oficial sobre os conceitos básicos da linguagem, incluindo variáveis; uma referência para revisitar.
• Declaração de variáveis locais — a documentação sobre como declarar variáveis, complementar a esta aula.
• Convenções de nomenclatura em C# — as regras e convenções oficiais para nomear variáveis e outros elementos.
• Comentários em C# — como escrever comentários, as anotações que o computador ignora.
• O operador de atribuição — a referência do sinal = e seu significado de atribuição, não de igualdade.

Exercícios

Exercício 1

Num programa novo, declare uma variável int chamada ano e guarde nela o ano atual. Em seguida, exiba-a com Console.WriteLine. Depois, explique com suas palavras a diferença entre escrever Console.WriteLine(ano) e Console.WriteLine("ano").

int ano = 2026;
Console.WriteLine(ano);   // exibe 2026

Exercício 2

Declare uma variável idade com o valor 20, exiba-a, depois atribua a ela o valor 21 e exiba de novo. Explique por que, na segunda atribuição, você não deve escrever int novamente.

int idade = 20;
Console.WriteLine(idade);   // 20
idade = 21;
Console.WriteLine(idade);   // 21

Exercício 3

Escreva um programa que declare uma variável contador valendo 0, e depois execute três vezes a instrução contador = contador + 1, exibindo o valor após cada uma. Preveja a saída antes de rodar, e depois confirme. Explique, com a regra da atribuição, por que o valor cresce.

int contador = 0;
contador = contador + 1;
Console.WriteLine(contador);   // 1
contador = contador + 1;
Console.WriteLine(contador);   // 2
contador = contador + 1;
Console.WriteLine(contador);   // 3

Exercício 4

Explique, com suas palavras, por que o sinal = em programação não significa "é igual a" no sentido matemático. Ilustre com a instrução x = x + 1, mostrando por que ela seria absurda como equação, mas faz sentido como atribuição.

Exercício 5

Para cada nome de variável a seguir, diga se é válido (segue as regras) e se é bom (segue as convenções), justificando: 2preco, preco total, precoTotal, x, _contador, int. Corrija os inválidos.