Tipos Primitivos: As Naturezas dos Valores

Na aula anterior, ao declarar uma variável, fomos obrigados a dizer o seu tipo — escrevemos int para indicar um número inteiro. Talvez você tenha se perguntado por que a linguagem exige isso: não bastaria criar uma gaveta e guardar qualquer coisa nela? A resposta a essa pergunta revela um dos traços mais importantes do C#, e desta aula. Valores têm naturezas diferentes — um número não é a mesma coisa que um texto, que não é a mesma coisa que um "sim ou não" — e o C# faz questão de saber, de antemão, a natureza de cada valor que uma variável guardará. Essa exigência, que pode parecer burocrática no começo, é na verdade uma poderosa aliada, que previne uma classe inteira de erros. Vamos conhecer os tipos fundamentais — os tipos primitivos — e entender por que eles importam.

Por que os tipos existem

Considere uma pergunta aparentemente boba: quanto é "cinco" mais "casa"? A pergunta não faz sentido, porque somar um número e uma palavra é uma operação sem significado. O computador, que executa tudo ao pé da letra, precisa de alguma forma saber que "cinco" é um número (com o qual se pode fazer contas) e "casa" é um texto (com o qual não). O tipo de um valor é justamente a declaração da sua natureza: ele informa ao C# o que aquele valor é e, por consequência, o que se pode e o que não se pode fazer com ele.

Ao exigir que você diga o tipo de cada variável, o C# ganha a capacidade de verificar, antes mesmo de rodar o programa, se você não está cometendo um disparate — como tentar somar um número a um texto, ou guardar uma palavra numa gaveta destinada a números. Quando você tenta, o compilador o avisa com um erro, e o problema é corrigido ali, na sua tela, em vez de virar um comportamento estranho durante a execução. Essa é a filosofia do C#, que você reencontrará por todo o curso: detectar erros o mais cedo possível, transformando problemas de execução em avisos de compilação. Os tipos são a primeira e mais fundamental linha dessa defesa.

Os números inteiros: int

Comecemos pelo tipo que já conhecemos. O int guarda números inteiros — isto é, sem casas decimais: 0, 42, -7, 1000. É o tipo que você usará para contar coisas, para índices, para idades, para qualquer quantidade que não tenha fração.

int quantidade = 12;
int temperatura = -5;
int pontuacao = 0;

O int tem um limite: ele consegue representar números inteiros dentro de uma faixa ampla, mas finita (aproximadamente de menos dois bilhões a mais dois bilhões). Para a esmagadora maioria dos usos, essa faixa é mais que suficiente. Quando você precisar de inteiros ainda maiores, existe o tipo long, que guarda inteiros de faixa muito maior; por ora, o int basta, e mencionamos o long apenas para você saber que existe.

Os números com casas decimais: double e decimal

Nem todo número é inteiro. Preços, medidas, médias — muitos valores têm parte fracionária. Para eles, o tipo mais comum é o double, que guarda números com casas decimais:

double altura = 1.75;
double preco = 19.90;
double media = 7.5;

Uma observação importante sobre a escrita: em C#, a separação da parte decimal usa ponto, não vírgula — escreve-se 1.75, e não 1,75, independentemente de como se escreve em português. A vírgula tem outro uso na linguagem, então respeite o ponto como separador decimal.

Há uma sutileza que vale conhecer desde cedo, embora sua compreensão plena venha com o tempo: o double é excelente para medidas científicas e cálculos gerais, mas ele armazena os números de uma forma que pode gerar pequenas imprecisões em certos cálculos — um resquício de como os computadores representam frações internamente. Por isso, para valores monetários, onde cada centavo precisa ser exato, o C# oferece um tipo específico, o decimal, mais preciso para dinheiro:

decimal saldo = 1500.75m;   // o 'm' ao final marca o valor como decimal

Note o sufixo m após o número: ele diz ao C# "este é um valor decimal". Por ora, guarde a regra prática: use double para medidas e cálculos gerais, e decimal (com o m) para dinheiro. A razão profunda dessa distinção ficará mais clara adiante; o importante agora é conhecer os dois e saber quando cada um se aplica.

O texto: string e char

Já usamos texto desde a primeira aula. O tipo que guarda texto — uma sequência de caracteres — é a string, escrita entre aspas duplas:

string nome = "Ana";
string saudacao = "Bom dia!";
string frase = "C# é uma linguagem versátil.";

Uma string pode conter qualquer texto: letras, números (tratados como texto, não como valor numérico), espaços, pontuação. É importante perceber que "30" (entre aspas) é texto, não o número 30 — são naturezas diferentes, e essa distinção terá consequências práticas quando, mais adiante, precisarmos converter um do outro.

