Armazenando e Exibindo Valores Binários em C#

Armazenando Literais Binários em C

[0:00 - 1:50] A primeira questão que Tim aborda é simples: como você coloca um número binário em uma variável C#? A resposta é o prefixo 0b, que informa ao compilador para interpretar os dígitos como base 2 em vez da base 10 padrão.

// Store binary 1001 (which is 9 in decimal)
int binaryValue = 0b1001;

// Store binary 1001 (which is 9 in decimal)
int binaryValue = 0b1001;

Sem o prefixo, 1001 seria interpretado como mil e um. Com 0b, é tratado como quatro dígitos binários representando o valor decimal 9. Os zeros à esquerda são opcionais. Escrever 0b00001001 é idêntico a 0b1001, mas a forma mais longa pode tornar as posições dos bits mais fáceis de ler quando você está trabalhando com larguras de bits específicas.

O tipo de variável é um int padrão. Você também pode usar uint (inteiro sem sinal) se não precisar de valores negativos, ou long para armazenamento de 64 bits. A sintaxe de literal binário funciona com qualquer um dos tipos de número inteiro.

Exibindo Números em Binário

[1:50 - 3:48] Armazenar um valor binário é uma coisa. Vê-lo como binário na tela é outra. Quando você imprime um int com Console.WriteLine, C# gera a representação em base 10. Para 0b1001, isso significa que você vê 9, não 1001.

Para obter a representação em string binária, use Convert.ToString() com um parâmetro de base:

int binaryValue = 0b1001;

// Convert to binary string (base 2)
string representation = Convert.ToString(binaryValue, 2);

Console.WriteLine($"Base 10: {binaryValue}");      // Output: 9
Console.WriteLine($"Base 2: {representation}");     // Output: 1001

int binaryValue = 0b1001;

// Convert to binary string (base 2)
string representation = Convert.ToString(binaryValue, 2);

Console.WriteLine($"Base 10: {binaryValue}");      // Output: 9
Console.WriteLine($"Base 2: {representation}");     // Output: 1001

O segundo argumento de Convert.ToString() especifica a base de saída. Os valores suportados são 2 (binário), 8 (octal), 10 (decimal) e 16 (hexadecimal). Tim demonstra a base 2, mas o mesmo método lida com todos os quatro.

Preenchendo com Zeros à Esquerda

[3:48 - 5:24] A saída bruta de Convert.ToString(binaryValue, 2) omite zeros à esquerda. Para 0b1001, o resultado é a string "1001", não "00001001". Quando você está trabalhando com bytes (8 bits), valores de 16 bits ou registros de 32 bits, ver a largura total com zeros à esquerda torna as posições dos bits imediatamente claras.

A correção é PadLeft():

// Pad to 8 characters (one byte) with leading zeros
string padded = Convert.ToString(binaryValue, 2).PadLeft(8, '0');

Console.WriteLine(padded);  // Output: 00001001

// Pad to 8 characters (one byte) with leading zeros
string padded = Convert.ToString(binaryValue, 2).PadLeft(8, '0');

Console.WriteLine(padded);  // Output: 00001001

PadLeft(8, '0') garante que a saída tenha pelo menos 8 caracteres, preenchendo qualquer posição faltante à esquerda com o caractere '0'. Tim observa o detalhe de que o segundo argumento é um char (aspas simples), não uma string. É o caractere zero, não o número zero, porque PadLeft constrói uma string a partir de caracteres individuais.

Para uma representação de 16 bits, altere 8 para 16. Para um inteiro completo de 32 bits, use 32. A largura do preenchimento deve corresponder à largura do bit que você está considerando.

Convertendo Qualquer Inteiro em Binário

[5:24 - 7:28] Tim faz um ponto fácil de negligenciar: você não precisa armazenar um valor como um literal binário para ver sua representação binária. Qualquer inteiro pode ser convertido para saída binária usando a mesma abordagem Convert.ToString():

// A regular base 10 integer
int decimalValue = 12;

// Convert to padded binary string
string binary = Convert.ToString(decimalValue, 2).PadLeft(8, '0');

Console.WriteLine($"Decimal: {decimalValue}");  // Output: 12
Console.WriteLine($"Binary: {binary}");          // Output: 00001100

// A regular base 10 integer
int decimalValue = 12;

// Convert to padded binary string
string binary = Convert.ToString(decimalValue, 2).PadLeft(8, '0');

Console.WriteLine($"Decimal: {decimalValue}");  // Output: 12
Console.WriteLine($"Binary: {binary}");          // Output: 00001100

O prefixo 0b é para quando você já tem um valor binário e deseja inseri-lo em forma binária. Para inteiros comuns, Convert.ToString() lida com a conversão. Ambos os caminhos produzem o mesmo resultado para o mesmo valor subjacente.

Como o C# Armazena Inteiros na Memória

[7:28 - 9:20] Tim encerra com um detalhe sobre como o C# armazena inteiros internamente. Um int em C# é um alias para System.Int32, um inteiro assinado de 32 bits. Isso significa que cada int ocupa 32 bits na memória, independentemente do quão pequeno o valor seja. Armazenar 0b1001 (o número 9) usa os mesmos 32 bits que armazenar 0b01111111111111111111111111111111 (mais de dois bilhões).

// What's actually stored in memory for binaryValue = 0b1001
// 00000000 00000000 00000000 00001001
string fullRepresentation = Convert.ToString(binaryValue, 2).PadLeft(32, '0');
Console.WriteLine(fullRepresentation);

// What's actually stored in memory for binaryValue = 0b1001
// 00000000 00000000 00000000 00001001
string fullRepresentation = Convert.ToString(binaryValue, 2).PadLeft(32, '0');
Console.WriteLine(fullRepresentation);

Isso se conecta a por que escolher o tamanho certo do tipo é importante. Um long (Int64) usa 64 bits, dobrando o espaço na memória. Para a maioria das aplicações, int (32 bits) cobre o alcance que você precisa. Mas se você estiver trabalhando em ambientes com restrições de memória ou processando milhões de valores, a diferença entre byte (8 bits), short (16 bits), int (32 bits) e long (64 bits) se torna significativa.

Conclusão: O Padrão Completo

[9:07 - 9:15] O padrão completo para trabalhar com binário em C# é conciso. Armazene valores usando o prefixo 0b quando você tiver entrada binária. Exiba-os usando Convert.ToString(value, 2) para saída bruta. Adicione .PadLeft(width, '0') quando precisar de formatação de largura fixa. E lembre-se de que o armazenamento subjacente é sempre um tipo de inteiro padrão, com a largura do bit determinada por se você escolhe byte, short, int ou long.

Conclusão

[9:15 - 9:20] Resumindo: literais binários usam o prefixo 0b, Convert.ToString(value, 2) produz a string binária, e PadLeft() adiciona zeros à esquerda para exibição de largura fixa. O valor é armazenado em um tipo de inteiro regular sob o capô, e um int sempre ocupa 32 bits, independentemente da magnitude do número.

Esses blocos de construção aparecem nas próximas lições da série, onde os valores binários precisam ser formatados corretamente para operações bit a bit.

Dica de Exemplo: Ao depurar operações bit a bit, preencha sua saída binária para a largura total do seu tipo (8 para byte, 16 para short, 32 para int). Ver todas as posições dos bits de uma vez torna as operações de deslocamento e máscara muito mais fáceis de rastrear. Um método auxiliar como string ToBinary(int val) => Convert.ToString(val, 2).PadLeft(32, '0'); economiza digitação repetida.

Assista ao vídeo completo em seu canal YouTube e ganhe mais insights sobre compreensão binária em C#.