C unsigned int matrice de décalages de bits et

Question

Si j'ai un tableau de courts ints non signés.

Would matrice de décalage [k + 1] à gauche par 8 bits, 8 bits mis dans la moitié inférieure de la matrice [k + 1]?

Ou ils abandonnent tout simplement hors car ils sont allés à l'extérieur de l'espace alloué pour l'élément?

Answer 1

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

#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;
}

La sortie est

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

Answer 2

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

Si vous voulez ce genre de comportement, vous devez vous-même code avec quelque chose comme (décalage gauche du tableau entier 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;
}

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

Answer 3

La façon de penser à ce sujet est que, en C (et pour la plupart des langages de programmation) la mise en œuvre de array[k] << 8 implique tableau de chargement [k] dans un registre, décalage du registre, puis stocker de nouveau le registre dans un tableau [k]. Ainsi tableau [k + 1] restera intacte.

À titre d'exemple, foo.c:

unsigned short array[5];

void main() {
  array[3] <<= 8;
}

génère les instructions suivantes:

movzwl  array+6(%rip), %eax
sall    $8, %eax
movw    %ax, array+6(%rip)

Ce tableau de charges [3] en% eax, modifie, et le stocke en arrière.

Answer 4

Shifting un unsigned int gauche par 8 bits remplira les 8 bits inférieurs avec des zéros. Les 8 bits supérieurs seront mis au rebut, peu importe qu'ils sont dans un tableau.

Par 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 typiquement un quart d'unsigned int.

unsigned int x = 0x12345678;
// x is 0x12345678

x <<= 8;
// x is 0x34567800

Answer 5

Sachez que la définition C du type de données int ne précise pas le nombre de bits qu'il contient et dépend du système. Un int était initialement destiné à être le « naturel » taille de mot du processeur, mais ce n'est pas toujours et vous pouvez trouver int contient 16, 32, 64 ou même un certain nombre impair comme 24 bits.

La seule chose que vous êtes assuré est un entier non signé peut contenir toutes les valeurs comprises entre 0 et UINT_MAX inclus, où UINT_MAX doit être d'au moins 65535 - de sorte que les types int doit contenir au moins 16 bits pour maintenir la gamme requise des valeurs.

décaler une gamme de nombre entier par 8 bits change à chaque int individuellement, mais il faut savoir que ce changement ne sera pas nécessairement «moitié de la matrice