Ons gespreksonderwerp gaat over de ploegendienst. De bitsgewijze linker shift-operator (<<) zal in detail worden uitgelegd. De shift-operator verschuift, zoals de naam al doet vermoeden, het bit van de opgegeven positie naar links of naar rechts. De waarde wordt met het opgegeven aantal bits naar links verplaatst bij gebruik van de bitsgewijze linker shift-operator (<<). De linkse shift-operatoren nemen de invoer alleen in int (geheel getal), uint (niet-ondertekend geheel getal), long (lang geheel getal) en ulong (niet-ondertekend lang geheel getal) in. Wanneer de linker operand tot een ander type behoort, wordt deze geconverteerd naar het integer type. Het gegevenstype van de resulterende waarde behoudt een limiet van 32 bits; de uitvoer kan niet groter zijn dan dat. Bitsgewijze operators maken de code efficiënter en sneller. Bovendien bieden ze meer nauwkeurigheid en precisie.
Syntaxis:
Operand_1 << Operand_2
De eerste 'Operand_1' is de waarde die wordt verschoven van links naar het aantal shifts dat de 'Operand_2' bevat. Het symbool << naar links verschuift de “Operand_1”.
Voorbeeld 1:
De bitsgewijze linker shift-operator (<<) wordt toegepast op de gehele waarden in dit programma.
systeem gebruiken;
klasse Programma_1
{
statische leegte Main ( ) {
int Waarde_0 = 3. 4 ;
int Waarde_1 = 65 ;
int res = Waarde_0 << Waarde_1;
Console.Schrijven ( 'De linker shift is ' ) ;
Console.Schrijven ( res ) ;
}
}
De eerste instructie bevat de declaratie en initialisatie van twee integer-type variabelen. De eerste variabele is 'Value_0' en de tweede variabele is 'Value_1'. De waarden die erin zijn opgeslagen zijn '34' en '65'. We verlieten shift de waarde 34 met behulp van de linker shift-operator (<<). Vervolgens declareren we een andere variabele met een integer datatype om het resultaat op te slaan. Hier gebruiken we de linker shift-operator (<<) als Value_0 << Value_1. Deze operator links verschuift de linkerwaarde van de linker operand met de gegeven waarde in de tweede operand. De 'res' slaat de uitvoer van de shift-operator op. Hierna roepen we de methode Console.Write() aan om de tekst 'The left shift is' af te drukken en de resulterende waarde die is opgeslagen in 'res' op de terminal.
Voorbeeld 2:
Laten we de linker shift-operator gebruiken op de niet-ondertekende integer-waarden en kijken hoe ze de uitvoer produceren.
systeem gebruiken;
klasse Programma_2
{
statische leegte Main ( ) {
uint Waarde_0 = 4435 ;
int Val_1 = 64 ;
uint resultaat = Val_0 << Val_1;
Console.Schrijven ( 'De linker shift is ' ) ;
Console.Schrijven ( resultaat ) ;
}
}
Hier passen we de linker shift-operator toe op de waarde van het niet-ondertekende gehele getal. Een ding waar u op moet letten, is dat de tweede operand een waarde van het type integer moet zijn, omdat de compiler alleen een integerwaarde nodig heeft om te verschuiven.
Nadat we de functie static void Main() hebben aangeroepen, declareren we twee variabelen, waarvan er één een integerwaarde zonder teken is 'Val_0' en de andere een integerwaarde 'Val_1'. Vervolgens definiëren we een andere niet-ondertekende integer-variabele die 'resultaat' is om de resulterende waarde te behouden nadat het unsigned integer naar links is verschoven. We kunnen het resultaat niet opslaan in een variabele van het type geheel getal, omdat het resultaat na links verschuiven een waarde zonder teken is. De instructie 'Val_0 << Val_1' naar links verschuift de linker operand die een geheel getal zonder teken is. Het produceert een unsigned integer-waarde. Toon uiteindelijk het resultaat op het uitvoerscherm met de tekst 'The left shift is' met behulp van de Console.Write() methode:
Voorbeeld 3:
In dit geval zullen we het hebben over de verschillende methoden voor het gebruik van de bitsgewijze linker shift-operator (<<) op lange integerwaarden.
systeem gebruiken;klasse Programma_3
{
statische leegte Main ( ) {
lang getal_0 = Vier vijf ;
lang getal_1 = 5 ;
Console.Schrijven ( 'De linker shift van lang is ' ) ;
Console.WriteLine ( nummer_0 << 3 ) ;
Console.Schrijven ( 'De linker shift van lang is ' ) ;
Console.Schrijven ( nummer_0 << Converteren naarInt16 ( nummer 1 ) ) ;
}
}
De initialisatie van twee lange integer type variabelen, 'number_0' en 'number_1', wordt gedaan in de eerste instructie. Roep de functie Console.Write() aan om het bericht 'The left shift of long is' en het resultaat op de terminal weer te geven. Hier passen we de linker shift-operator (<<) zo toe dat we de eerste operand als de eerste variabele plaatsen en de tweede operand als een geheel getal. De compiler naar links verschuift de eerste operand die 'number_0' is met 3 en geeft het resultaat weer. Druk in de volgende instructie nog een bericht op het scherm af met behulp van de methode Console.Write(). Hier gebruiken we de eerste variabele, 'nummer_0', als de eerste operand en de tweede variabele, 'nummer_1', als de tweede operand. De tweede operand moet een waarde van het type integer zijn. We typecasten de tweede variabele 'number_1' naar het type integer met behulp van de functie Convert.ToInt16(). Geef vervolgens het resultaat weer op de console:
Voorbeeld 4:
Deze code laat zien hoe we de waarden aan een geheel getal kunnen toewijzen na het uitvoeren van de linkerverschuiving op de niet-ondertekende lange operator.
systeem gebruiken;klasse Program_4
{
statische leegte Main ( ) {
kop nummer_0 = 445 ;
Console.Schrijven ( 'De linker verschuiving van ulong is ' ) ;
Console.WriteLine ( nummer_0 << 8 ) ;
Console.Schrijven ( 'De linker verschuiving van ulong is ' ) ;
Console.WriteLine ( nummer_0 << 16 ) ;
Console.Schrijven ( 'De linker verschuiving van ulong is ' ) ;
Console.WriteLine ( nummer_0 << 32 ) ;
}
}
Declareer eerst een niet-ondertekende variabele van het type lang geheel getal die 'number_0' is. Toon vervolgens de tekst 'The left shift of ulong is' op de terminal door de methode Console.Write() aan te roepen. We vinden de linkerverschuiving van het 'getal_0' met een geheel getal van 8 en we hoeven het resultaat nergens op te slaan. De functie Console.WriteLine() drukt het resultaat af op de console. Herhaal dit proces twee keer en wijzig de waarden van de tweede operand. Door dit te doen, kunnen we de verschuiving naar links vinden van een lange waarde van het type geheel getal zonder teken. Maar als we de resulterende waarde in een variabele willen opslaan, moeten we er rekening mee houden dat het resultaat van hetzelfde type is als de eerste operand. Het enige verschil tussen Console.Write() en Console.WriteLine() is dat de tweede functie de uitkomst afdrukt en de cursor naar de volgende regel stuurt, terwijl de eerste functie alleen de uitkomst afdrukt en de cursor op dezelfde regel knippert, zelfs daarna weergave van de uitvoer.
Conclusie
We hebben de Bitwise-operators in C#, hun typen en functionaliteiten onderzocht. De linker shift (<<) operator wordt toegepast om het aantal of de waarde met het bepaalde aantal bits naar links te verschuiven. De Bitwise-operators verbeteren de efficiëntie van de code en belasten het systeem niet omdat het lichtgewicht operators zijn. Onze CPU (computerverwerkingseenheid) werkt op Bitwise-niveau wanneer we rekenkundige bewerkingen uitvoeren. Kortom, de Bitwise-operators zijn belangrijk bij het programmeren en C# ondersteunt alle Bitwise-operators waarin de linker shift-operator (<<) er een van is.