Ang aming paksa ng talakayan ay tungkol sa mga shift operator. Ang Bitwise left shift operator (<<) ay ipapaliwanag nang detalyado. Ang shift operator, gaya ng ipinahihiwatig ng pangalan, ay inililipat ang bit mula sa tinukoy na posisyon sa kaliwa o sa kanan. Ang halaga ay inilipat sa kaliwa ng tinukoy na bilang ng mga bit habang ginagamit ang bitwise left shift operator (<<). Ang kaliwang shift operator ay kumukuha ng input lamang sa int (integer), uint (unsigned integer), long (long integer), at ulong (unsigned long integer). Kapag ang kaliwang operand ay kabilang sa ibang uri, ito ay na-convert sa uri ng integer. Ang uri ng data ng resultang halaga ay nagpapanatili ng limitasyon na 32 bits; ang output ay hindi maaaring mas malaki kaysa doon. Ginagawa ng mga bitwise operator ang code na mahusay at mas mabilis. Bukod dito, nag-aalok sila ng higit na katumpakan at katumpakan.
Syntax:
Operand_1 << Operand_2
Ang unang 'Operand_1' ay ang value na inilipat mula sa kaliwa patungo sa bilang ng mga shift na naglalaman ng 'Operand_2'. Ang simbolo na << pakaliwa ay inilipat ang 'Operand_1'.
Halimbawa 1:
Ang Bitwise left shift operator (<<) ay inilapat sa mga integer value sa program na ito.
gamit ang System;
Programa ng klase_1
{
static void Main ( ) {
int Value_0 = 3. 4 ;
int Halaga_1 = 65 ;
int res = Halaga_0 << Halaga_1;
Console.Isulat ( 'Ang kaliwang shift ay ' ) ;
Console.Isulat ( res ) ;
}
}
Ang unang pahayag ay naglalaman ng deklarasyon at pagsisimula ng dalawang integer-type na variable. Ang unang variable ay “Value_0” at ang pangalawang variable ay “Value_1”. Ang mga halaga na nakaimbak sa kanila ay '34' at '65'. Iniwan namin ang shift ng value 34 gamit ang left shift operator (<<). Pagkatapos, nagdedeklara kami ng isa pang variable na may integer na uri ng data upang i-save ang resulta. Dito, ginagamit namin ang left shift operator (<<) bilang Value_0 << Value_1. Ang kaliwang operator na ito ay inililipat ang kaliwang halaga ng operand sa pamamagitan ng ibinigay na halaga sa pangalawang operand. Iniimbak ng 'res' ang output ng shift operator. Pagkatapos nito, tinatawagan namin ang Console.Write() na paraan para mag-print ng text na 'The left shift is' at ang resultang value na naka-store sa 'res' sa terminal.
Halimbawa 2:
Gamitin natin ang left shift operator sa mga unsigned integer value at tingnan kung paano nila ginagawa ang output.
gamit ang System;
Programa ng klase_2
{
static void Main ( ) {
uint Val_0 = 4435 ;
int Val_1 = 64 ;
uint resulta = Val_0 << Val_1;
Console.Isulat ( 'Ang kaliwang shift ay' ) ;
Console.Isulat ( resulta ) ;
}
}
Dito, inilalapat namin ang left shift operator sa unsigned integer type value. Ang isang bagay na dapat mong alagaan ay ang pangalawang operand ay dapat na isang integer na uri ng halaga dahil ang compiler ay tumatagal lamang ng isang integer na halaga upang ilipat.
Pagkatapos tawagan ang static void Main() function, idedeklara namin ang dalawang variable – ang isa ay unsigned integer value na “Val_0” at ang isa ay integer value na “Val_1”. Pagkatapos, tutukuyin namin ang isa pang unsigned integer variable na 'resulta' upang mapanatili ang resultang value pagkatapos kaliwa na ilipat ang unsigned integer. Hindi namin maiimbak ang resulta sa isang variable na uri ng integer dahil pagkatapos ng kaliwang paglilipat, ang resulta ay isang hindi napirmahang halaga. Ang “Val_0 << Val_1” na statement sa kaliwa ay inililipat ang kaliwang operand na isang unsigned integer value. Gumagawa ito ng unsigned integer value. Sa huli, ipakita ang resulta sa output screen na may text na 'The left shift is' gamit ang Console.Write() method:
Halimbawa 3:
Sa pagkakataong ito, pag-uusapan natin ang iba't ibang paraan ng paggamit ng Bitwise left shift operator (<<) sa mga mahahabang halaga ng integer.
gamit ang System;Programa ng klase_3
{
static void Main ( ) {
mahabang numero_0 = Apat. Lima ;
mahabang numero_1 = 5 ;
Console.Isulat ( 'Ang kaliwang shift ng mahaba ay' ) ;
Console.WriteLine ( numero_0 << 3 ) ;
Console.Isulat ( 'Ang kaliwang shift ng mahaba ay' ) ;
Console.Isulat ( numero_0 << I-convert.ToInt16 ( numero_1 ) ) ;
}
}
Ang pagsisimula ng dalawang mahahabang variable ng uri ng integer, 'number_0' at 'number_1', ay ginagawa sa unang statement. I-invoke ang function na Console.Write() upang kumatawan sa mensaheng 'The left shift of long is' at ang resulta sa terminal. Dito, inilalapat namin ang left shift operator (<<) sa paraang inilalagay namin ang unang operand bilang unang variable at ang pangalawang operand bilang isang integer na halaga. Inilipat ng compiler sa kaliwa ang unang operand na 'number_0' ng 3 at ipinapakita ang resulta. Sa susunod na pahayag, mag-print ng isa pang mensahe sa screen sa pamamagitan ng paggamit ng Console.Write() na paraan. Dito, ginagamit namin ang unang variable, 'number_0', bilang ang unang operand at ang pangalawang variable, 'number_1', bilang pangalawang operand. Ang pangalawang operand ay dapat na isang halaga ng uri ng integer. I-typecast namin ang pangalawang variable na 'number_1' sa uri ng integer gamit ang function na Convert.ToInt16(). Pagkatapos, ipakita ang kinalabasan sa console:
Halimbawa 4:
Ipinapakita ng code na ito kung paano namin itatalaga ang mga value sa isang integer pagkatapos isagawa ang left shift sa unsigned long operator.
gamit ang System;Programa ng klase_4
{
static void Main ( ) {
ulong number_0 = 445 ;
Console.Isulat ( 'Ang kaliwang shift ng ulong ay ' ) ;
Console.WriteLine ( numero_0 << 8 ) ;
Console.Isulat ( 'Ang kaliwang shift ng ulong ay ' ) ;
Console.WriteLine ( numero_0 << 16 ) ;
Console.Isulat ( 'Ang kaliwang shift ng ulong ay ' ) ;
Console.WriteLine ( numero_0 << 32 ) ;
}
}
Una, magdeklara ng isang unsigned long integer type variable na 'number_0'. Susunod, ipakita ang text na 'The left shift of ulong is' sa terminal sa pamamagitan ng pagtawag sa Console.Write() method. Hahanapin namin ang kaliwang shift ng 'number_0' sa pamamagitan ng isang integer na halaga na 8 at hindi namin kailangang iimbak ang resulta kahit saan. Ang Console.WriteLine() function ay nagpi-print ng resulta sa console. Ulitin ang prosesong ito ng dalawang beses at baguhin ang mga halaga ng pangalawang operand. Sa paggawa nito, mahahanap natin ang kaliwang shift ng isang mahabang hindi naka-sign na halaga ng uri ng integer. Ngunit kung gusto nating i-save ang resultang halaga sa isang variable, dapat nating panatilihin sa mga saloobin na ang resulta ay ang parehong uri ng unang operand. Ang tanging pagkakaiba sa pagitan ng Console.Write() at Console.WriteLine() ay ang pangalawang function ay nagpi-print ng kinalabasan at nagpapadala ng cursor sa susunod na linya habang ang unang function ay nagpi-print lamang ng resulta at ang cursor ay kumukurap sa parehong linya kahit na pagkatapos pagpapakita ng output.
Konklusyon
Ginalugad namin ang mga operator ng Bitwise sa C#, ang kanilang mga uri, at mga functionality. Ang left shift (<<) operator ay inilapat upang ilipat ang numero o halaga sa pamamagitan ng tiyak na bilang ng mga bit sa kaliwa. Pinapabuti ng mga operator ng Bitwise ang kahusayan ng code at hindi ito nagpapabigat sa system dahil sila ay mga magaan na operator. Gumagana ang aming CPU (computer processing unit) sa antas ng Bitwise sa tuwing nagsasagawa kami ng anumang mga operasyon sa aritmetika. Sa madaling sabi, ang mga operator ng Bitwise ay mahalaga sa programming at sinusuportahan ng C# ang lahat ng mga operator ng Bitwise kung saan isa sa mga ito ang left shift operator (<<).