C# Оператор побитового сдвига влево (<<)

C Operator Pobitovogo Sdviga Vlevo

В программировании на C# мы можем использовать побитовые операторы для выполнения операций на уровне битов. Вычисление битового уровня выполняется в ЦП, когда мы выполняем арифметические операции, такие как сложение, вычитание, умножение или деление. Мы также можем выполнять побитовые операции в программировании на C#, и этот процесс прост. Побитовые операторы выполняют операцию над заданным значением. Также указывается количество битов для сдвига. В языке C# есть шесть побитовых операторов, два из них — операторы сдвига.

Наша тема для обсуждения — операторы сдвига. Оператор побитового сдвига влево (<<) будет объяснен подробно. Оператор сдвига, как следует из названия, сдвигает бит из указанной позиции влево или вправо. Значение перемещается влево на указанное количество бит при использовании оператора побитового сдвига влево (<<). Операторы сдвига влево принимают входные данные только в int (целое число), uint (целое без знака), long (длинное целое) и ulong (длинное целое без знака). Когда левый операнд принадлежит к другому типу, он преобразуется в целочисленный тип. Тип данных результирующего значения сохраняет ограничение в 32 бита; выход не может быть больше этого. Побитовые операторы делают код эффективным и быстрым. Кроме того, они обеспечивают большую точность и точность.

Синтаксис:

Операнд_1 << Операнд_2







Первый «Операнд_1» — это значение, сдвинутое слева на число сдвигов, которое содержит «Операнд_2». Символ << влево сдвигает «Операнд_1».



Пример 1:

В этой программе к целочисленным значениям применяется оператор побитового сдвига влево (<<).



с помощью системы;

класс Program_1
{
статическая пустота Главная ( ) {
целое значение_0 = 3. 4 ;
целое значение_1 = 65 ;
инт разрешение = Значение_0 << Значение_1;
Консоль.Запись ( 'Сдвиг влево  ' ) ;
Консоль.Запись ( разрешение ) ;
}
}

Первый оператор содержит объявление и инициализацию двух переменных целочисленного типа. Первая переменная — «Value_0», а вторая переменная — «Value_1». В них хранятся значения «34» и «65». Мы сдвинули влево значение 34, используя оператор сдвига влево (<<). Затем мы объявляем другую переменную с целочисленным типом данных для сохранения результата. Здесь мы используем оператор сдвига влево (<<) как Value_0 << Value_1. Этот оператор влево сдвигает левое значение левого операнда на заданное значение во втором операнде. «res» хранит вывод оператора сдвига. После этого мы вызываем метод Console.Write() для вывода текста «Сдвиг влево есть» и результирующее значение, которое сохраняется в «res» на терминале.





Пример 2:

Давайте используем оператор сдвига влево для целочисленных значений без знака и посмотрим, как они производят вывод.



с помощью системы;

класс Program_2
{
статическая пустота Главная ( ) {
uинт Val_0 = 4435 ;
интервал  Val_1 = 64 ;
не результат = Вал_0 << Вал_1;
Консоль.Запись ( 'Левая смена' ) ;
Консоль.Запись ( результат ) ;
}
}

Здесь мы применяем оператор сдвига влево к значению целочисленного типа без знака. Одна вещь, о которой вы должны позаботиться, это то, что второй операнд должен быть значением целочисленного типа, потому что компилятор принимает только целочисленное значение для сдвига.

После вызова статической функции void Main() мы объявляем две переменные, одна из которых представляет собой целочисленное значение без знака «Val_0», а другая — целочисленное значение «Val_1». Затем мы определяем другую целочисленную переменную без знака, которая является «результатом», чтобы сохранить результирующее значение после сдвига влево целого числа без знака. Мы не можем сохранить результат в переменной целочисленного типа, потому что после сдвига влево результатом будет беззнаковое значение. Оператор «Val_0 << Val_1» сдвигает влево левый операнд, который является целым числом без знака. Он производит беззнаковое целое значение. В конце покажите результат на экране вывода с текстом «The left shift is» с помощью метода Console.Write():

Пример 3:

В этом случае мы поговорим о различных методах использования оператора побитового сдвига влево (<<) для длинных целых значений.

с помощью системы;

класс Program_3
{
статическая пустота Главная ( ) {
длинное число_0 = Четыре пять ;
длинное число_1 = 5 ;

Консоль.Запись ( 'Левый сдвиг долгого' ) ;
Console.WriteLine ( номер_0 << 3 ) ;
Консоль.Запись ( 'Левый сдвиг долгого' ) ;
Консоль.Запись ( номер_0 << Convert.ToInt16 ( номер 1 ) ) ;
}
}

Инициализация двух переменных типа long integer, «number_0» и «number_1», выполняется в первом операторе. Вызовите функцию Console.Write(), чтобы представить сообщение «Сдвиг влево длинного есть» и результат на терминале. Здесь мы применяем оператор сдвига влево (<<) таким образом, что мы помещаем первый операнд как первую переменную, а второй операнд как целочисленное значение. Компилятор сдвигает влево первый операнд «number_0» на 3 и отображает результат. В следующем операторе выведите на экран другое сообщение, используя метод Console.Write(). Здесь мы используем первую переменную «число_0» в качестве первого операнда и вторую переменную «число_1» в качестве второго операнда. Второй операнд должен быть значением целочисленного типа. Мы приводим вторую переменную «number_1» к целочисленному типу, используя функцию Convert.ToInt16(). Затем отобразите результат на консоли:

Пример 4:

Этот код показывает, как мы можем присвоить значения целому числу после выполнения сдвига влево над оператором unsigned long.

с помощью системы;

класс Program_4
{
статическая пустота Главная ( ) {
номер головы_0 = 445 ;

Консоль.Запись ( 'Левый сдвиг улонга' ) ;
Console.WriteLine ( номер_0 << 8 ) ;
Консоль.Запись ( 'Левый сдвиг улонга' ) ;
Console.WriteLine ( номер_0 << 16 ) ;
Консоль.Запись ( 'Левый сдвиг улонга' ) ;
Console.WriteLine ( номер_0 << 32 ) ;

}
}

Во-первых, объявите одну переменную длинного целочисленного типа без знака, которая имеет значение «number_0». Затем покажите на терминале текст «Сдвиг влево ulong is», вызвав метод Console.Write(). Мы найдем сдвиг влево «числа_0» на целочисленное значение 8 и нам не нужно никуда сохранять результат. Функция Console.WriteLine() выводит результат на консоль. Повторите этот процесс дважды и измените значения второго операнда. Делая это, мы можем найти сдвиг влево длинного целочисленного значения без знака. Но если мы хотим сохранить результирующее значение в переменной, мы должны помнить, что результат того же типа, что и первый операнд. Единственная разница между Console.Write() и Console.WriteLine() заключается в том, что вторая функция выводит результат и отправляет курсор на следующую строку, в то время как первая функция выводит только результат, а курсор мигает на той же строке даже после отображение вывода.

Вывод

Мы изучили побитовые операторы в C#, их типы и функциональные возможности. Оператор сдвига влево (<<) применяется для сдвига числа или значения на определенное количество битов влево. Побитовые операторы повышают эффективность кода и не нагружают систему, поскольку они являются облегченными операторами. Наш ЦП (компьютерный процессор) работает на побитовом уровне всякий раз, когда мы выполняем какие-либо арифметические операции. Короче говоря, побитовые операторы важны в программировании, и C# поддерживает все побитовые операторы, в которых оператор сдвига влево (<<) является одним из них.