Notre sujet de discussion concerne les opérateurs de décalage. L'opérateur de décalage à gauche au niveau du bit (<<) sera expliqué en détail. L'opérateur de décalage, comme son nom l'indique, décale le bit de la position spécifiée vers la gauche ou vers la droite. La valeur est déplacée vers la gauche du nombre de bits spécifié lors de l'utilisation de l'opérateur de décalage vers la gauche au niveau du bit (<<). Les opérateurs de décalage vers la gauche prennent l'entrée uniquement en int (entier), uint (entier non signé), long (entier long) et ulong (entier long non signé). Lorsque l'opérande gauche appartient à un type différent, il est converti en type entier. Le type de données de la valeur résultante conserve une limite de 32 bits ; la sortie ne peut pas être plus grande que cela. Les opérateurs au niveau du bit rendent le code efficace et plus rapide. De plus, ils offrent plus de justesse et de précision.
Syntaxe:
Opérande_1 << Opérande_2
Le premier 'Opérande_1' est la valeur qui est décalée de la gauche au nombre de décalages que contient 'Opérande_2'. Le symbole << vers la gauche décale l'“Opérande_1”.
Exemple 1:
L'opérateur de décalage à gauche au niveau du bit (<<) est appliqué aux valeurs entières dans ce programme.
utiliser le système ;
programme de classe_1
{
vide statique principal ( ) {
valeur entière_0 = 3. 4 ;
valeur entière_1 = 65 ;
entier résolution = Valeur_0 << Valeur_1 ;
Console.Write ( 'Le décalage vers la gauche est ' ) ;
Console.Write ( résolution ) ;
}
}
La première instruction contient la déclaration et l'initialisation de deux variables de type entier. La première variable est 'Valeur_0' et la deuxième variable est 'Valeur_1'. Les valeurs qui y sont stockées sont '34' et '65'. Nous avons décalé à gauche la valeur 34 en utilisant l'opérateur de décalage à gauche (<<). Ensuite, nous déclarons une autre variable qui a un type de données entier pour enregistrer le résultat. Ici, nous utilisons l'opérateur de décalage vers la gauche (<<) comme Value_0 << Value_1. Cet opérateur décale à gauche la valeur gauche de l'opérande gauche de la valeur donnée dans le deuxième opérande. Le 'res' stocke la sortie de l'opérateur de décalage. Après cela, nous appelons la méthode Console.Write () pour imprimer le texte 'Le décalage à gauche est' et la valeur résultante qui est stockée dans 'res' sur le terminal.
Exemple 2 :
Utilisons l'opérateur de décalage à gauche sur les valeurs entières non signées et voyons comment ils produisent la sortie.
utiliser le système ;
programme de classe_2
{
vide statique principal ( ) {
uint Val_0 = 4435 ;
entier Val_1 = 64 ;
uint résultat = Val_0 << Val_1 ;
Console.Write ( 'Le décalage à gauche est' ) ;
Console.Write ( résultat ) ;
}
}
Ici, nous appliquons l'opérateur de décalage à gauche sur la valeur de type entier non signé. Une chose dont vous devez tenir compte est que le deuxième opérande doit être une valeur de type entier car le compilateur ne prend qu'une valeur entière à décaler.
Après avoir appelé la fonction statique void Main(), nous déclarons deux variables - dont l'une est une valeur entière non signée 'Val_0' et l'autre est une valeur entière 'Val_1'. Ensuite, nous définissons une autre variable entière non signée qui est 'résultat' pour conserver la valeur résultante après le décalage à gauche de l'entier non signé. On ne peut pas stocker le résultat dans une variable de type entier car après décalage vers la gauche, le résultat est une valeur non signée. L'instruction 'Val_0 << Val_1' décale vers la gauche l'opérande gauche qui est une valeur entière non signée. Il produit une valeur entière non signée. À la fin, affichez le résultat sur l'écran de sortie avec le texte 'Le décalage à gauche est' en utilisant la méthode Console.Write() :
Exemple 3 :
Dans cet exemple, nous parlerons des différentes méthodes d'utilisation de l'opérateur de décalage à gauche au niveau du bit (<<) sur des valeurs entières longues.
utiliser le système ;programme de classe_3
{
vide statique principal ( ) {
nombre long_0 = Quatre cinq ;
nombre long_1 = 5 ;
Console.Write ( 'Le décalage à gauche de long est ' ) ;
Console.WriteLineConsole.WriteLine ( nombre_0 << 3 ) ;
Console.Write ( 'Le décalage à gauche de long est ' ) ;
Console.Write ( nombre_0 << Convert.ToInt16 ( numéro 1 ) ) ;
}
}
L'initialisation de deux variables de type entier long, « nombre_0 » et « nombre_1 », se fait dans la première instruction. Appelez la fonction Console.Write() pour représenter le message 'Le décalage à gauche de long est' et le résultat sur le terminal. Ici, nous appliquons l'opérateur de décalage à gauche (<<) de manière à placer le premier opérande comme première variable et le deuxième opérande comme valeur entière. Le compilateur décale à gauche le premier opérande qui est « number_0 » de 3 et affiche le résultat. Dans l'instruction suivante, imprimez un autre message à l'écran en utilisant la méthode Console.Write(). Ici, nous utilisons la première variable, 'number_0', comme premier opérande et la deuxième variable, 'number_1', comme deuxième opérande. Le deuxième opérande doit être une valeur de type entier. Nous transtypons la deuxième variable 'number_1' en type entier à l'aide de la fonction Convert.ToInt16(). Ensuite, affichez le résultat sur la console :
Exemple 4 :
Ce code montre comment nous pouvons attribuer les valeurs à un entier après avoir effectué le décalage vers la gauche sur l'opérateur long non signé.
utiliser le système ;programme de classe_4
{
vide statique principal ( ) {
numéro de tête_0 = 445 ;
Console.Write ( 'Le décalage à gauche de ulong est' ) ;
Console.WriteLineConsole.WriteLine ( nombre_0 << 8 ) ;
Console.Write ( 'Le décalage à gauche de ulong est' ) ;
Console.WriteLineConsole.WriteLine ( nombre_0 << 16 ) ;
Console.Write ( 'Le décalage à gauche de ulong est' ) ;
Console.WriteLineConsole.WriteLine ( nombre_0 << 32 ) ;
}
}
Tout d'abord, déclarez une variable de type entier long non signé qui est 'number_0'. Ensuite, affichez le texte 'Le décalage à gauche de ulong est' sur le terminal en appelant la méthode Console.Write(). Nous trouverons le décalage à gauche du 'nombre_0' par une valeur entière de 8 et nous n'avons pas besoin de stocker le résultat nulle part. La fonction Console.WriteLine() imprime le résultat sur la console. Répétez ce processus deux fois et modifiez les valeurs du deuxième opérande. En faisant cela, nous pouvons trouver le décalage vers la gauche d'une valeur de type entier long non signé. Mais si nous voulons enregistrer la valeur résultante dans une variable, nous devons garder à l'esprit que le résultat est du même type que le premier opérande. La seule différence entre Console.Write() et Console.WriteLine() est que la deuxième fonction imprime le résultat et envoie le curseur à la ligne suivante tandis que la première fonction imprime uniquement le résultat et le curseur clignote sur la même ligne même après afficher la sortie.
Conclusion
Nous avons exploré les opérateurs Bitwise en C #, leurs types et leurs fonctionnalités. L'opérateur de décalage vers la gauche (<<) est appliqué pour décaler le nombre ou la valeur d'un nombre défini de bits vers la gauche. Les opérateurs Bitwise améliorent l'efficacité du code et ne surchargent pas le système car ce sont des opérateurs légers. Notre CPU (unité de traitement informatique) fonctionne au niveau Bitwise chaque fois que nous effectuons des opérations arithmétiques. En un mot, les opérateurs Bitwise sont importants dans la programmation et C # prend en charge tous les opérateurs Bitwise dans lesquels l'opérateur de décalage à gauche (<<) est l'un d'entre eux.