English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
В этом руководстве вы узнаете о различных битовых операциях в Swift. Они используются для вычислений на уровне бит в выражениях.
Биты используются для представления двоичных чисел. Двоичное число может иметь два возможных значения 0 или 1. В качестве начинающего программиста вам не нужно работать на уровне бит.
Использование исходных данных типов, таких как: integer, float, boolean, string и т.д., достаточно для обработки низкоуровневой программирования. При обработке низкоуровневого программирования может потребоваться работа на уровне бит.
КромеОсновные операцииКроме того, Swift предоставляет набор богатых операторов для работы с битами. Эти операторы подобны логическим операторам, но они обрабатывают двоичное представление данных.
Битовые операторы используются для изменения отдельных бит операнда. Операнд - это переменная или константа, в которой выполняется операция.
Ниже приведены все битовые операторы, доступные в Swift:
Он представлен символом ~ и может применяться к одному операнду. Это изменяет все биты, т.е. меняет 1 на 0, а 0 на 1.
Если x - это переменная или константа, сохраняющая двоичное значение (т.е. 0 или 1), то битовая несовместимость переменной x может быть представлена в таблице ниже:
| x | ~x |
|---|---|
| 0 | 1 |
| 1 | 0 |
let initalNumber: UInt8 = 1 let invertedNumber = ~initalNumber print(invertedNumber)
Когда вы запустите вышеуказанную программу, вывод будет:
254
В上面的 программе переменная let initalNumber:UInt8 = 1 имеет тип Unsigned int, размером в 8 бит. Таким образом, десятичное значение 1 можно представить в двоичном формате как 00000001.
Оператор несовместимости изменяет все биты переменной или константы, бит 0 изменяется на 1, а 1 на 0. Таким образом, обратное число содержит биты 11111110. Преобразовав его в десятичное значение, оно равно 254. Таким образом, команда print(invertedNumber) выводит на экран 254.
Битовые операции также可以直接 выполняться в битах, как показано ниже:
let initialBits: UInt8 = 0b11111111 let invertedBits = ~initialBits print(invertedBits)
Когда вы запустите вышеуказанную программу, вывод будет:
0
Пакет initialBits содержит двоичное значение 11111111, что соответствует десятичному 255. Чтобы представить цифру в двоичном формате, мы используем префикс 0b в тексте. Если префикс 0b отсутствует, он будет рассматривать это как обычное целое число, и может возникнуть ошибка переполнения (UInt8 может хранить только числа от 0 до 255).
由于我们使用了按位非运算符，因此将所有1都更改为0。因此，常量reverseBits包含00000000，这等效于UInt8中的0。
let initalNumber: Int = 1 let invertedNumber = ~initalNumber print(invertedNumber)
Когда вы запустите вышеуказанную программу, вывод будет:
-2
在上面的程序中，十进制的1可以二进制表示为00000001。 按位非运算符将更改变量或常量的所有位，将位0更改为1，将1更改为0。因此，反转数字包含位11111110。这应在屏幕中输出254。 而是返回-2。 奇怪吧？ 让我们在下面看看这是如何发生的。
let initalNumber: Int = 1是一个有符号 Int，可以同时包含正整数和负整数。这就是为什么当我们对有符号整数应用非运算符时，返回的二进制数也可能表示负数。
编译器如何将 -2 解释 为11111110 二进制形式？
编译器使用二进制补码表示整数。 要获得整数的二进制补码负号，您应该首先以二进制形式写出数字，然后将数字取反，然后在结果中加一个。
求-2的补码的步骤：
以二进制形式写2： 00000010
反转数字。0变为1，而1变为0：11111101
加1： 11111110
这就是编译器将二进制数1111110解释为十进制中的-2的方式。 但是，编译器有一个我们没有注意到的小问题。 它还推断 invertedNumber 的类型为Int8类型。
为了理解这一点，让我们看下面的实例：
print(Int8(bitPattern: 0b11111110)) print(0b11111110)
Когда вы запустите вышеуказанную программу, вывод будет:
-2 254
在上面的示例中，编译器仅对带符号的8位整数将二进制数处理为十进制的-2。因此，语句print(Int8(bitPattern: 0b11111110))在屏幕上输出-2。
但是对于大小为32/64位并且可以容纳较大值的普通整数类型，它将值解释为254。因此，语句在屏幕上print(0b11111110)输出254
Это обозначается символом & и может применяться к двум операндам. Оператор AND сравнивает два бита, и если оба бита равны 1, то результат равен 1, в противном случае 0.
Если x и y являются переменными/константами, сохраняющими двоичное значение (то есть 0 или 1), то битовое И x и y можно представить в таблице ниже:
| x | y | x & y |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 1 | 1 |
| 1 | 0 | 0 |
let xBits = 0b10000011
let yBits = 0b11111111
let result = xBits & yBits
print("Бинарное:", String(result, radix: 2))
print(result)Когда вы запустите вышеуказанную программу, вывод будет:
Бинарное: 10000011 131
В上面的 программе команда let result = xBits & yBits комбинирует биты двух операндов xBits и yBits. Если оба бита равны 1, то результат равен 1, в противном случае 0.
Initial value for String(value, radix:) используется для представления чисел в различных системах счисления. Если мы предоставляем базовое значение 2, оно преобразует число в двоичную систему счисления. Таким же образом, мы можем использовать 16 для шестнадцатеричной системы счисления и 10 для десятичной.
Эта команда print("Binary:", String(result, radix: 2)) выводит на экран Бинарное：10000011. 10000011 равно 131 в десятичной системе, команда print(result) выводит в консоли 131.
Это обозначается символом | и может применяться к двум операндам. Если один или несколько входов оператора битовое И равны 1, то сравниваются два бита и результат равен 1, в противном случае 0.
Если x и y являются переменными/константами, сохраняющими двоичное значение (то есть 0 или 1), то битовое И x и y можно представить в таблице ниже:
| x | y | x | y |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 1 |
| 1 | 0 | 1 |
let xBits = 0b10000011
let yBits = 0b11111111
let result = xBits | yBits
print("Binary:", String(result, radix: 2))
print(result)Когда вы запустите вышеуказанную программу, вывод будет:
Бинарное: 11111111 255
В上面的 программе команда let result = xBits | yBits комбинирует биты двух констант xBits и yBits. Если любой бит равен 1, то результат равен 1, в противном случае 0.
Эта команда print("Бинарное:", String(result, radix: 2)) выводит на экран:Бинарное: 11111111. Так как 11111111 эквивалентен 255 в десятичной системе, поэтому команда print(result) выводит на экран:255
Это обозначается символом ^ и может применяться к двум операндам. Оператор битовое ИЛИ сравнивает два бита, и если только один из них равен 1, то результат равен 1, в противном случае 0.
Если x и y являются переменными/константами, сохраняющими двоичное значение, то есть 0 или 1, битовое ИЛИ x и y можно представить в таблице ниже:
| x | y | x ^ y |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 0 |
| 1 | 0 | 1 |
let xBits = 0b10000011
let yBits = 0b11111111
let result = xBits ^ yBits
print("Binary:", String(result, radix: 2))
print(result)Когда вы запустите вышеуказанную программу, вывод будет:
Binary: 1111100 124
В предыдущем примере команда let result = xBits ^ yBits объединяет биты двух констант xBits и yBits. Если один из бит точно равен 1, то возвращается 1, в противном случае 0.
Эта команда print("Binary:", String(result, radix: 2)) выводит на экранBinary: 1111100(эквивалентно 01111100). Поскольку 1111100 эквивалентен 124 в десятичной системе, команда print(result) выводит на экран124
Этот оператор используется для смещения всех бит числа на определенное количество позиций влево или вправо и может применяться к одному операнду. Он представлен << или >>.
Смещение операторов有两种:
表示为 <<
Это вызывает левое смещение битов, которое указывается числом после <<
Освободившиеся позиции смещения заполнены нулями.
Смещение битов левого типа удваивает значение числа
let someBits:UInt8 = 0b11000100 print(someBits << 1)
Когда вы запустите вышеуказанную программу, вывод будет:
136
В предыдущем примере мы использовали оператор левого смещения. Использование <<1 означает смещение битов на один бит влево. Эти числа смещаются на один бит влево, и ноль добавляется справа.
Вы также можете видеть, что цифры, смещенные с левой "стороны", теряются. Они не возвращаются обратно справа. Смещение на один бит влево удаляет 1 из двоичного числа, добавляет 0 справа для заполнения смещенного значения, а другие биты смещаются на один бит влево.
Возвращает 10001000, что эквивалентно 136 в UInt8. Поэтому строка print(someBits << 1) выводит на экран 136.
表示为 >>
Это вызывает правое смещение битов, за которым следует >>
Для беззнаковых чисел освободившиеся битовые позиции заполнены нулями.
Для знаковых чисел (также может быть отрицательным), бит знака используется для заполнения освободившихся битовых позиций. Иными словами, если число положительное, используется 0; если отрицательное, используется 1.
Перемещение на один бит вправо удваивает его значение.
let someBits: UInt8 = 4 print(someBits >> 1)
Когда вы запустите вышеуказанную программу, вывод будет:
2
В вышеуказанной программе мы используем правое смещение для беззнаковых целых чисел. >>1 означает смещение битов вправо на один. Пустые места, оставленные смещением, для беззнаковых целых чисел всегда заполнены нулями.
Потому что, 4 в двоичном представлении равно 00000100. При правом смещении на один бит, вернёмся к 00000010, что равно 2 в UInt8. Поэтому, предложение print(someBits>>1) выводит на экран 2.
let someBits: Int = -4 print(someBits >> 1)
Когда вы запустите вышеуказанную программу, вывод будет:
-2
В上面的 программе мы используем правое смещение для беззнаковых целых чисел. В отличии от положительных чисел, >> для отрицательных чисел означает заполнение пустых мест 1, а не 0.
Потому что, -4 в двоичном представлении равно 11111100. Поставьте 1 в пустое место при правом смещении на один бит, вернёмся к 11111110, что равно -2 типа Int8. Поэтому, предложение print(someBits>>1) выводит на экран -2.