Swift 按位和移位运算符

Dans ce tutoriel, vous allez apprendre différentes opérations de bits en Swift. Elles sont utilisées pour des calculs de niveau de bits dans les expressions.

Les bits sont utilisés pour représenter des nombres binaires. Un nombre binaire peut avoir deux valeurs possibles, 0 ou1. En tant que programmeur débutant, vous n'avez pas besoin d'utiliser des opérations à l'échelle des bits.

L'utilisation de types de données en brut, tels que integer, float, boolean, string, etc., est suffisante. Lorsque vous travaillez à un niveau de programmation basique, vous pourriez devoir travailler à l'échelle des bits.

En plus deOpérations de baseDe plus, Swift fournit un ensemble riche d'opérateurs pour manipuler les bits. Ces opérateurs sont similaires aux opérateurs logiques, mais ils traitent la représentation binaire des données (bits).

Les opérateurs de manipulation de bits sont des opérateurs utilisés pour modifier les bits des opérandes. Les opérandes sont les variables ou les constantes dans lesquelles l'opération est effectuée.

Voici une liste de tous les opérateurs de manipulation de bits disponibles dans Swift :

1. Opérateur de négation binaire

Il est représenté par le tilde ~ et peut être appliqué à un opérande unique. Cela inversera tous les bits. C'est-à-dire que1Changez-le en 0, changez 0 en1。

