Comment remplacer des bits dans un champ de bits sans affecter d'autres bits en utilisant c

Je voulais remplacer bits/bits(plus de 1) dans un 32/64 bits du champ de données sans affecter les autres bits.Dire par exemple:

J'ai un 64 bits registre où les bits 5&6 peut prendre des valeurs 0,1,2,3.

Maintenant, quand j'ai lu le registre je reçois dire la valeur 0x146(0001 0 10 0 0110).Maintenant, je veux changer la valeur à la position des bits 5 et 6 de 01.(maintenant, c'est 10, qui est de 2 en décimal et je veux le remplacer pour 1 e 01) sans autres bits d'être touché et écrire de nouveau le registre avec bits seulement 5&6 modifié.(il devenir 126 après le changement)

J'ai essayé de faire ce

reg_data=0x146
reg_data |= 1 << shift   (shift in this case is 5)

Si je fais cette valeur à peu les positions 5& 6 deviendra 11(0x3) et pas 01(0x1) qui je voulais.

Comment puis-je aller sur le faire lire/modifier/écrire?
Comment puis-je la remplacer uniquement certains bits/octets dans un 32/64 bits champs sans affecter l'ensemble des données du champ à l'aide de C?

Mettre un bit est ok, mais plus de un peu, je trouve ça un peu difficile.

Toutes les suggestions sont grandement appréciés.

source d'informationauteur Unicorn

bit-manipulation c

Pourquoi n'utilisez-vous pas un masque? Un peu comme:

new_value = 0, 1, 2 or 3  //(this is the value you will set in)
bit_mask = (3<<5)         //(mask of the bits you want to set)
reg_data = (reg_data & (~bit_mask)) | (new_value<<5)

Cela préserve l'ancien bits et OU du dans la de nouveaux.

reg_data &= ~( (1 << shift1) | (1 << shift2) );
reg_data |= ( (1 << shift1) | (1 << shift2) );

La première ligne efface les deux bits (shift1, shift2) et la deuxième ligne définit.

5

Ici est un processus générique qui agit sur un tableau, il envisage un long champ de bits et les adresses de chaque position de bit individuellement
```
#define set_bit(arr,x) ((arr[(x)>>3]) |= (0x01 << ((x) & 0x07)))
#define clear_bit(arr,x) (arr[(x)>>3] &= ~(0x01 << ((x) & 0x07)))
#define get_bit(arr,x) (((arr[(x)>>3]) & (0x01 << ((x) & 0x07))) != 0)
```
Prend simplement l'indice le plus faible de 3 btis de l'indice pour identifier les 8 différentes positions de bits à l'intérieur de chaque emplacement de la char tableau, et la partie supérieure reste des bits d'adresses dans laquelle la matrice de l'emplacement ne le bit désigné par x se produire. Espérons que cette aide.

Edit1:
Pour définir un bit vous avez besoin de OU le mot cible avec un autre mot avec 1 dans cette position de bit et 0 dans tous les autres avec la cible. Tous les 0 dans tous les autres postes s'assurer que le 1 est dans la cible, tout comme pendant OU, et les 1 dans les positions assure que la cible obtient la 1 dans cette position. si nous avons masque = 0x02 = 00000010 (1 octet), alors on peut OU ce à n'importe quel mot pour définir de quelques pos
```
target = 1 0 1 1 0 1 0 0
OR       + + + + + + + +
mask     0 0 0 0 0 0 1 0
         ---------------
answer   1 0 1 1 0 1 1 0
```
Pour effacer un peu vous en avez besoin ET le mot cible avec un autre mot avec 0 dans cette position de bit et 1 dans tous les. Tous 1 dans toutes les autres positions de bits s'assurer que lors de ET la cible conserve ses valeurs 0 et 1 comme ils l'ont été dans ces endroits, et un 0 dans la position du bit à être effacé serait également définir la position du bit 0 du mot cible. si nous avons le même masque = 0x02, alors on peut préparer ce masque pour la compensation par ~masque
```
mask  = 0 0 0 0 0 0 1 0 
~mask = 1 1 1 1 1 1 0 1
AND     . . . . . . . .
target  1 0 1 1 0 1 1 0
        ---------------
answer  1 0 1 1 0 1 0 0
```

