Vores diskussionsemne handler om vagtoperatørerne. Den bitvise venstreskiftoperator (<<) vil blive forklaret i detaljer. Skiftoperatoren, som navnet antyder, flytter bittet fra den angivne position til venstre eller højre. Værdien flyttes til venstre med det angivne antal bit, mens du bruger den bitvise venstreskiftoperator (<<). Venstreskiftsoperatorerne tager kun input i int (heltal), uint (heltal uden fortegn), langt (langt heltal) og ulong (langt heltal uden fortegn). Når venstre operand tilhører en anden type, konverteres den til heltalstypen. Datatypen for den resulterende værdi bevarer en grænse på 32 bit; output kan ikke være større end det. Bitvise operatører gør koden effektiv og hurtigere. Desuden tilbyder de mere nøjagtighed og præcision.
Syntaks:
Operand_1 << Operand_2
Den første 'Operand_1' er den værdi, der flyttes fra venstre til det antal skift, som 'Operand_2' indeholder. Symbolet << til venstre flytter 'Operand_1'.
Eksempel 1:
Bitwise left shift-operatoren (<<) anvendes på heltalværdierne i dette program.
bruger System;
klasse Program_1
{
statisk tomrum Main ( ) {
int Værdi_0 = 3. 4 ;
int Værdi_1 = 65 ;
int res = Værdi_0 << Værdi_1;
Konsol.Skriv ( 'Venstre skift er ' ) ;
Konsol.Skriv ( res ) ;
}
}
Den første sætning indeholder erklæringen og initialiseringen af to heltalsvariabler. Den første variabel er 'Value_0', og den anden variabel er 'Value_1'. Værdierne, der er gemt i dem, er '34' og '65'. Vi forlod skift værdien 34 ved at bruge venstre skift-operator (<<). Derefter erklærer vi en anden variabel, der har en heltalsdatatype for at gemme resultatet. Her bruger vi den venstre skiftoperator (<<) som Value_0 << Value_1. Denne operator til venstre flytter venstre operands venstre værdi med den givne værdi i den anden operand. 'Res' gemmer output fra skiftoperatøren. Efter dette kalder vi Console.Write()-metoden for at udskrive teksten 'The left shift is' og den resulterende værdi, der er gemt i 'res' på terminalen.
Eksempel 2:
Lad os bruge venstre shift-operator på de usignerede heltalværdier og se, hvordan de producerer output.
bruger System;
klasse Program_2
{
statisk tomrum Main ( ) {
uint Val_0 = 4435 ;
int Val_1 = 64 ;
uint resultat = Val_0 << Val_1;
Konsol.Skriv ( 'Venstre skift er' ) ;
Konsol.Skriv ( resultat ) ;
}
}
Her anvender vi den venstre skiftoperator på den usignerede heltalstypeværdi. En ting du skal passe på er, at den anden operand skal være en heltalstypeværdi, fordi compileren kun tager en heltalsværdi for at skifte.
Efter at have kaldt den statiske void Main()-funktion, erklærer vi to variable - hvoraf den ene er en heltalsværdi 'Val_0' uden fortegn, og den anden er en heltalsværdi 'Val_1'. Derefter definerer vi en anden heltalsvariabel uden fortegn, som er 'resultat' for at beholde den resulterende værdi efter at have flyttet det heltal uden fortegn til venstre. Vi kan ikke gemme resultatet i en heltalstypevariabel, fordi efter venstreforskydning er resultatet en værdi uden fortegn. 'Val_0 << Val_1'-sætningen til venstre flytter den venstre operand, der er en heltalsværdi uden fortegn. Det producerer en heltalsværdi uden fortegn. Til sidst skal du vise resultatet på outputskærmen med teksten 'The left shift is' ved hjælp af Console.Write() metoden:
Eksempel 3:
I dette tilfælde vil vi tale om de forskellige metoder til at bruge Bitwise left shift-operatoren (<<) på lange heltalsværdier.
bruger System;klasse Program_3
{
statisk tomrum Main ( ) {
langt tal_0 = Fire, fem ;
langt nummer_1 = 5 ;
Konsol.Skriv ( 'Venstre skift af lang er' ) ;
Console.WriteLine ( nummer_0 << 3 ) ;
Konsol.Skriv ( 'Venstre skift af lang er' ) ;
Konsol.Skriv ( nummer_0 << Convert.ToInt16 ( nummer 1 ) ) ;
}
}
Initialiseringen af to lange heltalsvariabler, 'tal_0' og 'tal_1', udføres i den første sætning. Aktiver Console.Write()-funktionen for at repræsentere beskeden 'The left shift of long is' og resultatet på terminalen. Her anvender vi den venstre skiftoperator (<<) på en sådan måde, at vi placerer den første operand som den første variabel og den anden operand som en heltalsværdi. Kompileren til venstre flytter den første operand, som er 'nummer_0' med 3 og viser resultatet. I den næste sætning skal du udskrive endnu en meddelelse på skærmen ved at bruge metoden Console.Write(). Her bruger vi den første variabel, 'number_0', som den første operand og den anden variabel, 'number_1', som den anden operand. Den anden operand skal være en heltalstypeværdi. Vi typecaster den anden variabel 'number_1' til heltalstypen ved hjælp af Convert.ToInt16()-funktionen. Vis derefter resultatet på konsollen:
Eksempel 4:
Denne kode viser, hvordan vi kan tildele værdierne til et heltal efter at have udført det venstre skift på den usignerede lange operator.
bruger System;klasse Program_4
{
statisk tomrum Main ( ) {
hovednummer_0 = 445 ;
Konsol.Skriv ( 'Venstre skift af ulong er' ) ;
Console.WriteLine ( nummer_0 << 8 ) ;
Konsol.Skriv ( 'Venstre skift af ulong er' ) ;
Console.WriteLine ( nummer_0 << 16 ) ;
Konsol.Skriv ( 'Venstre skift af ulong er' ) ;
Console.WriteLine ( nummer_0 << 32 ) ;
}
}
Først skal du erklære en lang heltalsvariabel uden fortegn, som er 'tal_0'. Vis derefter teksten 'The left shift of ulong is' på terminalen ved at kalde Console.Write() metoden. Vi finder venstreforskydningen af 'number_0' med en heltalværdi på 8, og vi behøver ikke gemme resultatet nogen steder. Funktionen Console.WriteLine() udskriver resultatet på konsollen. Gentag denne proces to gange og skift værdierne for den anden operand. Ved at gøre dette kan vi finde venstreforskydningen af en lang heltalstypeværdi uden fortegn. Men hvis vi vil gemme den resulterende værdi i en variabel, bør vi huske på, at resultatet er af samme type som den første operand. Den eneste forskel mellem Console.Write() og Console.WriteLine() er, at den anden funktion udskriver resultatet og sender markøren til næste linje, mens den første funktion kun udskriver resultatet og markøren blinker på samme linje selv efter visning af output.
Konklusion
Vi udforskede Bitwise-operatorerne i C#, deres typer og funktionaliteter. Venstreforskydningsoperatoren (<<) anvendes til at flytte antallet eller værdien med det bestemte antal bits til venstre. Bitwise-operatørerne forbedrer effektiviteten af koden, og det belaster ikke systemet, da de er lette operatører. Vores CPU (computerbehandlingsenhed) fungerer på Bitwise-niveauet, når vi udfører aritmetiske operationer. I en nøddeskal er Bitwise-operatorerne vigtige i programmering, og C# understøtter alle Bitwise-operatorer, hvor venstreskiftsoperatoren (<<) er en af dem.