C# Operatore di spostamento a sinistra bitwise

Nella programmazione C#, possiamo utilizzare gli operatori bitwise per eseguire le operazioni a livello di bit. Il calcolo del livello di bit viene eseguito nella CPU quando eseguiamo operazioni aritmetiche come aggiunta, sottrazione, moltiplicazione o divisione. Possiamo anche fare operazioni bitwise nella programmazione C# e il processo è semplice. Gli operatori bitwise eseguono un'operazione sul valore dato. Viene inoltre specificato il numero di bit da spostare. Ci sono sei operatori bitwise in lingua C#, due di loro sono operatori di turno.

Il nostro argomento di discussione riguarda gli operatori del turno. L'operatore di spostamento a sinistra bitwise (<<) 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.

Sintassi:

Operand_1 << Operand_2

Il primo "operand_1" è il valore che viene spostato da sinistra al numero di turni che contiene "operand_2". Il simbolo << left shifts the “Operand_1”.

Esempio 1:

L'operatore di spostamento a sinistra bitwise (<<) is applied to the integer values in this program.

usando il sistema;
Classe Program_1

statico void main ()
int value_0 = 34;
int value_1 = 65;
int res = value_0 << Value_1;
Console.Scrivere ("il turno sinistro è");
Console.Scrivere (res);

La prima dichiarazione contiene la dichiarazione e l'inizializzazione di due variabili di tipo intero. La prima variabile è "value_0" e la seconda variabile è "valore_1". I valori che sono memorizzati in essi sono "34" e "65". Abbiamo lasciato il turno del valore 34 utilizzando l'operatore di spostamento a sinistra (<<). 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.

Esempio 2:

Usiamo l'operatore di spostamento a sinistra sui valori interi non firmati e vediamo come producono l'output.

usando il sistema;
Classe Program_2

statico void main ()
uint val_0 = 4435;
int val_1 = 64;
Uint result = val_0 << Val_1;
Console.Scrivere ("il turno sinistro è");
Console.Scrivere (risultato);

Qui, applichiamo l'operatore di spostamento a sinistra sul valore del tipo intero non firmato. Una cosa di cui devi prenderti cura è che il secondo operando deve essere un valore di tipo intero perché il compilatore prende solo un valore intero per spostare.

Dopo aver chiamato la funzione main () del vuoto statico, dichiariamo due variabili: una delle quali è un valore intero non firmato "val_0" e l'altro è un valore intero "val_1". Quindi, definiamo un'altra variabile intera non firmata che è "risultato" per mantenere il valore risultante dopo aver lasciato il passaggio del numero intero non firmato. Non possiamo archiviare il risultato in una variabile di tipo intero perché dopo il cambio di sinistra, il risultato è un valore non firmato. Il "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:

Esempio 3:

In questo caso, parleremo dei diversi metodi di utilizzo dell'operatore di spostamento a sinistra bitwise (<<) on long integer values.

usando il sistema;
Classe Program_3

statico void main ()
Numero lungo_0 = 45;
Numero lungo_1 = 5;
Console.Scrivere ("lo spostamento sinistro di Long is");
Console.WriteLine (Number_0 << 3);
Console.Scrivere ("lo spostamento sinistro di Long is");
Console.Scrivi (numero_0 << Convert.ToInt16(number_1));

L'inizializzazione di due variabili di tipo intero lungo, "numero_0" e "numero_1", viene eseguita nella prima istruzione. Invocare la console.Funzione write () per rappresentare il messaggio "lo spostamento sinistro di lungo è" e il risultato sul terminale. Qui, applichiamo l'operatore di shift sinistro (<<) 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:

Esempio 4:

Questo codice mostra come possiamo assegnare i valori a un numero intero dopo aver eseguito lo spostamento a sinistra sull'operatore lungo non firmato.

usando il sistema;
Classe Program_4

statico void main ()
Ulong Number_0 = 445;
Console.Scrivi ("lo spostamento sinistro di Ulong è");
Console.WriteLine (Number_0 << 8);
Console.Scrivi ("lo spostamento sinistro di Ulong è");
Console.WriteLine (Number_0 << 16);
Console.Scrivi ("lo spostamento sinistro di Ulong è");
Console.WriteLine (Number_0 << 32);

Innanzitutto, dichiarare una variabile di tipo intero lungo non firmato che è "numero_0". Successivamente, mostra il testo "Il turno di sinistra di Ulong è" sul terminale chiamando la console.Metodo Write (). Troveremo lo spostamento a sinistra del "numero_0" con un valore intero di 8 e non abbiamo bisogno di archiviare il risultato da nessuna parte. La console.La funzione WriteLine () stampa il risultato sulla console. Ripeti questo processo due volte e modifica i valori del secondo operando. In questo modo, possiamo trovare lo spostamento a sinistra di un lungo valore di tipo intero non firmato. Ma se vogliamo salvare il valore risultante in una variabile, dovremmo mantenere il pensiero che il risultato sia lo stesso tipo del primo operando. L'unica differenza tra la console.Scrivi () e console.WriteLine () è che la seconda funzione stampa il risultato e invia il cursore alla riga successiva mentre la prima funzione stampica solo il risultato e il cursore lampeggia sulla stessa riga anche dopo aver visualizzato l'uscita.

Conclusione

Abbiamo esplorato gli operatori bitwise in C#, i loro tipi e le funzionalità. Il turno sinistro (<<) 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.