Bitwise operations! come usare gli operatori Bitwise in C - pt.1

Anche se questo è un blog di stile (nel caso che qualcuno non se ne fosse ancora accorto...), ho deciso, ancora per un po', di continuare con la mia opera meritoria (che modestia!) di rinfrescare alcuni argomenti che, immagino, tutti hanno letto e/o studiato (magari sul K&R), e poi hanno prontamente dimenticato, perché, diciamocelo, il C contiene delle parti un po' specialistiche e di nicchia, che in alcuni ambienti di programmazione non si usano mai (ma proprio mai!).

Ripetiamo il giochetto dello scorso post: alzi la mano chi ha scritto recentemente codice che usa le operazioni bit a bit. Oppure, alzi la mano, senza prima andare a rileggersi un manuale del C, chi di voi sa usare e/o descrivere perfettamente le operazioni bit a bit. Uhmm... vedo poche mani alzate. Il fatto è che le bitwise operations sono una di quelle parti del C un po' misconosciute, di uso dubbio e infrequente, insomma una di quelle parti di cui, per mancanza di pratica ci si scorda (e ho usato esattamente le stesse parole dello scorso post: sono un ecologista, quando posso riciclo).

Rispetto alle union, oltretutto, devo dire che sulle operazioni bit a bit il fantastico K&R non è particolarmente chiaro e dettagliato, le tratta (come sono) come un argomento di nicchia, e non ti coinvolge con decine di divertenti esempi che ti aiutano a memorizzare definitivamente l'argomento, anzi, per quel che ricordo dell'ultima volta che lo lessi, sono un paio di pagine che scivolano via e che hai già dimenticato quando passi al prossimo capitolo. Beh anche la bibbia K&R (che io considero sacra) ha alcuni punti non proprio coinvolgenti.

Rinfreschiamo: gli operatori di bitwise (che operano sui singoli bit) sono:

"&"  AND
"|"  OR
"^"  XOR
"~"  NOT (complemento a 1)
"<<" SHIFT a sinistra
">>" SHIFT a destra  
     
N.B.:
- il NOT e' un operatore unario: opera su un solo argomento indicato
  sulla destra.
- gli shift sono operatori unari: operano su un solo argomento indicato
  sulla sinistra.

Adesso, senza dilungarci in noiosi sproloqui, passiamo a una piccola tabella e ad alcuni semplici esempi pratici.

Ecco la tabella:

"&":   il risultato è 1 se i due operandi valgono 1. Altrimenti 0.
"|":   il risultato è 0 se i due operandi valgono 0. Altrimenti 1.
"^":   il risultato è 1 se i due operandi sono diversi. Altrimenti 0.
"~":   il risultato è 1 se l'operando vale 0. Se l'operando vale 1 il risultato è 0.
"<<n": il risultato è l'operando con tutti i bit spostati a sinistra di
       n posizioni. 
">>n": il risultato è l'operando con tutti i bit spostati a destra di
       n posizioni.

Ed ecco i semplici esempi pratici:

AND
int a = 74;       // 0 1 0 0 1 0 1 0
int b = 174;      // 1 0 1 0 1 1 1 0
int c = a & b;    // 0 0 0 0 1 0 1 0 risultato c=10

OR
int a = 74;       // 0 1 0 0 1 0 1 0
int b = 174;      // 1 0 1 0 1 1 1 0
int c = a | b;    // 1 1 1 0 1 1 1 0 risultato c=238

XOR
int a = 74;       // 0 1 0 0 1 0 1 0
int b = 174;      // 1 0 1 0 1 1 1 0
int c = a ^ b;    // 1 1 1 0 0 1 0 0 risultato c=228

NOT
int a = 74;       // 0 1 0 0 1 0 1 0
int b = ~a;       // 1 0 1 1 0 1 0 1 risultato b=181

