C unsigned int tableau de bits et changements

Si j'ai un tableau de short unsigned ints.

Serait décalage tableau[k+1] gauche par 8 bits, mettre 8 bits dans la moitié inférieure de la matrice[k+1]?

Ou ont-ils simplement déposer comme ils l'ont fait en dehors de l'espace alloué pour l'élément?

Vouliez-vous dire shifting array[k] left?

OriginalL'auteur Darrel | 2009-11-22

Ils abandonnent. Vous ne pouvez pas affecter les autres bits de cette façon. Essayez-le:

#include <stdio.h>

void print_a (short * a)
{
    int i;
    for (i = 0; i < 3; i++)
        printf ("%d:%X\n", i, a[i]);
}

int main ()
{
    short a[3] = {1, -1, 3};
    print_a (a);
    a[1] <<= 8;
    print_a (a);
    return 0;
}

De sortie est

0:1 
1:FFFFFFFF 
2:3 
0:1 
1:FFFFFF00 
2:3

OriginalL'auteur

Ils abandonnent le type de données totalement, ne portant pas sur le prochain élément de tableau.

Si vous voulez ce genre de comportement, vous avez le code vous-même avec quelque chose comme (à gauche décalage de l'ensemble de la matrice par quatre bits):

#include <stdio.h>
int main(void) {
    int i;
    unsigned short int a[4] = {0xdead,0x1234,0x5678,0xbeef};

    //Output "before" variables.

    for (i = 0; i < sizeof(a)/sizeof(*a); i++)
        printf ("before %d: 0x%04x\n", i, a[i]);
    printf ("\n");

    //This left-shifts the array by left-shifting the current
    //element and bringing in the top bit of the next element.
    //It is in a loop for all but hte last element.
    //Then it just left-shifts the last element (no more data
    //to shift into that one).

    for (i = 0; i < sizeof(a)/sizeof(*a)-1; i++)
        a[i] = (a[i] << 8) | (a[i+1] >> 8);
    a[i] = (a[i] << 8);

    //Print the "after" variables.

    for (i = 0; i < sizeof(a)/sizeof(*a); i++)
        printf ("after  %d: 0x%04x\n", i, a[i]);

    return 0;
}

Ce sorties:

before 0: 0xdead
before 1: 0x1234
before 2: 0x5678
before 3: 0xbeef

after  0: 0xad12
after  1: 0x3456
after  2: 0x78be
after  3: 0xef00

OriginalL'auteur paxdiablo

2

La manière de penser, c'est que dans C (et pour la plupart des langages de programmation) la mise en œuvre de array[k] << 8 implique le chargement de tableau[k] dans un registre, un décalage de registre, puis stocker le registre de retour dans un tableau[k]. Donc tableau[k+1] restent intacts.

Comme un exemple, foo.c:
```
unsigned short array[5];

void main() {
  array[3] <<= 8;
}
```
Va générer les instructions suivantes:
```
movzwl  array+6(%rip), %eax
sall    $8, %eax
movw    %ax, array+6(%rip)
```
Cette charge tableau[3] dans %eax, les modifie, et les stocke en arrière.

OriginalL'auteur Craig Trader
0

De déplacement d'un unsigned int gauche par les 8 bits de remplissage inférieur de 8 bits avec des zéros. Le top 8 bits seront mis au rebut, il n'importe pas qu'ils sont dans un tableau.

D'ailleurs, si 8 bits est la moitié d'un unsigned int dépend de votre système, mais sur les systèmes 32 bits, 8 bits est généralement un quart d'un unsigned int.
```
unsigned int x = 0x12345678;
//x is 0x12345678

x <<= 8;
//x is 0x34567800
```
OriginalL'auteur Tom
0

Être conscient que le C de la définition du type de données int ne précise pas combien de bits il contient et est dépendante du système. Un int était à l'origine destiné à être le "naturel" taille de mot du processeur, mais ce n'est pas toujours le cas et vous pourriez trouver int contient 16, 32, 64 ou même certains nombre impair de 24 bits.

La seule chose qui vous garanti est un unsigned int peut contenir toutes les valeurs entre 0 et UINT_MAX inclusive, où UINT_MAX doit être d'au moins 65535 - de sorte que l'int types doit contenir au moins 16 bits pour contenir le nécessaire de plage de valeurs.

Afin de déplacement d'un tableau d'entiers de 8 bits changent chaque int individuellement, mais sachez que ce changement ne sera pas nécessairement être "moitié de la matrice'

OriginalL'auteur Cruachan

Vous devez vous connecter pour publier un commentaire.