Si x est un sauvegarde de valeur binaire (c'est-à-dire 0 ou1） de la variable/Si c'est une constante, l'opération de négation binaire de la variable x peut être représentée dans le tableau suivant :

示例1：l'opérateur de non binaire pour les entiers unsigned

let　initalNumber:UInt8　=　1　
let　invertedNumber　=　~initalNumber　
print(invertedNumber)

当您运行上述程序时，输出将是：

254

dans le programme suivant, la phrase let initalNumber:UInt8 = 1 de type Unsigned int, de taille8bits. Par conséquent, le nombre décimal1qui peut être représenté comme 00000001binaire.

l'opérateur de non binaire change tous les bits d'un variable ou d'une constante, changeant le bit 0 en1et1passer à 0. Par conséquent, l'inversion du nombre contient des bits11111110。 Après sa conversion en décimal, elle représente254。 Par conséquent, la phrase print（invertedNumber ）est affichée à l'écran254。

on peut également exécuter des opérations binaire directement dans les bits, comme montré ci-dessous :

示例2：l'opérateur de non binaire par bit

let　initialBits:　UInt8　=　0b11111111
let　invertedBits　=　~initialBits　　
print(invertedBits)

当您运行上述程序时，输出将是：

0

initialBits contient la valeur binaire11111111correspondant au décimal255. Pour représenter un nombre en binaire, nous utilisons 0b comme préfixe dans le texte. Si le préfixe 0b n'est pas utilisé, il le traitera comme un entier normal et il y aura une erreur d'overflow (UInt8ne peut stocker que des nombres entre255entre ces nombres).

parce que nous avons utilisé l'opérateur de non binaire, tous les1tous passent à 0. Par conséquent, la constante reverseBits contient 00000000, ce qui équivaut à un UInt8des 0.

示例3：l'opérateur de non binaire pour les entiers signés

let　initalNumber:Int　=　1　
let　invertedNumber　=　~initalNumber　
print(invertedNumber)

当您运行上述程序时，输出将是：

-2

dans le programme suivant, le nombre décimal1qui peut être représenté en binaire comme 00000001L'opérateur de non binaire change tous les bits d'un variable ou d'une constante, changeant le bit 0 en1。1passer à 0. Par conséquent, l'inversion du nombre contient des bits11111110。 Cela devrait être affiché à l'écran254au lieu de retourner-2。 Étonnant, n'est-ce pas ? Regardons maintenant comment cela se produit.

let initalNumber: Int = 1est un Int signé, qui peut contenir à la fois des entiers positifs et négatifs. C'est pourquoi, lorsque nous appliquons un opérateur non signé à un entier signé, le nombre binaire retourné peut également représenter un nombre négatif.

comment le compilateur transforme -2 explication de11111110 sous forme binaire ?

Le compilateur utilise le complément à deux pour représenter les entiers. Pour obtenir le complément à deux d'un entier, vous devez d'abord écrire le nombre sous forme binaire, puis inverser le nombre, puis ajouter 1 au résultat.

chercher-2Les étapes pour obtenir le complément à deux du nombre sous forme binaire :

1. écrit sous forme binaire2: 00000010

2. inversez le nombre. 0 devient1et1et devient 0:11111101

3. ajoute1: 11111110

C'est ce que le compilateur transforme en nombre binaire1111110interprété comme décimal de}-2manière. Mais, le compilateur a un petit problème que nous n'avons pas remarqué. Il déduit également le type de invertedNumber comme Int8type.

Pour comprendre cela, regardons l'exemple suivant :

print(Int8(bitPattern:　0b11111110))
print(0b11111110)

当您运行上述程序时，输出将是：

-2
254

Dans l'exemple ci-dessus, le compilateur traite uniquement les entiers signés8bits entier traite le nombre binaire comme décimal-2. Par conséquent, la directive print(Int8(bitPattern: 0b11111110))在屏幕上输出-2。

de taille32/64bits et peut contenir des valeurs plus grandes, l'entier normal type interprète la valeur comme254. Par conséquent, la directive print(0b11111110) est affiché254。

2. Opérateur ET binaire

Il est représenté par &, et peut être appliqué à deux opérandes. L'opérateur AND compare deux bits, et si les deux bits sont1，则返回1，否则返回0。

如果x和y是变量/常量，保存二进制值，即0或1. Les opérations ET binaire des bits de x et y peuvent être représentées par le tableau suivant :

示例5：Opérateur ET binaire

let　xBits　=　0b10000011
let　yBits　=　0b11111111
let　result　=　xBits　&　yBits
print("Binary:", String(result,　radix:　2))
print(result)

当您运行上述程序时，输出将是：

Binary:　10000011
131

Dans le programme ci-dessus, la directive let result = xBits & yBits combine les bits des deux opérandes xBits et yBits. Si ces deux bits sont1，则返回1，否则返回0。

String(value , radix: ) est utilisé pour représenter des nombres dans différents systèmes de numération. Si nous fournissons la valeur de base2. Il convertit le nombre en système binaire. De même, nous pouvons utiliser16représente l'hexadécimal, avec10représente l'octal.

该语句print("Binary:",String(result, radix: 2))在屏幕上输出 Binary：10000011。10000011égal à l'octal131, la directive print(result) affiche le résultat dans le console131。

3. Opérateur OU binaire

Il est représenté par |, et peut être appliqué à deux opérandes. Si un ou plusieurs des entrées de l'opérateur OU binaire sont1，elle compare les deux bits et génère le résultat1，sinon c'est 0.

Si x et y conservent la valeur binaire (c'est-à-dire 0 ou1） de la variable/Les opérations OU binaire des constantes peuvent être représentées par le tableau suivant :

示例6：Opérateur OU binaire

let　xBits　=　0b10000011
let　yBits　=　0b11111111
let　result　=　xBits　|　yBits
print("Binary:",　String(result,　radix:　2))
print(result)

当您运行上述程序时，输出将是：

Binary:　11111111
255

Dans le programme ci-dessus, la directive let result = xBits | yBits combine les bits des deux constantes xBits et yBits. Si l'un des bits est1，则返回1，否则返回0。

La directive print("Binary:", String(result, radix: 2)) est affiché sur l'écranBinary：11111111Pour cette raison11111111et255équivalent décimal, donc la directive print(result) affiche le résultat sur l'écran255。

4. Opérateur XOR binaire

Il est représenté par ^, et peut être appliqué à deux opérandes. L'opérateur XOR compare les bits, et si un seul des deux entrées est1，则生成结果1，否则返回0。

如果x和y是变量/常量，保存二进制值，即0或1。x和y上的位异或运算可表示为下表：

示例7：按位异或运算

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。

5.按位移位运算符

该运算符用于将数字中的所有位向左或向右移动一定数量的位置，并且可以应用于单个操作数。它表示为<<或>>。

移位运算符有两种：

按位左移运算符

• 表示为 <<

• 它会导致位向左移位，该移位是由数字后跟 << 指定的。

• 移位操作空出的位位置用零填充。

• 将整数的位左移一个位置会使其值加倍

示例8：按位左移运算符

let　someBits:UInt8　=　0b11000100
print(someBits　<<　1)

当您运行上述程序时，输出将是：

136

在上面的程序中，我们使用了左移运算符。使用<<1表示将位向左移动1。这些数字向左移动一个位置，右侧的最后一个数字填充零。

您还可以看到从左侧“末端”移位的数字丢失。 它不会再次从右侧绕回。 将其向左移位一位将从二进制中移除1，并在右侧添加0以填充移位值，而其他位的其余位则向左位置移位1。

返回10001000，相当于UInt8中的136。因此，print(someBits<<1) 语句在屏幕中输出136。

按位右移运算符

• 表示为 >>

• 它会导致位向右移位，移位的数字后跟 >>

• 对于无符号数字，移位操作腾出的位位置是零填充的。

• 对于有符号的数字（也可以是负数），符号位用于填充腾出的位位置。换句话说，如果数字为正，则使用0；如果数字为负，则使用1。

• 向右移动一个位置，其值将减半。

示例9：无符号整数的按位右移运算符

let　someBits:　UInt8　=　4　　　　　
print(someBits　>>　1)

当您运行上述程序时，输出将是：

2

在上面的程序中，我们对无符号整数使用了右移运算符。使用 >>1意味着将位向右移动1。移位操作腾出的位位置对于无符号整数总是零填充。

因为，4在二进制中表示为00000100。右移一位，返回00000010，相当于UInt8中的2。因此，print(someBits>>1) 语句在屏幕中输出2。

示例10：有符号整数的按位右移运算符

let　someBits:Int　=　-4　　　　　
print(someBits　>>　1)

当您运行上述程序时，输出将是：

-2

在上面的程序中，我们对无符号整数使用了右移运算符。 与正数不同，使用>>表示负数，使用1填充空位，而不是0。

因为，-4在二进制中表示为11111100。右移一位并将1置于空位，返回11111110，这相当于Int8类型的-2。因此，print（someBits>>1）语句在屏幕中输出-2。