C# Operador de mudança de esquerda bittude

C# Operador de mudança de esquerda bittude
Na programação C#, podemos usar os operadores bitwise para executar as operações no nível de bits. O cálculo do nível de bits é feito na CPU quando realizamos operações aritméticas como adição, subtração, multiplicação ou divisão. Também podemos fazer operações bit netise na programação C# e o processo é simples. Os operadores bitwise realizam uma operação no valor fornecido. O número de bits para mudar também é especificado. Existem seis operadores bit -bitwise em C# Language, dois deles são operadores de turno.

Nosso tópico de discussão é sobre os operadores de turno. O operador de mudança de esquerda bittude (<<) 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.

Sintaxe:

Operand_1 << Operand_2

O primeiro "operando_1" é o valor que é deslocado da esquerda para o número de turnos que o "operando_2" contém. O símbolo << left shifts the “Operand_1”.

Exemplo 1:

O operador de mudança de esquerda bittude (<<) is applied to the integer values in this program.

usando o sistema;
Classe Program_1

estático void main ()
int vale_0 = 34;
int vale_1 = 65;
int res = value_0 << Value_1;
Console.Escreva ("O turno esquerdo é");
Console.Escreva (res);

A primeira declaração contém a declaração e a inicialização de duas variáveis ​​do tipo inteiro. A primeira variável é "value_0" e a segunda variável é "value_1". Os valores armazenados neles são "34" e "65". Deixamos o turno do valor 34 Usando o operador de mudança de esquerda (<<). 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.

Exemplo 2:

Vamos usar o operador de mudança de esquerda nos valores inteiros não assinados e ver como eles produzem a saída.

usando o sistema;
Classe Program_2

estático void main ()
uint val_0 = 4435;
int val_1 = 64;
resultado uint = val_0 << Val_1;
Console.Escreva ("O turno esquerdo é");
Console.Gravar (resultado);

Aqui, aplicamos o operador de turno esquerdo no valor do tipo inteiro não assinado. Uma coisa que você deve cuidar é que o segundo operando deve ser um valor do tipo inteiro, porque o compilador leva apenas um valor inteiro para mudar.

Depois de chamar a função estática do vazio principal (), declaramos duas variáveis ​​- uma das quais é um valor inteiro não assinado "val_0" e o outro é um valor inteiro "val_1". Em seguida, definimos outra variável inteira não assinada que é "resultado" para manter o valor resultante depois de esquerda mudando o número inteiro não assinado. Não podemos armazenar o resultado em uma variável do tipo inteiro porque, após a mudança da esquerda, o resultado é um valor não assinado. O “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:

Exemplo 3:

Nesse caso, falaremos sobre os diferentes métodos de usar o operador de mudança de esquerda bit -bitween (<<) on long integer values.

usando o sistema;
Classe Program_3

estático void main ()
número longo_0 = 45;
número longo_1 = 5;
Console.Escreva ("A mudança esquerda de Long Is");
Console.WriteLine (número_0 << 3);
Console.Escreva ("A mudança esquerda de Long Is");
Console.Escreva (número_0 << Convert.ToInt16(number_1));

A inicialização de duas variáveis ​​do tipo inteiro longo, "número_0" e "número_1", é feito na primeira declaração. Invocar o console.Write () função para representar a mensagem "A mudança esquerda de longa é" e o resultado no terminal. Aqui, aplicamos o operador de turno esquerdo (<<) 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:

Exemplo 4:

Este código mostra como podemos atribuir os valores a um número inteiro depois de executar o turno esquerdo no operador longo não assinado.

usando o sistema;
Classe Program_4

estático void main ()
Ulong Number_0 = 445;
Console.Escreva ("A mudança esquerda de Ulong é");
Console.WriteLine (número_0 << 8);
Console.Escreva ("A mudança esquerda de Ulong é");
Console.WriteLine (número_0 << 16);
Console.Escreva ("A mudança esquerda de Ulong é");
Console.WriteLine (número_0 << 32);

Primeiro, declare uma variável do tipo inteiro longo não assinado que é "número_0". Em seguida, mostre o texto "A mudança esquerda de Ulong é" no terminal chamando o console.Método Write (). Encontraremos a mudança à esquerda do "número_0" por um valor inteiro de 8 e não precisamos armazenar o resultado em nenhum lugar. O console.Função writeLine () imprime o resultado no console. Repita este processo duas vezes e altere os valores do segundo operando. Ao fazer isso, podemos encontrar o turno esquerdo de um valor inteiro não assinado longo. Mas se queremos salvar o valor resultante em uma variável, devemos manter os pensamentos de que o resultado é o mesmo tipo que o primeiro operando. A única diferença entre o console.Write () e console.WriteLine () é que a segunda função imprime o resultado e envia o cursor para a próxima linha, enquanto a primeira função imprime apenas o resultado e o cursor pisca na mesma linha, mesmo depois de exibir a saída.

Conclusão

Exploramos os operadores bitwise em C#, seus tipos e funcionalidades. O turno esquerdo (<<) 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.