C# char e bool

Dois tipos pequenos e muito usados. O char guarda um caractere: uma letra, um dígito, um símbolo. O bool guarda uma resposta de sim ou não: true ou false. Toda decisão que um programa toma ("o cliente é maior de idade?", "a senha está certa?") passa por um bool. Nesta aula você vai ver os dois de perto, com as pegadinhas de cada um.

Todos os programas desta aula foram rodados com o .NET 10 (C# 14) na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/cs, com dotnet run arquivo.cs.

A ideia: a peça do jogo de letras e o interruptor

Num jogo de palavras cruzadas, cada pecinha tem uma letra. Uma palavra é uma fileira de pecinhas. No C#, a pecinha é o char, e a fileira é a string.

Já o bool é um interruptor: ou está ligado (true), ou desligado (false). Não existe "meio ligado".

1. char: um caractere

char inicial = 'A';
char simbolo = '$';
char digito = '7';
char espaco = ' ';
char acento = 'é';
Console.WriteLine(inicial);
Console.WriteLine(simbolo);
Console.WriteLine(digito);
Console.WriteLine("[" + espaco + "]");
Console.WriteLine(acento);

$ dotnet run letras.cs
A
$
7
[ ]
é

char inicial = 'A';

char (de character, "caractere"). O valor vai entre aspas simples: 'A'.

'$' · '7' · ' '

Qualquer caractere serve: símbolos, dígitos e até o espaço. Atenção: '7' é o desenho do dígito 7, não o número 7 (seção 2).

"[" + espaco + "]"

Os colchetes só servem para você ver o espaço na saída.

'é'

Acentos funcionam: o char do C# usa o Unicode, a tabela que tem as letras de quase todas as línguas.

'A' é char; "A" é string

Aspas simples fazem um char; aspas duplas fazem uma string, mesmo com uma letra só. Os dois não se trocam:

char letra = "A";
Console.WriteLine(letra);

$ dotnet run charerro1.cs
/home/ana/cs/charerro1.cs(1,14): error CS0029: Não é possível converter implicitamente tipo "string" em "char"

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

E um char guarda exatamente um caractere: nem dois, nem zero.

char letra = 'AB';
Console.WriteLine(letra);

$ dotnet run charerro2.cs
/home/ana/cs/charerro2.cs(1,14): error CS1012: Número excessivo de caracteres no literal de caractere

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

char vazio = '';
Console.WriteLine(vazio);

$ dotnet run charerro3.cs
/home/ana/cs/charerro3.cs(1,14): error CS1011: Literal de caractere vazio

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

Para mais de um caractere, ou nenhum, use string: "AB" e "" são textos válidos (aula Strings).

2. Todo caractere tem um código

Por dentro, o computador só guarda números. Cada caractere tem o seu código na tabela Unicode: 'A' é 65, 'B' é 66, 'a' é 97, o dígito '0' é 48. O char é, no fundo, esse número, em 2 bytes (de 0 a 65 535):

char letra = 'A';
int codigo = letra;
Console.WriteLine(codigo);
Console.WriteLine((int)'a');
Console.WriteLine((int)'0');
Console.WriteLine((char)66);
Console.WriteLine(letra + 1);
Console.WriteLine((char)(letra + 1));
letra++;
Console.WriteLine(letra);
Console.WriteLine('A' + 'B');
Console.WriteLine("" + 'A' + 'B');

$ dotnet run codigo.cs
65
97
48
B
66        « 'A' + 1 é um número!
B
B
131       « 65 + 66
AB

int codigo = letra;

Um char entra direto num int: o valor é o código, 65.

(int)'a' · (int)'0'

O (int) na frente pede "me mostre como int" (é um cast, aula Conversão de Tipos). Minúsculas têm outros códigos (97), e o dígito '0' é 48, não zero.

(char)66

O caminho inverso: o caractere de código 66, B.

letra + 1 → 66

A pegadinha: uma conta com char vira conta de int. 'A' + 1 é o número 66, não a letra B.

(char)(letra + 1) → B

Para voltar a ter um caractere, converta o resultado com (char). Os parênteses em volta de letra + 1 fazem a soma acontecer antes da conversão.

letra++

O ++ soma 1 e continua char: a variável passa de 'A' para 'B' (aula ++ e --).

'A' + 'B' → 131 · "" + 'A' + 'B' → AB

Dois char somados dão a soma dos códigos. Para juntar os caracteres, comece com uma string (aqui, a vazia ""): aí o + junta textos.

char letra = 'C';
Console.WriteLine($"Depois de {letra} vem {letra + 1}");

char letra = 'C';
Console.WriteLine($"Depois de {letra} vem {(char)(letra + 1)}");

3. Perguntas sobre um caractere

O tipo char traz métodos prontos para perguntar coisas sobre um caractere e para trocar maiúscula por minúscula:

char c = 'a';
Console.WriteLine(char.IsLetter(c));
Console.WriteLine(char.IsDigit('7'));
Console.WriteLine(char.IsUpper(c));
Console.WriteLine(char.ToUpper(c));
Console.WriteLine(char.IsWhiteSpace(' '));
Console.WriteLine(char.IsPunctuation('!'));
Console.WriteLine('7' - '0');

$ dotnet run metodoschar.cs
True
True
False
A
True
True
7

A última linha do programa é um truque antigo: '7' - '0' é 55 - 48 = 7. Como os dígitos estão em ordem na tabela, subtrair '0' transforma o desenho do dígito no número. Esses métodos aparecem muito com strings, para conferir o que o usuário digitou letra por letra.

4. Escapes: caracteres difíceis de digitar

Alguns caracteres não dá para escrever direto entre aspas simples. Para eles existe a barra invertida \, que muda o sentido do caractere seguinte:

char aspas = '\'';
char barra = '\\';
char tab = '\t';
char unicode = '\u00E9';
char novaLinha = '\n';
Console.WriteLine(aspas);
Console.WriteLine(barra);
Console.WriteLine("A" + tab + "B");
Console.WriteLine(unicode);
Console.Write("linha 1" + novaLinha + "linha 2" + novaLinha);

$ dotnet run escchar.cs
'
\
A	B
é
linha 1
linha 2

'\''

Uma aspa simples. Sem a barra, ''' confundiria o compilador.

'\\'

A própria barra invertida.

'\t'

Tab: um espaço grande, que alinha colunas.

'\u00E9'

Qualquer caractere pelo código Unicode em hexadecimal: 00E9 é o é.

'\n'

New line, "nova linha": a quebra de linha. O Console.Write (sem Line) não pula linha sozinho; quem pula é o \n.

Os mesmos escapes funcionam dentro de strings ("Ela disse \"oi\""). A lista completa está em Escapes e Strings Literais.

Um emoji não cabe num char

O char tem 2 bytes e vai até o código 65 535. Os emojis (e alguns ideogramas raros) têm códigos maiores e precisam de dois char:

char carinha = '😀';
Console.WriteLine(carinha);

$ dotnet run charerro4.cs
/home/ana/cs/charerro4.cs(1,16): error CS1012: Número excessivo de caracteres no literal de caractere

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

string carinha = "😀";
Console.WriteLine(carinha);
Console.WriteLine(carinha.Length);
Console.WriteLine("Ana".Length);

$ dotnet run emoji.cs
😀
2         « um emoji = dois char
3

Na tela é um desenho só, mas para o C# são dois char (um "par substituto", ou surrogate pair, do UTF-16). Por isso .Length ("comprimento") dá 2. Moral: emojis vão em string, nunca em char.

5. bool: verdadeiro ou falso

bool maiorDeIdade = true;
bool temDesconto = false;
int idade = 29;
bool podeVotar = idade >= 16;
Console.WriteLine(maiorDeIdade);
Console.WriteLine(temDesconto);
Console.WriteLine(podeVotar);
Console.WriteLine(idade > 60);
Console.WriteLine(!temDesconto);
Console.WriteLine($"Pode votar? {podeVotar}");
Console.WriteLine(podeVotar ? "sim" : "não");
Console.WriteLine(true.ToString().ToLower());

$ dotnet run booleanos.cs
True
False
True
False
True
Pode votar? True
sim
true

bool maiorDeIdade = true;

bool vem de George Boole, o matemático que criou a lógica do verdadeiro/falso. Os únicos valores são true e false, sempre minúsculos e sem aspas.

bool podeVotar = idade >= 16;

O jeito mais comum de ganhar um bool: uma comparação. idade >= 16 ("idade maior ou igual a 16") é uma pergunta, e a resposta é true ou false. As comparações têm aula própria: Operadores de Comparação.

idade > 60

29 é maior que 60? False.

!temDesconto

O ! é o "não": inverte o valor. Não tem desconto? True (aula Operadores Lógicos).

True · False

Na saída, o .NET escreve com a primeira letra maiúscula, em inglês, também no Ubuntu em português.

podeVotar ? "sim" : "não"

Para mostrar em português, escolha o texto pelo valor. O ? : é o operador ternário: "se podeVotar, "sim"; senão, "não"".

true.ToString().ToLower()

Se você precisa de true minúsculo (para um arquivo JSON, por exemplo), converta para texto e passe para minúsculas.

Um bool ocupa 1 byte (sizeof(bool) = 1). O lugar onde ele mais trabalha é o if, que decide se um trecho do programa roda ou não (aula if e else).

No C#, número não é bool

Em C, JavaScript e Python, o número 0 vale como "falso" e qualquer outro como "verdadeiro". No C# não: bool e números são mundos separados.

bool ativo = 1;
Console.WriteLine(ativo);

$ dotnet run boolerro1.cs
/home/ana/cs/boolerro1.cs(1,14): error CS0029: Não é possível converter implicitamente tipo "int" em "bool"

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

bool ativo = true;
int x = (int)ativo;
Console.WriteLine(x);

$ dotnet run boolerro4.cs
/home/ana/cs/boolerro4.cs(2,9): error CS0030: Não é possível converter tipo "bool" em "int"

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

Nem com (int) vai: o CS0030 diz que não existe conversão nenhuma. Isso evita uma classe inteira de erros, como um if (estoque) escrito por engano no lugar de if (estoque > 0). Se você precisa mesmo de 1 e 0, escolha com o ternário: int x = ativo ? 1 : 0;.

Quando dá errado

$ dotnet run boolerro3.cs
/home/ana/cs/boolerro3.cs(1,14): error CS0103: O nome "True" não existe no contexto atual

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

Referência rápida

Exercícios

Missão final: meia-entrada

int idade = 15;
bool meiaEntrada = 1;
Console.WriteLine($"Meia-entrada: {meiaEntrada}");

int idade = 15;
bool meiaEntrada = idade < 18;
Console.WriteLine($"Meia-entrada: {meiaEntrada}");

Resumo

• char: um caractere, entre aspas simples ('A'), 2 bytes, Unicode. "A" é string.
• Todo char tem um código: (int)'A' = 65, (char)66 = B. Conta com char dá int: use (char)(c + 1).
• Escapes: '\n', '\t', '\'', '\\', '\u00E9'. Emojis precisam de dois char: guarde em string.
• char.IsDigit, IsLetter, IsUpper, ToUpper… fazem perguntas e trocas.
• bool: true ou false (minúsculos no código; True/False na saída). Nasce de comparações: idade >= 18.
• No C#, número não é bool: bool b = 1; dá CS0029 e (int)true dá CS0030.