Existe também o tipo char (de character), que guarda um único caractere, escrito entre aspas simples:

char inicial = 'A';
char nota = 'B';

Preste atenção à diferença das aspas: aspas duplas ("...") fazem uma string (texto de zero, um ou muitos caracteres); aspas simples ('...') fazem um char (exatamente um caractere). Confundir as duas é um erro comum de iniciante, e o C# reclamará se você trocá-las.

O verdadeiro ou falso: bool

Por fim, um tipo pequeno mas imensamente importante: o bool (de boolean, em homenagem ao matemático George Boole). Ele guarda apenas um de dois valores possíveis: true (verdadeiro) ou false (falso).

bool estaChovendo = true;
bool maiorDeIdade = false;

Pode parecer modesto guardar apenas "sim ou não", mas o bool é o coração de toda decisão que um programa toma. Quando, nas próximas aulas, seu programa precisar escolher entre caminhos ("se estiver chovendo, leve o guarda-chuva"), essa escolha se apoiará num valor bool. Por ora, apenas conheça-o; seu poder se revelará na Fase 2.

Uma visão de conjunto

Recapitulando os tipos primitivos essenciais que você usará com mais frequência: int para números inteiros; double para números com casas decimais em geral, e decimal (com m) para dinheiro; string para texto (aspas duplas) e char para um único caractere (aspas simples); e bool para verdadeiro ou falso. Existem outros tipos primitivos além destes, mas estes cobrem a vasta maioria das necessidades do dia a dia, e dominá-los é suficiente para avançar com segurança. Cada variável que você declarar terá um destes tipos (ou outros que aprenderemos depois), e o C# usará essa informação para protegê-lo de operações sem sentido.

Cada gaveta agora tem uma natureza declarada. Você conhece os tipos com que a maior parte do código do mundo é escrita: int para números inteiros, double e decimal para valores com casas decimais, string para texto, char para um único caractere e bool para verdadeiro ou falso. E sabe a distinção prática que evita o erro mais caro da lista: decimal para dinheiro, double para medidas e cálculos científicos.

Mais do que a tabela de tipos, ficou claro por que eles existem. Exigir o tipo de antemão permite ao compilador reservar a memória certa e recusar operações sem sentido antes mesmo do programa rodar — um rigor que parece burocrático no início e se revela uma rede de proteção.

Fontes e leituras recomendadas

• Tipos internos do C# — a referência oficial dos tipos primitivos, com suas faixas e usos; a base desta aula.
• Tipos numéricos inteiros — detalhes sobre int, long e os demais tipos inteiros.
• Tipos numéricos de ponto flutuante — sobre double e decimal, incluindo por que o decimal é indicado para dinheiro.
• O tipo bool — a referência do tipo verdadeiro/falso, base das decisões.
• Cadeias de caracteres (string) — uma introdução ao tipo texto, que aprofundaremos em aula própria.

Exercícios

Exercício 1

Declare uma variável de cada um dos seguintes tipos, com um valor apropriado e um nome descritivo: int, double, decimal, string, char, bool. Exiba todas com Console.WriteLine. Ao escrever o decimal, não esqueça do sufixo m.

int idade = 25;
double altura = 1.80;
decimal preco = 49.90m;
string nome = "Carlos";
char inicial = 'C';
bool ativo = true;
Console.WriteLine(idade);
Console.WriteLine(altura);
Console.WriteLine(preco);
Console.WriteLine(nome);
Console.WriteLine(inicial);
Console.WriteLine(ativo);

Exercício 2

Explique, com suas palavras, por que o C# exige que você declare o tipo de cada variável. Que classe de erro essa exigência ajuda a evitar, e em que momento (antes ou durante a execução) o erro é apontado?

Exercício 3

Explique a diferença entre "A" e 'A' em C#: qual é o tipo de cada um e qual a regra das aspas? Depois, explique por que "30" e 30 são coisas de naturezas diferentes.

Exercício 4

Você precisa guardar: (a) a quantidade de alunos numa turma; (b) o preço de um produto numa loja; (c) a temperatura medida por um sensor científico; (d) se um usuário confirmou seu e-mail; (e) a inicial do nome de alguém. Para cada caso, escolha o tipo primitivo mais apropriado e justifique brevemente.

Exercício 5

Tente declarar int preco = 19.90; e execute. O que acontece e por quê? Depois, corrija a declaração escolhendo o tipo adequado para um valor com casas decimais, e explique sua correção.