Campo di bit

Da Wikipedia, l'enciclopedia libera.
Vai alla navigazione Vai alla ricerca

Un campo di bit è una struttura dati utilizzata nella programmazione del computer. Consiste di un numero di locazioni di memoria del computer adiacenti che sono state allocate per contenere una sequenza di bit, memorizzate in modo che ogni singolo bit o gruppo di bit all'interno dell'insieme possa essere indirizzato.[1][2] Un campo di bit è più comunemente usato per rappresentare tipi di dato primitivi di larghezza di bit fissa nota.

Il significato dei singoli bit all'interno del campo è determinato dal programmatore; ad esempio, il primo bit in un campo di bit (situato all'indirizzo di base del campo) viene talvolta utilizzato per determinare lo stato di un particolare attributo associato al campo di bit.[3]

All'interno di microprocessori e altri dispositivi logici, raccolte di campi di bit denominati "flag" sono comunemente utilizzati per controllare o indicare lo stato intermedio o il risultato di particolari operazioni.[4] I microprocessori hanno tipicamente un registro di stato composto da tali flag, utilizzati per indicare varie condizioni post-operazione, ad esempio un overflow aritmetico. I flag possono essere letti e usati per decidere le operazioni successive, come nell'elaborazione delle istruzioni di salto condizionale. Ad esempio, un JE ... JE ... JE ... (Salta se uguale) nel linguaggio assembly x86 risulterà in un salto se il flag Z (zero) è stato impostato da qualche operazione precedente.

Un campo di bit si distingue da un array di bit in quanto quest'ultimo viene utilizzato per memorizzare un ampio insieme di bit indicizzati da numeri interi ed è spesso più ampio di qualsiasi tipo integrale supportato dal linguaggio.[senza fonte] I campi di bit, d'altra parte, tipicamente rientrano in una word del calcolatore[3], e la denotazione dei bit è indipendente dal loro indice numerico.[2]

Implementazione

[modifica | modifica wikitesto]

I campi di bit possono essere utilizzati per ridurre il consumo di memoria quando un programma richiede un numero di variabili intere che avranno sempre valori piccoli. Ad esempio, in molti sistemi la memorizzazione di un valore intero richiede due byte (16 bit) di memoria; a volte i valori da memorizzare necessitano effettivamente solo uno o due bit. Il fatto che un certo numero di queste minuscole variabili condivida un campo di bit consente un impacchettamento efficiente dei dati nella memoria.[5]

In C e C++, i campi di bit definiti dall'implementazione nativa possono essere creati utilizzando unsigned int, signed int o, in C99, _Bool. In questo caso, il programmatore può dichiarare una struttura per un campo di bit che etichetta e determina la larghezza di diversi sottocampi.[6] Campi di bit dello stesso tipo dichiarati adiacenti possono quindi essere impacchettati dal compilatore in un numero ridotto di parole, rispetto alla memoria utilizzata se ogni "campo" dovesse essere dichiarato separatamente.

Per i linguaggi prive di campi di bit nativi o in cui il programmatore desidera un controllo rigoroso sulla rappresentazione dei bit risultante, è possibile manipolare manualmente i bit all'interno di un tipo di parola più grande. In questo caso, il programmatore può impostare, testare e modificare i bit nel campo utilizzando combinazioni di mascheramento e operazioni bitwise.[7]

Esempi

[modifica | modifica wikitesto]

Linguaggio di programmazione C

[modifica | modifica wikitesto]

Dichiarazione di un campo bit in C e C++: 

// nascosto e visibile
#define SI 1
#define NO 0

// stili di linea
#define CONTINUO     1
#define PUNTEGGIATO  2
#define TRATTEGGIATO 3

// colori primari
#define BLU   4 /* 100 */
#define VERDE 2 /* 010 */
#define ROSSO 1 /* 001 */

// colori misti
#define NERO     0                    /* 000 */
#define GIALLO  (ROSSO | VERDE)       /* 011 */
#define MAGENTA (ROSSO | BLU)         /* 101 */
#define CIANO   (VERDE | BLU)         /* 110 */
#define BIANCO  (ROSSO | VERDE | BLU) /* 111 */