SHIFT a sinistra
int a = 74;       // 0 1 0 0 1 0 1 0
int b = a<<2;     // 0 0 1 0 1 0 0 0 risultato b=296

SHIFT a destra
int a = 74;       // 0 1 0 0 1 0 1 0
int b = a>>2;     // 0 0 0 1 0 0 1 0 risultato b=18

Notare che nelle operazioni di shift i bit nuovi che entrano a destra (nello shift a sinistra) valgono 0, e i bit nuovi che entrano a sinistra (nello shift a destra) valgono 0.

Notare anche che lo shift a destra equivale a una divisione per multipli di 2 (>>1 è una divisione per 2, >>2 è una divisione per 4, ecc.), mentre lo shift a sinistra equivale a una moltiplicazione per multipli di 2 (<<1 è una moltiplicazione per 2, <<2 è una moltiplicazione per 4, ecc.). Queste operazioni di moltiplicazione e divisione sono molto veloci, e si potrebbe essere tentati a usarle per velocizzare il codice: beh, prima di farlo rileggetevi (o leggetevi) questo.

E aggiungo un avvertimento: in base alla dimensione del tipo del operando e alla presenza o meno del bit di segno, le moltiplicazioni e divisioni con shift possono dare risultati inaspettati. Di questo ne parleremo in una prossima puntata, in cui faremo qualche esempio pratico di codice che usa le bitwise operations (e non trattenete il respiro, nel frattempo...).

Ciao e al prossimo post.

La union fa la forza come usare le union in C

Alzi la mano chi ha scritto recentemente codice che usa le union. Oppure, alzi la mano, senza prima andare a rileggersi un manuale del C, chi di voi sa usare e/o descrivere perfettamente le union ? Uhmm... vedo poche mani alzate. Il fatto è che le union sono una di quelle parti del C un po' misconosciute, di uso dubbio e infrequente, insomma una di quelle parti di cui, per mancanza di pratica, ci si scorda.

Per introdurvi l'argomento (e, ripeto, leggete senza consultare prima un manuale del C, se no non potete mettervi alla prova), vi racconterò una storia vera. Un tipo che conosco, le cui iniziali sono A.A. (di più non posso dirvi per questioni di privacy) andò, molto tempo fa, a un colloquio di lavoro, e gli proposero un semplice test come questo (più o meno):

#include <stdio.h>

void main(void)
{
    union u_test {
        int  i;
        char s[4];
    } my_test;

    my_test.i = 0x01020304;

    // cosa stampa la seguente linea?
    printf("s[0]=%d s[1]=%d s[2]=%d s[3]=%d\n",
        my_test.s[0], my_test.s[1], my_test.s[2], my_test.s[3]);
}

Ecco, per i motivi indicati all'inizio del post (uso dubbio e infrequente), il nostro amico che non usava una union da almeno 15 anni (si, 15 anni!), rimase inizialmente perplesso, sforzò la memoria e non cadde nel 1º livello di errore che induce questo test un po' ingannevole, 1º livello di errore che ti indurrebbe a dire:

ho inizializzato il campo i e vado a leggere il campo s: ma allora la printf() stampa valori indefiniti!

No, lui si ricordava che "le union allocano memoria per la più grande delle variabili interne, variabili che condividono lo stesso spazio di memoria", quindi non cadde nel tranello, e rispose quasi perfettamente... quasi, perché cadde nel 2º livello di errore, quello che ti porta a dire:

ho inizializzato i, però leggo s, che è come se fosse stata inizializzata anche lei, quindi la riposta è: s[0]=1 s[1]=2 s[2]=3 s[3]=4 !

Ok, quasi giusto: in realtà la risposta è:

s[0]=4 s[1]=3 s[2]=2 s[3]=1

Il nostro amico A.A. se ne rese conto tornando a casa, quando l'errore ormai era fatto: nella locazione s[0] ci finisce la parte meno significativa di i (quindi 0x04), e così via gli altri numeri, per cui il risultato era in ordine inverso. Va beh, cose che succedono...