La question était de savoir comment mettre en œuvre en C, mais comme al recherche pour "remplacer bits" entraîner ici, je vais fournir ma mise en œuvre dans VB.Net. Il a été de test de l'unité testée. Pour ceux qui se demandent ce que l' ToBinaryString extension ressemble: Convert.ToString(value,2)

     ''' <summary>
''' Replace the bits in the enumValue with the bits in the bits parameter, starting from the position that corresponds to 2 to the power of the position parameter.
''' </summary>
''' <param name="enumValue">The integer value to place the bits in.</param>
''' <param name="bits">The bits to place. It must be smaller or equal to 2 to the power of the position parameter.</param>
'''<param name="length">The number of bits that the bits should replace.</param>
''' <param name="position">The exponent of 2 where the bits must be placed.</param>
''' <returns></returns>
''' <remarks></remarks>'
<Extension>
Public Function PlaceBits(enumValue As Integer, bits As Integer, length As Integer, position As Integer) As Integer
If position > 31 Then
Throw New ArgumentOutOfRangeException(String.Format("The position {0} is out of range for a 32 bit integer.",
position))
End If
Dim positionToPlace = 2 << position
If bits > positionToPlace Then
Throw New ArgumentOutOfRangeException(String.Format("The bits {0} must be smaler than or equal to {1}.",
bits, positionToPlace))
End If
'Create  a bitmask (a series of ones for the bits to retain and a series of zeroes for bits to discard).'
Dim mask As Integer = (1 << length) - 1
'Use for debugging.'
'Dim maskAsBinaryString = mask.ToBinaryString'
'Shift the mask to left to the desired position'
Dim leftShift = position - length + 1
mask <<= leftShift
'Use for debugging.'
'Dim shiftedMaskAsBinaryString = mask.ToBinaryString'
'Shift the bits to left to the desired position.'
Dim shiftedBits = bits << leftShift
'Use for debugging.'
'Dim shiftedBitsAsBinaryString = shiftedBits.ToBinaryString'
'First clear (And Not) the bits to replace, then set (Or) them.'
Dim result = (enumValue And Not mask) Or shiftedBits
'Use for debugging.'
'Dim resultAsBinaryString = result.ToBinaryString'
Return result
End Function

1
1. Appliquer un masque sur le champ de bits pour maintenir les bits que vous ne voulez pas cnange. Cela aidera à éliminer les bits que vous serez en train de changer.
2. Assurer que vous avez un champ de bits qui contient uniquement les bits que vous souhaitez définir/effacer.
3. Soit utiliser l'opérateur ou à "ou" les deux bitfields, ou tout simplement les ajouter.
Par exemple, si vous souhaitez uniquement modifier les bits 2 à 5 basée sur la saisie de 0 thru 15.
```
byte newVal = (byte)value & 0x0F;
newVal = (byte)value << 2;
oldVal = oldVal & 0xC3;
oldVal = oldval + newVal;
```
0

Vous aurez besoin de faire un bit à la fois. Utilisez ou que vous êtes en train de faire pour définir un bit à un, et à utiliser les éléments suivants pour définir quelque chose à 0:
```
reg_data &= ~ (1 << shift)
```
0

Vous pouvez utiliser cette dynamique logique pour un nombre quelconque de bits et dans tout champ de bits.
Fondamentalement, vous avez 3 pièces dans une séquence de bits de numéro

MSB_SIDE | CHANGED_PART | LSB_SIDE

La CHANGED_PART peut être déplacée jusqu'à l'extrême MSB ou LSB côté.

Les étapes pour remplacer un certain nombre de bit(s) sont comme suit -
1. Prenez seulement MSB_SIDE partie et de le remplacer tous les autres bits à 0.
2. Mise à jour de la nouvelle séquence de bits en ajoutant votre choix séquence de bits en position particulière.
3. Mise à jour de l'ensemble de la séquence de bits avec LSB_SIDE de l'original de la séquence de bits.
```
org_no = 0x53513C;
upd_no = 0x333;
start_pos = 0x6, bit_len = 0xA;
temp_no = 0x0;
temp_no = org_no & (0xffffffff << (bit_len+start_pos));  //this is step 1
temp_no |= upd_no << start_pos;  //this is step 2
org_no = temp_no | (org_no & ~(0xffffffff << start_pos));  //this is step 3`
```
Remarque: Le masquage à 0xffffffff est considéré comme de 32 bits. Vous pouvez modifier selon vos besoins.

Vous devez vous connecter pour publier un commentaire.