Наша тема разговора је о оператерима смене. Оператор померања у лево (<<) биће детаљно објашњен. Оператор померања, као што име каже, помера бит са одређене позиције улево или удесно. Вредност се помера улево за одређени број битова док се користи оператор померања улево у битовима (<<). Оператори левог померања уносе унос само у инт (цео број), уинт (цео број без предзнака), лонг (дугачки цео број) и улонг (неозначени дуг цео број). Када леви операнд припада другом типу, он се конвертује у целобројни тип. Тип података резултујуће вредности задржава ограничење од 32 бита; излаз не може бити већи од тога. Битови оператори чине код ефикаснијим и бржим. Штавише, они нуде већу тачност и прецизност.
Синтакса:
Операнд_1 << Операнд_2
Први „Операнд_1“ је вредност која се помера са леве стране на број померања који „Операнд_2“ садржи. Симбол << лево помера 'Операнд_1'.
Пример 1:
Оператор померања битова улево (<<) се примењује на целобројне вредности у овом програму.
коришћење система;
разред Програм_1
{
статичка празнина Главна ( ) {
инт Вредност_0 = 3. 4 ;
инт Вредност_1 = 65 ;
инт рес = Вредност_0 << Валуе_1;
Цонсоле.Врите ( „Лева смена је “ ) ;
Цонсоле.Врите ( рес ) ;
}
}
Прва изјава садржи декларацију и иницијализацију две променљиве целобројног типа. Прва променљива је „Вредност_0“, а друга променљива је „Вредност_1“. Вредности које се чувају у њима су „34“ и „65“. Померамо вредност 34 улево користећи оператор померања лево (<<). Затим декларишемо другу променљиву која има целобројни тип података да бисмо сачували резултат. Овде користимо леви оператор померања (<<) као Вредност_0 << Вредност_1. Овај оператор улево помера леву вредност левог операнда за дату вредност у другом операнду. „рес“ чува излаз оператора смене. Након тога, позивамо методу Цонсоле.Врите() да одштампамо текст „Леви помак је“ и резултујућу вредност која се чува у „рес“ на терминалу.
Пример 2:
Хајде да користимо оператор померања улево на вредностима целих бројева без предзнака и видимо како оне производе излаз.
коришћење система;
разред Програм_2
{
статичка празнина Главна ( ) {
уинт Вал_0 = 4435 ;
инт Вал_1 = 64 ;
уинт резултат = Вал_0 << Вал_1;
Цонсоле.Врите ( 'Лева смена је' ) ;
Цонсоле.Врите ( резултат ) ;
}
}
Овде примењујемо леви оператор померања на вредност типа целих бројева без предзнака. Једна ствар о којој морате водити рачуна је да други операнд мора бити вредност целобројног типа јер компајлер узима само целобројну вредност за померање.
Након позива функције статичке воид Маин(), декларишемо две променљиве – од којих је једна неозначена целобројна вредност „Вал_0“, а друга целобројна вредност „Вал_1“. Затим дефинишемо другу неозначену целобројну променљиву која је „резултат“ да задржи резултујућу вредност након левог померања неозначеног целог броја. Не можемо да сачувамо резултат у променљивој целобројног типа јер је после померања улево резултат непотписана вредност. Наредба „Вал_0 << Вал_1” налево помера леви операнд који је неозначена целобројна вредност. Он производи неозначену целобројну вредност. На крају, прикажите резултат на излазном екрану са текстом „Леви помак је“ користећи Цонсоле.Врите() метод:
Пример 3:
У овом случају, говорићемо о различитим методама коришћења оператора померања улево по биту (<<) на дугим целобројним вредностима.
коришћење система;разред Програм_3
{
статичка празнина Главна ( ) {
дугачак број_0 = Четири, пет ;
дугачак број_1 = 5 ;
Цонсоле.Врите ( 'Лева смена дуга је' ) ;
Цонсоле.ВритеЛине ( број_0 << 3 ) ;
Цонсоле.Врите ( 'Лева смена дуга је' ) ;
Цонсоле.Врите ( број_0 << Цонверт.ТоИнт16 ( број 1 ) ) ;
}
}
Иницијализација две променљиве дугог целобројног типа, „број_0“ и „број_1“, врши се у првој изјави. Позовите функцију Цонсоле.Врите() да бисте представили поруку „Лево померање дугог је“ и резултат на терминалу. Овде примењујемо леви оператор померања (<<) на начин да први операнд поставимо као прву променљиву, а други операнд као целобројну вредност. Компајлер помера улево први операнд који је „број_0“ за 3 и приказује резултат. У следећој изјави, одштампајте другу поруку на екрану коришћењем методе Цонсоле.Врите(). Овде користимо прву променљиву, „нумбер_0“, као први операнд и другу променљиву, „нумбер_1“, као други операнд. Други операнд мора бити вредност целобројног типа. Другу променљиву „нумбер_1“ пребацујемо на целобројни тип помоћу функције Цонверт.ТоИнт16(). Затим прикажите резултат на конзоли:
Пример 4:
Овај код показује како можемо да доделимо вредности целом броју након што извршимо леви помак на непотписаном лонг оператору.
коришћење система;разред Програм_4
{
статичка празнина Главна ( ) {
број главе_0 = 445 ;
Цонсоле.Врите ( 'Лева помера од улонга је' ) ;
Цонсоле.ВритеЛине ( број_0 << 8 ) ;
Цонсоле.Врите ( 'Лева помера од улонга је' ) ;
Цонсоле.ВритеЛине ( број_0 << 16 ) ;
Цонсоле.Врите ( 'Лева помера од улонга је' ) ;
Цонсоле.ВритеЛине ( број_0 << 32 ) ;
}
}
Прво, декларишете једну непотписану променљиву дугог целобројног типа која је „број_0“. Затим покажите текст „Лево померање улонга је“ на терминалу позивањем методе Цонсоле.Врите(). Пронаћи ћемо лево померање „броја_0“ за целобројну вредност од 8 и не морамо нигде да чувамо резултат. Функција Цонсоле.ВритеЛине() штампа резултат на конзоли. Поновите овај процес два пута и промените вредности другог операнда. Радећи ово, можемо пронаћи леви помак вредности дугог неозначеног целобројног типа. Али ако желимо да резултујућу вредност сачувамо у променљивој, треба да имамо у виду да је резултат истог типа као и први операнд. Једина разлика између Цонсоле.Врите() и Цонсоле.ВритеЛине() је у томе што друга функција штампа резултат и шаље курсор у следећи ред, док прва функција само штампа резултат, а курсор трепери у истој линији чак и након приказивање излаза.
Закључак
Истражили смо Битвисе операторе у Ц#, њихове типове и функционалности. Оператор померања улево (<<) се примењује за померање броја или вредности за одређени број битова улево. Битвисе оператори побољшавају ефикасност кода и не оптерећују систем пошто су они лаки оператори. Наш ЦПУ (компјутерска процесорска јединица) ради на нивоу битова кад год изводимо било коју аритметичку операцију. Укратко, Битвисе оператори су важни у програмирању и Ц# подржава све Битвисе операторе у којима је оператор померања улево (<<) један од њих.