Se cercate in rete con google troverete tanti utili esempi d'uso delle union, tra i quali, direi, i più interessanti sono quelli per il trattamento di dati con contenuto variabile (protocolli di comunicazione, per esempio) in cui si vuole trattare, con la stessa struttura dati, informazioni di tipo diverso, e interpretando la union, di volta in volta, nella maniera corretta selezionando un opportuno flag mantenuto dal programma. Questo permette di fare programmi flessibili e risparmiosi di memoria (rispetto all'uso delle struct), cosa che in alcuni ambienti di sviluppo potrebbe risultare utile.

Occhio però: per la maniera stessa in cui funzionano le union sono flessibili ma ingannevoli, e gli errori subdoli di funzionamento sono dietro l'angolo che aspettano. Bisogna essere molto rigorosi nel mantenere, e testare, il flag di stato che ci indica quale personalità della union stiamo usando in ogni momento.

Ciao e al prossimo post.

Questo post è ispirato ad una storia vera, ma ogni riferimento a fatti o persone realmente esistiti è puramente casuale (uhmm ???)

La maledizione della Callback di giada II - Il ritorno come scrivere una Callback in C - pt.2

Ho deciso di prendermi un attimo di pausa sulla questione del C a oggetti: ho già scritto due post sull'argomento e non voglio annoiarmi né annoiarvi. Lo so, si potrebbero approfondire altri dettagli e parlare (come promesso) di C vs C++, ma, in questo momento, non ne ho voglia. Comunque, prima o poi, ci torneremo di sicuro...

Per cui, oggi, ritorniamo su un argomento già trattato qui, e su cui (mi son reso conto proprio ieri) si potrebbe fare qualche aggiunta interessante. Sto parlando, nuovamente, delle funzioni callback.

Ovviamente, prima di continuare a leggere, dovreste rinfrescarvi la memoria rileggendovi l'altro post sull'argomento, perché questo ne è una estensione, e sono strettamente collegati.

Pausa di riflessione...

Siete già tornati? ma come ? Non avete ancor riletto il vecchio post? Dovete rileggerlo, grazie...

Altra pausa di riflessione...

Ecco, adesso possiamo continuare.

Allora, come avrete ri-notato, l'esempio che avevo proposto era, direi, classico, ispirato all'uso della qsort(), quindi con una callback che si chiama senza argomenti, ma che, in realtà, ne necessita due che verranno generati internamente dalla funzione stessa (la mysort() dell'esempio, o la qsort(), se preferite).

Quindi, riepiloghiamo il flusso dell'esempio: ho scritto un main() che usa la funzione mysort() che, per funzionare, ha bisogno di una funzione di comparazione tra due valori. Ho scritto anche, quindi, la funzione di comparazione (che può essere semplice come quella dell'esempio, ma anche molto più complessa, dipende da quello che si vuole ottenere). La funzione rispettava, ovviamente, il prototipo fornito con la mysort(): ossia, una funzione che ha bisogno di una callback, deve anche dichiarare il prototipo della calback stessa (e se no come la scriviamo?). La mysort() stessa si occupa, poi, di riempire i due parametri della callback con i valori da comparare.

E ora passiamo alla parte nuova: sempre riferendoci al nostro esempio della mysort() (che oramai conoscerete a memoria) supponiamo di avere bisogno di passare un altro parametro alla callback, un parametro esterno disponibile solo a livello della chiamata base, e che la mysort() non può generare internamente.

Come possiamo fare? Vediamo subito il nuovo codice (presentato come un blocco unico, ma, in realtà, da dividere su tre file):

/* parte che dovrebbe essere nel file mysort.h
*/
// prototipi per mySort()
typedef int (*mycallback)(int, int, void *);
void mySort(int *array, int nelems, mycallback cmpFunc, void *fp);

