J'ai du mal à comprendre le bon opérateur de quart. Je comprends le décalage à gauche. Disons que nous n'avons pas de
int a = n >> 1
Maintenant, si nous quittons le décalage, n
Le résultat est
int a = n << 1 ; so a = 10110; (simply add a 0 to the end)
Cela a du sens
Maintenant c'est le quart de travail à droite où j'ai des difficultés
int n = 11; which is 1011
Je pense que la réponse est 01011 (ajoutez un 0 à l'avant) qui serait à nouveau 1011 mais à la place c'est 101. Ma question est de savoir comment avons-nous perdu le dernier chiffre.
Mon raisonnement pourrait être de supposer qu'un int est 8 bits dans ce cas, nous aurons int8 n = 1011 => qui est 00001011 donc lorsque nous décalons vers la droite de 1, il dépasse 8 bits int de 1 donc le dernier bit est abandonné et il devient 0000101? Cette compréhension est-elle correcte?
5 Réponses :
1011 sera 101 après le décalage à droite. Le bit le plus à droite a été supprimé de 1011 .
111110101 lorsque décalé vers la droite de 3 donne 111110 , en supprimant les bits en gras 111110 101
Comment les bits sont-ils supprimés? C'est ce que je recherche. Y a-t-il une raison pour laquelle les 3 derniers bits de votre exemple ont été supprimés. Est-ce parce qu'il dépasse la taille int ou quelque chose? parce qu'un int9 (disons que int est 9 bits) pourrait être 111110101 lorsqu'il est décalé à droite de 3, il perd les 3 derniers bits?
@MistyD C'est le but du changement. Pour supprimer les bons bits.
Je sais mais j'essaie de savoir pourquoi il est abandonné?
@MistyD oh, je t'ai maintenant.
Il semble que vous ayez mal compris le fonctionnement des équipes.
Le décalage n'ajoute pas de zéro à gauche ou à droite. Vous ne pouvez pas simplement ajouter des chiffres, il n'y a qu'un nombre limité de bits. Prenons votre nombre, le nombre décimal 11.
int n = 11; qui est 1011
C'est vrai, mais seulement la moitié de l'histoire. Vous voyez, les nombres ont une taille fixe dans votre CPU. Pour les entiers, c'est 32 bits, mais pour faciliter les choses, supposons des nombres de 8 bits. Votre 11 ressemble à ceci:
+-+-+-+-+-+-+-+-+ |0|0|0|0|0|1|0|1| +-+-+-+-+-+-+-+-+
Il a 8 bits. Toujours. Faisons maintenant un décalage vers la gauche de 1:
+-+-+-+-+-+-+-+-+ | |0|0|0|0|1|0|1|1 +-+-+-+-+-+-+-+-+
Après avoir décalé, le premier bit a été "décalé". Il n'y a pas d'espace pour stocker ce bit. De plus, le dernier bit est "vide", nous ne pouvons pas stocker le "vide". Il n'y en a qu'un ou zéro. Au lieu de cela, nous «décalons» les zéros. Donc, vous vous retrouvez avec
+-+-+-+-+-+-+-+-+ |0|0|0|0|1|0|1|1| +-+-+-+-+-+-+-+-+
Lors d'un décalage à droite, c'est l'inverse. Nous recommençons par 11:
+-+-+-+-+-+-+-+-+ |0|0|0|1|0|1|1|0| +-+-+-+-+-+-+-+-+
et décalons vers la droite de 1:
+-+-+-+-+-+-+-+-+ 0|0|0|0|1|0|1|1| | +-+-+-+-+-+-+-+-+
Encore une fois, chaque bit a été décalé de droite 1. Sur la gauche, il y a un bit vide qui, comme précédemment, devient juste zéro. Sur la droite, celui a été déplacé et il n'y a pas d'espace pour le stocker. C'est juste perdu. Notre nombre final est:
+-+-+-+-+-+-+-+-+ |0|0|0|0|1|0|1|1| +-+-+-+-+-+-+-+-+
Ci-dessus est vrai pour les nombres non signés, également appelés décalage logique vers la droite . Sur un système de complément à deux, pour les nombres signés, il utilise le soi-disant décalage arithmétique à droite , qui au lieu de se décaler en zéro bits, il se décale en bits de signe. C'est à dire. si le nombre est négatif, donc le bit le plus significatif est un, il se décale dans un, sinon il se décale en zéro.
Donc ma compréhension était correcte. Dans la section mise à jour
Il y a plusieurs façons de le voir.
Premièrement, les types numériques entiers (en C, C ++, Java, C #) ont un nombre fixe de bits. Donc, 11 est en fait (en supposant le rare int 8 bits pour la lisibilité):
00001101 (8 digits)
Décalage à gauche d'un bit
00011010 (8 digits)
Mais comme notre entier ne peut gérer que 8 bits, le bit le plus à gauche tombe.
00011010 (8 digits)
La même chose se produit avec les entiers 32 bits: le bit le plus à gauche tombe.
La même chose se produit avec le décalage droit: le bit de droite tombe. Si l'original est:
000011010 (9 digits?)
Ensuite, ajouter un bit à gauche crée une valeur de 9 bits, qui n'est pas prise en charge. Au lieu de cela, le zéro ajouté pousse tous les bits d'un endroit vers la droite, et le bit le plus à droite tombe, et le résultat est
00001101 (8 digits)
Une autre façon de voir les choses est comme la multiplication et division. En décimales, lorsque nous multiplions par 10, un zéro est ajouté à droite. Le décalage à gauche est comme la multiplication, mais pour le binaire. Lorsque nous divisons par 10, nous supprimons le chiffre le plus à droite et le mettons dans une fraction. Avec un binaire positif et un décalage à droite c'est pareil, on perd simplement la fraction.
Notez qu'avec des nombres négatifs les choses sont plus compliquées en C ++. Par exemple, le décalage vers la gauche d'un négatif n'est pas défini
Ma faute. Je suppose que ce n'est pas défini.
Disons que nous avons un nombre (nous allons faire simple, disons 00010000 ) et que nous voulons le décaler un peu vers la gauche, il ressemblera à ceci:
01010101 << 1 = 10101010 01010101 >> 1 = 00101010 11111111 << 2 = 11111100 11111111 >> 2 = 00111111
Nous avons pris un nombre, et mis la valeur de chaque colonne dans l'espace de la colonne 1 à sa gauche (car 1 est le nombre que nous mettons sur l'autre opérande du décalage de bits).
/ p>
Avec moi jusqu'ici? bien.
Maintenant, que fait un changement à droite? Eh bien, il fait le contraire. Il met la valeur de chaque colonne dans la colonne x espaces à sa droite . Par exemple:
00010000 >> 1 = 00001000
Quelques exemples plus avancés:
00010000 << 1 = 00100000
REMARQUE: Bit les décalages couperont tous les bits qui sont décalés au-dessus de la limite des données, comme dans l'exemple de 11111111 , tous les bits qui tombent sur le bord après le décalage sont perdus.
p >
Vous n'avez pas «perdu» le dernier chiffre. Vous ne changiez tout simplement pas la valeur que vous pensiez être.
Vous avez commencé avec n = 0b1011 . Vous avez déplacé cela vers la gauche d'un bit et stocké le résultat dans a , laissant n inchangé. Vous avez ensuite déplacé n (toujours avec la valeur 0b1011 ) vers la droite et obtenu 0b0101 .
Si vous aviez déplacé a vers la droite plutôt que n , vous auriez vu le résultat que vous attendiez.
Que voulez-vous dire ?
Oui je sais. Je voudrais savoir pourquoi le décalage à droite 1011 donne 101 au lieu de 01011 => 1011 (ce qui est pareil)
Comment avons-nous perdu le plus