C unsigned int array ed un po di turni

Se ho un array di unsigned short int.

Sarebbe cambiata matrice[k+1] sinistra da 8 bit, mettere 8 bit nella metà inferiore della matrice[k+1]?

O semplicemente lasciare che loro sono andati al di fuori dello spazio allocato per l’elemento?

Volevi dire shifting array[k] left?

OriginaleL’autore Darrel | 2009-11-22

5 Replies
  1. 4

    Che il drop off. Non è possibile influenzare gli altri bit in questo modo. Prova:

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

    Uscita è

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

    OriginaleL’autore

  2. 3

    Diminuiscono il tipo di dati totalmente, non portando al prossimo elemento della matrice.

    Se si desidera che il tipo di comportamento, è necessario il codice da te con qualcosa di simile (a sinistra spostando l’intero array da quattro bit):

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

    Questo output:

    before 0: 0xdead
    before 1: 0x1234
    before 2: 0x5678
    before 3: 0xbeef
    
    after  0: 0xad12
    after  1: 0x3456
    after  2: 0x78be
    after  3: 0xef00

    OriginaleL’autore paxdiablo

  3. 2

    Il modo di pensare è che in C (e per la maggior parte dei linguaggi di programmazione) l’attuazione per array[k] << 8 riguarda il caricamento della matrice[k] in un registro, spostando il registro, e quindi la conservazione del registro posteriore in matrice[k]. Così matrice[k+1] rimarrà intatta.

    Come un esempio, foo.c:

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

    Genererà le seguenti istruzioni:

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

    Questo carica array[3] in %eax, modifica e archivia indietro.

    OriginaleL’autore Craig Trader

  4. 0

    Spostando un unsigned int sinistra da 8 bit di riempimento inferiore a 8 bit con zeri. La top 8 bit sarà scartato, non importa che essi sono in un array.

    Per inciso, se a 8 bit è la metà di un unsigned int dipende dal tuo sistema, ma su sistemi a 32 bit, 8 bit è in genere un quarto di un unsigned int.

    unsigned int x = 0x12345678;
    //x is 0x12345678
    
    x <<= 8;
    //x is 0x34567800

    OriginaleL’autore Tom

  5. 0

    Essere consapevoli del fatto che il C definizione del tipo di dati int non specifica il numero di bit che contiene e dipende dal sistema. Int era originariamente destinato ad essere “naturale” parola del processore, ma non è sempre così e si potrebbe trovare int contiene 16, 32, 64 o anche qualche numero dispari come 24 bit.

    L’unica cosa che si sono garantiti un unsigned int può tenere tutti i valori tra 0 e UINT_MAX inclusive, dove UINT_MAX deve essere di almeno 65535 – così int i tipi devono contenere almeno 16 bit per l’intervallo di valori.

    Così spostamento di un array di interi da 8 bit cambierà ogni int singolarmente, ma essere consapevoli del fatto che questo cambiamento non sarà necessariamente “la metà della matrice’

    OriginaleL’autore Cruachan

Lascia un commento