/* parte che dovrebbe essere nel file mysort.c
 */
// mySort() - funzione di sort che usa l'algoritmo bubblesort
void mySort(int *array, int nelems, mycallback cmpFunc, void *fp)
{
    // loop su tutti gli elementi di array
    while (nelems > 0) {
        // loop interno con lunghezza calante
        int i;
        for (i = 0; i < (nelems - 1); i++) {
            // eseguo callback di comparazione
            if (cmpFunc(array[i], array[i + 1], fp)) {
                // eseguo swap di array[i] e array[i+1]
                int temp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = temp;
            }
        }

        // decremento nelems
        nelems--;
    }
}

/* parte che dovrebbe essere nel file mymain.c
*/
// cbCmpFunc() - funzione di comparazione
static int cbCmpFunc(int elem_a, int elem_b, void *fp)
{
    // scrivo risultati parziali in un file
    fprintf(fp, "%d > %d = %d\n", elem_a, elem_b, elem_a > elem_b);

    return elem_a > elem_b;
}

// main
int main(void)
{
    int array[] = {34,12,32,9,10,72,82,23,14,7,94};
    int nelems = sizeof(array) / sizeof(int);
    FILE *fp = fopen("result.txt", "w");

    // eseguo sort array
    mySort(array, nelems, cbCmpFunc, fp);

    // chiudo file
    fclose(fp);

    // stampo risultati
    int i;
    for (i = 0; i < nelems; i++)
        printf("%d - ", array[i]);
    printf("\n");

    // esco
    return 0;
}

Come vedete è molto simile all'esempio dell'altro post, solo che ora, a livello del main(), apriamo un file per registrare dei dati di elaborazione e dobbiamo passare il file descriptor alla mysort(), già che non possiamo certo pensare di scrivere una funzione di libreria che porti schiantato nel codice il nome del file di log: è l'applicazione chiamante che deve passarlo.

E come lo passiamo? È abbastanza semplice: si aggiunge un parametro (del tipo opportuno) alla mysort() e alla callback, e, nella chiamata base (nel main(), nel nostro caso) si passa il valore alla mysort(), che si occuperà i propagarlo fino alla callback, che è l'utilizzatrice del nuovo parametro; la mysort() non lo usa, lo trasporta solamente. Con questo metodo possiamo passare tutti i parametri che vogliano: nell'esempio ne ho aggiunto uno, ma se ne possono aggiungere a piacere.

Ovviamente tutto quanto sopra è valido per funzioni che implementiamo noi: non si può certo pensare di aggiungere parametri a funzioni di libreria di cui non abbiamo il controllo: ad esempio la qsort() ha bisogno solo della callback con due parametri, e così ce la dobbiamo tenere.

Qualcuno si chiederà perché il parametro fp è un void* e non un tipo più specifico (in questo caso un FILE*) : l'ho scritto così per dimostrare che, con questo metodo, si può passare qualsiasi cosa (ad esempio in C++ si usa per passare il pointer this): anzi, ho visto codice in cui si aggiungono dei void* alle callback (in fase di progetto) solo per usi futuri, in maniera di poter scrivere, in seguito, delle callback molto personalizzate senza modificare la funzione base (che, come detto, e solo trasportatrice di questi parametri)

Che ve ne sembra? Si, anche questa volta l'argomento suona un po' lapalissiano, ma, se un giorno vi scontrerete con le callback spero vi torni utile. Io, ad esempio, per mancanza di documentazione e altri motivi contingenti, a suo tempo (molto tempo fa) ho dovuto arrangiarmi da solo leggendo codice scritto da altri, e non so cosa avrei dato per avere a disposizione un esempio semplice semplice come quello che vi ho appena proposto (ma, allora, viviamo in un'epoca fortunata... si, ma solo per gli informatici. E neanche tanto. Ma questa è un altra storia...).

Ciao e al prossimo post.