const char* colori[8] = {"Nero", "Rosso", "Verde", "Giallo", "Blu", "Magenta", "Ciano", "Bianco"};

// Proprietà del struttura di campi di field
struct PropBox
{
 unsigned int opaco        : 1;
 unsigned int riempi_colore: 3;
 unsigned int              : 4; // Riempie fino all'ottavo bit
 unsigned int mostra_bordo : 1;
 unsigned int colore_bordo : 3;
 unsigned int stile_bordo  : 2;
 unsigned char             : 0; // Riempie fino al byte più vicino (16 bit)
 unsigned char larghezza   : 4, // Divide un byte in due campi di 4 bit
               altezza     : 4;
};

[6] Il layout dei campi di bit in una struct C è definito dall'implementazione. Per avere un comportamento che rimanga prevedibile tra i vari compilatori, potrebbe essere preferibile emulare i campi di bit con gli operatori bit a bit e non:

/ * Ciascuna di queste direttive del preprocessore definisce un singolo bit,
corrispondente ad un pulsante sul controller. L'ordine dei pulsanti
corrisponde a quello del Nintendo Entertainment System. * /
#define KEY_RIGHT  (1 << 0) /* 00000001 */
#define KEY_LEFT   (1 << 1) /* 00000010 */
#define KEY_DOWN   (1 << 2) /* 00000100 */
#define KEY_UP     (1 << 3) /* 00001000 */
#define KEY_START  (1 << 4) /* 00010000 */
#define KEY_SELECT (1 << 5) /* 00100000 */
#define KEY_B      (1 << 6) /* 01000000 */
#define KEY_A      (1 << 7) /* 10000000 */

int gameControllerStatus = 0;

/* Imposta il gameControllerStatus usando OR */
void KeyPressed( int key ) { gameControllerStatus |= key; }

/* Disattiva un tasto in gameControllerStatus usando AND e ~ (NOT binario) */
void KeyReleased( int key ) { gameControllerStatus &= ~key; }

/* Verifica se un bit è settato utilizzando AND */
int IsPressed( int key ) { return gameControllerStatus & key; }

Note

[modifica | modifica wikitesto]
  1. ^ Penn Brumm e Don Brumm, 80386 Assembly Language: A Complete Tutorial and Subroutine Library, McGraw-Hill School Education Group, August 1988, p. 606, ISBN 978-0-8306-9047-3.
  2. ^ a b Steve Oualline, Practical C Programming, "O'Reilly Media, Inc.", 1997, pp. 403–, ISBN 978-1-56592-306-5.
  3. ^ a b Michael A. Miller, The 68000 Microprocessor Family: Architecture, Programming, and Applications, Merrill, January 1992, p. 323, ISBN 978-0-02-381560-7.
  4. ^ Ian Griffiths, Matthew Adams e Jesse Liberty, Programming C# 4.0: Building Windows, Web, and RIA Applications for the .NET 4.0 Framework, "O'Reilly Media, Inc.", 30 July 2010, pp. 81–, ISBN 978-1-4493-9972-6.
  5. ^ Tibet Mimar, Programming and Designing with the 68000 Family: Including 68000, 68010/12, 68020, and the 68030, Prentice Hall, 1991, p. 275, ISBN 978-0-13-731498-0.
  6. ^ a b Stephen Prata, C primer plus, 5thª ed., Indianapolis, Ind, Sams, 2007, ISBN 978-0-672-32696-7.
  7. ^ Mark E. Daggett, Expert JavaScript, Apress, 13 November 2013, pp. 68–, ISBN 978-1-4302-6097-4.

Voci correlate

[modifica | modifica wikitesto]
  • Codice binario
  • Bitboard, utilizzato negli scacchi e in giochi simili.
  • Matrice di bit (o stringa di bit)
  • Word (architettura del computer)
  • Maschera (informatica)
  • Parola di stato del programma
  • Registro di stato
  • Registro FLAGS (informatico)
  • Registro di controllo

Collegamenti esterni

[modifica | modifica wikitesto]
  Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica
Estratto da "https://it.wikipedia.org/w/index.php?title=Campo_di_bit&oldid=141123719"