C # Opérateur de quart de bitwise gauche

Dans la programmation C #, nous pouvons utiliser les opérateurs de bitwise pour effectuer les opérations au niveau du bit. Le calcul du niveau du bit est effectué dans le CPU lorsque nous effectuons des opérations arithmétiques comme l'addition, la soustraction, la multiplication ou la division. Nous pouvons également faire des opérations bit dans la programmation C # et le processus est simple. Les opérateurs bitwise effectuent une opération sur la valeur donnée. Le nombre de bits à déplacer est également spécifié. Il y a six opérateurs de bitwise en langue C #, deux d'entre eux sont des opérateurs de quart.

Notre sujet de discussion concerne les opérateurs de quart. L'opérateur de changement de vitesse à gauche (<<) will be explained in detail. The shift operator, as the name suggests, shifts the bit from the specified position to the left or to the right. The value is moved to the left by the specified number of bits while using the bitwise left shift operator (<<). The left shift operators take the input only in int (integer), uint (unsigned integer), long (long integer), and ulong (unsigned long integer). When the left operand belongs to a different type, it is converted to the integer type. The data type of the resultant value retains a limit of 32 bits; the output cannot be larger than that. Bitwise operators make the code efficient and faster. Moreover, they offer more accuracy and precision.

Syntaxe:

Opérand_1 << Operand_2

Le premier «Operand_1» est la valeur qui est déplacée de la gauche vers le nombre de changements que contenu «Operand_2». Le symbole << left shifts the “Operand_1”.

Exemple 1:

L'opérateur de changement de vitesse à gauche (<<) is applied to the integer values in this program.

Utilisation du système;
Programme de classe_1

statique void main ()
int Value_0 = 34;
int Value_1 = 65;
int res = value_0 << Value_1;
Console.Écrire ("Le Shift de gauche est");
Console.Écrire (res);

La première instruction contient la déclaration et l'initialisation de deux variables de type entier. La première variable est "Value_0" et la deuxième variable est "Value_1". Les valeurs qui y sont stockées sont «34» et «65». Nous avons à gauche la valeur 34 à l'aide de l'opérateur de changement de gauche (<<). Then, we declare another variable that has an integer data type to save the result. Here, we utilize the left shift operator (<<) as Value_0 << Value_1. This operator left shifts the left operand's left value by the given value in the second operand. The “res” stores the output of the shift operator. After this, we call the Console.Write() method to print text “The left shift is” and the resultant value that is stored in “res” on the terminal.

Exemple 2:

Utilisons l'opérateur de changement de gauche sur les valeurs entières non signées et voyons comment ils produisent la sortie.

Utilisation du système;
Classe Program_2

statique void main ()
uint val_0 = 4435;
int Val_1 = 64;
Résultat uint = VAL_0 << Val_1;
Console.Écrire ("Le Shift de gauche est");
Console.Écrire (résultat);

Ici, nous appliquons l'opérateur de changement de gauche sur la valeur de type entier non signé. Une chose dont vous devez prendre soin est que le deuxième opérande doit être une valeur de type entier car le compilateur ne prend qu'une valeur entière pour changer.

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 maintenir la valeur résultante après la gauche de déplacer l'entier non signé. Nous ne pouvons pas stocker le résultat dans une variable de type entier car après le déplacement de gauche, le résultat est une valeur non signée. Le «Val_0 << Val_1” statement left shifts the left operand that is an unsigned integer value. It produces an unsigned integer value. In the end, show the result on the output screen with the text “The left shift is” using the Console.Write() method:

Exemple 3:

Dans ce cas, nous parlerons des différentes méthodes d'utilisation de l'opérateur de décalage gauche à gauche (<<) on long integer values.

Utilisation du système;
programme de classe_3

statique void main ()
Long Number_0 = 45;
Long Number_1 = 5;
Console.Écrire ("Le décalage gauche de Long est");
Console.Writeline (numéro_0 << 3);
Console.Écrire ("Le décalage gauche de Long est");
Console.Écrire (numéro_0 << Convert.ToInt16(number_1));

L'initialisation de deux variables de type entier long, "Number_0" et "Number_1", se fait dans la première instruction. Invoquez la console.La fonction écrite () 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 changement de gauche (<<) in such a way that we place the first operand as the first variable and the second operand as an integer value. The compiler left shifts the first operand which is “number_0” by 3 and displays the result. In the next statement, print another message on the screen by employing the Console.Write() method. Here, we utilize the first variable, “number_0”, as the first operand and the second variable, “number_1”, as the second operand. The second operand must be an integer type value. We typecast the second variable “number_1” to the integer type using the Convert.ToInt16() function. Then, display the outcome on the console:

Exemple 4:

Ce code montre comment nous pouvons attribuer les valeurs à un entier après avoir effectué le décalage de gauche sur l'opérateur long non signé.

Utilisation du système;
Programme de classe_4

statique void main ()
ULONG NUMBRE_0 = 445;
Console.Écrire ("Le décalage gauche d'Ulong est");
Console.Writeline (numéro_0 << 8);
Console.Écrire ("Le décalage gauche d'Ulong est");
Console.Writeline (numéro_0 << 16);
Console.Écrire ("Le décalage gauche d'Ulong est");
Console.Writeline (numéro_0 << 32);

Tout d'abord, déclarez une variable de type entier long non signé qui est "Number_0". Ensuite, montrez le texte «Le décalage gauche d'Ulong est» sur le terminal en appelant la console.Méthode écrite (). Nous trouverons le décalage gauche du «numéro_0» par une valeur entière de 8 et nous n'avons pas besoin de stocker le résultat n'importe où. La console.La fonction writeLine () imprime le résultat sur la console. Répétez ce processus deux fois et modifiez les valeurs du deuxième opérande. Ce faisant, nous pouvons trouver le décalage gauche d'une longue valeur de type entier non signé. Mais si nous voulons enregistrer la valeur résultante dans une variable, nous devons garder dans les pensées que le résultat est le même type que le premier opérande. La seule différence entre la console.Écrire () 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 avoir affiché la sortie.

Conclusion

Nous avons exploré les opérateurs bitwise en C #, leurs types et les fonctionnalités. Le changement de gauche (<<) operator is applied to shift the number or value by the definite number of bits to the left. The Bitwise operators improve the efficiency of the code and it does not burden the system since they are lightweight operators. Our CPU (computer processing unit) works on the Bitwise level whenever we perform any arithmetic operations. In a nutshell, the Bitwise operators are important in programming and C# supports all the Bitwise operators in which the left shift operator (<<) is one of them.