Stockage et affichage des valeurs binaires en C#

Stocker des littéraux binaires en C

[0:00 - 1:50] La première question que Tim aborde est simple : comment mettez-vous un nombre binaire dans une variable C# ? La réponse est le préfixe 0b, qui dit au compilateur d'interpréter les chiffres comme une base 2 plutôt que la base 10 par défaut.

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

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

Sans le préfixe, 1001 serait interprété comme mille et un. Avec 0b, il est traité comme quatre chiffres binaires représentant la valeur décimale 9. Les zéros initiaux sont optionnels. Écrire 0b00001001 est identique à 0b1001, mais la forme plus longue peut rendre les positions de bit plus faciles à lire lorsque vous travaillez avec des largeurs de bit spécifiques.

Le type de variable est un int standard. Vous pouvez également utiliser uint (entier non signé) si vous n'avez pas besoin de valeurs négatives, ou long pour un stockage 64 bits. La syntaxe des littéraux binaires fonctionne avec n'importe lequel des types de nombres entiers.

Afficher les nombres en binaire

[1:50 - 3:48] Stocker une valeur binaire est une chose. La voir en binaire à l'écran en est une autre. Lorsque vous imprimez un int avec Console.WriteLine, C# produit la représentation en base 10. Pour 0b1001, cela signifie que vous voyez 9, pas 1001.

Pour obtenir la représentation binaire sous forme de chaîne, utilisez Convert.ToString() avec un paramètre 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

Le second argument de Convert.ToString() spécifie la base de sortie. Les valeurs prises en charge sont 2 (binaire), 8 (octal), 10 (décimal) et 16 (hexadécimal). Tim démontre la base 2, mais la même méthode traite les quatre.

Compléter avec des zéros initiaux

[3:48 - 5:24] La sortie brute de Convert.ToString(binaryValue, 2) omet les zéros en tête. Pour 0b1001, le résultat est la chaîne "1001", pas "00001001". Lorsque vous travaillez avec des octets (8 bits), des valeurs de 16 bits, ou des registres de 32 bits, voir la largeur complète avec des zéros initiaux rend les positions de bit immédiatement claires.

La solution est 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') assure que la sortie a au moins 8 caractères de long, remplissant les positions manquantes à gauche avec le caractère '0'. Tim note le détail que le deuxième argument est un char (guillemets simples), pas une chaîne. C'est le caractère zéro, pas le nombre zéro, car PadLeft construit une chaîne à partir de caractères individuels.

Pour une représentation de 16 bits, changez 8 en 16. Pour un entier complet de 32 bits, utilisez 32. La largeur du remplissage doit correspondre à la largeur de bit à laquelle vous vous rapportez.

Convertir n'importe quel entier en binaire

[5:24 - 7:28] Tim souligne un point facile à ignorer : il n'est pas nécessaire de stocker une valeur comme un littéral binaire pour voir sa représentation binaire. Tout entier peut être converti en sortie binaire en utilisant la même approche 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

Le préfixe 0b est pour lorsque vous avez déjà une valeur binaire et que vous souhaitez la saisir sous forme binaire. Pour les entiers normaux, Convert.ToString() gère la conversion. Les deux chemins produisent le même résultat pour la même valeur sous-jacente.

Comment C# stocke les entiers en mémoire

[7:28 - 9:20] Tim termine par un détail sur la manière dont C# stocke les entiers en interne. Un int en C# est un alias de System.Int32, un entier signé de 32 bits. Cela signifie que chaque int occupe 32 bits en mémoire, quelle que soit la taille de la valeur. Stocker 0b1001 (le numéro 9) utilise les mêmes 32 bits que stocker 0b01111111111111111111111111111111 (plus de deux milliards).

// 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);

Cela se relie à pourquoi choisir la bonne taille de type est important. Un long (Int64) utilise 64 bits, doublant l'empreinte mémoire. Pour la plupart des applications, un int (32 bits) couvre la plage dont vous avez besoin. Mais si vous travaillez dans des environnements à mémoire contrainte ou si vous traitez des millions de valeurs, la différence entre byte (8 bits), short (16 bits), int (32 bits) et long (64 bits) devient significative.

Conclusion : le modèle complet

[9:07 - 9:15] Le modèle complet pour travailler avec le binaire en C# est concis. Stockez les valeurs en utilisant le préfixe 0b lorsque vous avez une entrée binaire. Affichez-les en utilisant Convert.ToString(value, 2) pour une sortie brute. Ajoutez .PadLeft(width, '0') lorsque vous avez besoin d'un formatage à largeur fixe. Et rappelez-vous que le stockage sous-jacent est toujours un type d'entier standard, avec la largeur de bit déterminée par votre choix de byte, short, int ou long.

Conclusion

[9:15 - 9:20] Pour résumer : les littéraux binaires utilisent le préfixe 0b, Convert.ToString(value, 2) produit la chaîne binaire, et PadLeft() ajoute les zéros en tête pour un affichage à largeur fixe. La valeur est stockée dans un type d'entier standard à l'intérieur, et un int occupe toujours 32 bits quel que soit l'ordre de grandeur du nombre.

Ces blocs de construction apparaîtront dans les prochaines leçons de la série, où les valeurs binaires doivent être correctement formatées pour les opérations bit à bit.

Astuce d'exemple : lors du débogage d'opérations bit à bit, complétez votre sortie binaire à la largeur totale de votre type (8 pour les octets, 16 pour les courts, 32 pour les int). Voir toutes les positions de bit à la fois rend les opérations de décalage et de masque beaucoup plus faciles à tracer. Une méthode assistante comme string ToBinary(int val) => Convert.ToString(val, 2).PadLeft(32, '0'); évite de taper plusieurs fois.

Regardez la vidéo complète sur sa chaîne YouTube pour en savoir plus sur la compréhension du binaire en C#.