Il terminale, la console e il linguaggio C

Lo scopo dell’istruzione è quello di trasformare gli specchi in finestre.

Sydney J. Harris

La console testuale, la mitica “finestra nera” per i non addetti ai lavori, è da sempre croce e delizia per noi sviluppatori software. Nella sua apparente semplicità, tale ambiente si mostra amichevole o perfido a seconda della conoscenza che noi abbiamo di lui, della sua struttura interna e dei comandi che accetta. Ho usato volutamente il pronome personale “lui” in quanto noi informatici siamo soliti attribuire una personalità agli oggetti con i quali sistematicamente interagiamo nella nostra vita quotidiana.

Ogni sistema software ha da sempre una interfaccia a caratteri, la cosiddetta shell testuale, che ci permette di interagire con il sistema sottostante: nel mondo Unix-Linux essa prende il nome di terminale mentre nel contesto Windows è chiamata più spesso console o anche cmd.exe, dal nome del file eseguibile che la manda in esecuzione.

In questo breve viaggio cercherò di mostrare come interagire, usando il linguaggio C, con la console in questione per realizzare delle semplici operazioni di spostamento del cursore da un punto ad un altro della finestra. Infatti, una delle difficoltà maggiori che abbiamo nella gestione di tale finestra è la sua assoluta rigidità dovuta al fatto che il prompt dei comandi è apparentemente immutabile nella sua acquisizione di un comando da tastiera e nella relativa restituzione dell’output del comando stresso. Se questa situazione è del tutto scontata e naturale in un contesto classico di gestione testuale lo stesso non vale nel momento in cui vogliamo gestire in maniera un po’ più “grafica” la nostra console.  Mi riferisco qui alla possibilità di realizzare un minimo di interattività all’interno della finestra muovendo, ad esempio, il cursore a piacimento in una specifica posizione al fine di simulare un classico ambiente a menu piuttosto che un rudimentale videogioco pseudo-grafico.

Il terminale e il mondo Unix-like

Nel mondo cosiddetto Unix-like, ovvero nel contesto di derivazione Unix quale Linux e macOS, il nostro terminale può essere gestito al meglio facendo uso della libreria di funzioni ncurses il cui sito ufficiale è:

https://invisible-island.net/ncurses/

Ovviamente ci si dovrà accertare della disponibilità della librerie in questione. A solo titolo di esempio, l’installazione in un sistema Debian-Ubuntu la si realizza con il gestore di pacchetti apt nel seguente modo:

sudo apt-get install libncurses5-dev libncursesw5-dev

Una volta risolti i problemi di installazione si potrà editare il proprio file sorgente con un editor di propria scelta. Io uso per lo più l’editor nano e, solo quando costretto dalle circostanze, il mitico vim.

Un “salve mondo” con ncurses, ovvero il tipico primo programma che si realizza per un qualsiasi ambiente di programmazione potrebbe essere il seguente:

 

#include <ncurses.h>

int main()

{                                                                                                                     

   initscr();

   printw("Salve mondo da ncurses!");

   refresh();

   getch();

   endwin();

   return 0;

}

 

Tale semplicissimo snippet (pezzo di codice sorgente) dovrebbe far comprendere almeno in linea generale la modalità di utilizzo della libreria in questione.

La prima cosa che faccio notare è il fatto che ho inserito il solo include della libreria ncurses.h in quanto la sola riga:

#include <ncurses.h>

Include in automatico altre librerie tra cui anche stdio.h.

La prima istruzione che incontriamo, la chiamata alla funzione initscr() inizializza l’ambiente ncurses, ambiente che viene poi chiuso con la successiva endwin(). Faccio notare che l’istruzione initscr()  non effettua la cancellazione dello schermo ma predispone tutta una serie di strutture dati  per interfacciare ncirses con l’hardware video del sistema su cu è in  esecuzione.

Di seguito incontriamo l’istruzione:

 

printw("Salve mondo da ncurses!");

 

che, senza sorprese predispone la stampa di una stringa di saluto. In realtà, la scrittura avviene preventivamente in uno specifico buffer che verrà poi dirottato in output grazie alla funzione refresh() che aggiornerà il nostro display video. Ci sono poi un altro paio di cose che vale la pena di sottolineare. La prima riguarda l’assoluta necessità di usare l’istruzione getch() per consentire la visualizzazione dell’output a video in quanto, in caso contrario, scomparirebbe immediatamente alla vista riportando la sola visualizzazione del prompt dei comandi. La seconda cosa riguarda il fatto che la funzione getch() effettua una sorta di aggiornamento  implicito e automatico dello schermo e che quindi, teoricamente, in questo caso specifico di esempio minimale anche senza la chiamata della funzione refresh, l’output a video verrebbe comunque mostrato.

Per la compilazione useremo il seguente comando:

 

gcc  mycurse.c -lncurses

 

Attenzione alla necessità di compilare usando l’opzione -lncurses in quanto ncurses non è semplicemente un file di intestazione ma una vera e propria libreria e  quindi -l ne impone il linking. Ovviamente, per lancoare il nostro eseguibile digiteremo il classico ./a.out.

Al solo scopo di far comprendere la semplicità d’uso della libreria vi mostro ora una funzione che consente di spostare il punto di editing, il nostro cursore, in una specifica posizione:

 

move(y,x);

 

dove y è il valore per la riga e quindi, partendo dall’angolo in alto a sinistra, che ha coordinata (0, 0), aumenta verso il basso mentre x è il valore per la colonna che quindi, banalmente, aumenta da sinistra verso destra.

Un’altra funzione semplice e interessante è:

 

mvprintw(y,x,formato,argomenti[...])

 

che consente di stampare una data stringa in una qualsiasi posizione del nostro terminale.

Questo brevissima panoramica sulla libreria ncurses voleva solo sollecitare l’interesse per un sistema software che, se be padroneggiato può dare grandi soddisfazioni come dimostra plasticamente la figura relativa al videogioco Rouge sviluppato appunto sfruttando tale libreria e che ha segnato un’epoca guadagnandosi un posto nella storia dei videogame.

Figura 1 Il videogioco Rouge realizzato con le librerie  ncurses.

 

 

 

 

 

 

 

 

 

Cmd.exe e la console testuale come non l’hai mai vista prima

La libreria ncurses è sicuramente uno strumento formidabile relativo al mondo Unix-like. Tuttavia, può essere interessante capire come gestire la console a caratteri in maniera evoluta anche sul sistema di zio Bill. Per farlo, ovviamente, possiamo sfrutta il WSL,  ovvero il Sottosistema Windows per Linux all’interno di Windows 10, così come usarlo in ambiente di emulazione Cygwin. Volendo potremmo addirittura sfruttare sotto Windows le librerie ncurses con il linguaggio di programmazione Python. Ma a noi piacciono le cose complesse e ardite per cui di seguito vi mostro come realizzare “a mano” qualcosa di simile alle ncurses direttamente sotto Windows. Pronti? Partiamo!

Sappiamo bene che la console cmd.exe è in effetti estremamente rigida ma cercheremo ora di forzarla a essere più duttile rispetto alle nostre necessità e di renderla, in un certo qual modo, “grafica”. Ovviamente, la prima cosa che dobbiamo cercare di fare è quella di poter scrivere un certo simbolo in una posizione qualsiasi della console e non quindi semplicemente sul nostro prompt dei comandi. Questa operazione, non propriamente banale, è possibile grazie alla libreria windows.h ed alla funzione SetConsoleCursorPosition che consente appunto di settare (collocare) il cursore in una data posizione della console. Per rendere il tutto più immediatamente comprensibile vi mostro subito un pezzo di codice minimale che realizza quanto detto.

 

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

void gotoxy(short x, short y);

int main()
{

    gotoxy(10,1);

    printf("X");

     getchar();

     return 0;

}



void gotoxy(short x, short y)
{
    COORD pos ={x,y};

    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}

 

 

Analizziamo quindi il codice precedente, osservando innanzitutto, come già anticipato, la necessità di includere la libreria windows.h. Subito dopo troviamo l’intestazione di una funzione gotoxy che abbiamo scritto con lo specifico scopo di spostare il nostro cursore in una determinata posizione che passeremo come argomento alla funzione stessa. La funzione in questione richiama quindi  al suo interno SetConsoleCursorPosition. Quest’ultima prende in input il riferimento alla finestra in uso e le coordinate  per la nuova posizione del cursore. Per ulteriori dettagli su tale funzione è possibile rifarsi al link:

 

https://docs.microsoft.com/it-it/windows/console/setconsolecursorposition

 

Qui si può facilmente scoprire che le coordinate da passare alla funzione sono la colonna e la riga di una cella del buffer dello schermo. Ovviamente, le coordinate in questione devono trovarsi all’interno dei limiti del buffer dello schermo della console. Nel caso in cui la funzione ha esito negativo verrà restituito il valore zero. Al momento, per una questione di semplicità non effettuiamo uno specifico controllo di errore che comunque dovrebbe essere sempre fatto con l’ausilio della funzione GetLastError.

 

Figura 2 – La console dopo lo spostamento del cursore

 

 

 

 

 

 

 

Come si intuisce, la coordinata 0, 0 è nell’angolo in  alto a sinistra e quindi è come se ci trovassimo in un piano cartesiano con x che cresce verso sinistra e y che cresce verso il basso.

Per rendere immediatamente interessante quello che stiamo facendo, possiamo immaginare di far muovere il nostro cursore sulla console usando i mitici e classici tasti freccia. Per farlo dobbiamo innanzitutto poter leggere i tasti della tastiera e quindi solo dopo spostare il cursore in maniera consistente. Per leggere la tastiera possiamo sfruttare le funzioni kbhit e getch.

È importante precisare che entrambe le funzioni in questione non sono il massimo della standardizzazione e che quindi devono essere usate consapevoli del fatto che sarà necessario verificare gli eventuali vincoli delle specifiche piattaforme. In ogni caso, kbhit legge la tastiera e restituisce un valore diverso da zero in caso di pressione di un tasto mentre getch restituisce il valore corrispondente al tasto digitato. Vediamo allora il codice che ci permette di leggere la digitazione dei vari tasti e interrompere l’esecuzione in caso di digitazione del tasto ESC, escape, che corrisponde al valore 27.

 

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <conio.h>

int main()
{
    printf("Premere ESC per interrompere.\n");

    int ch;

    while (TRUE)

    {

          if ( kbhit() )

          {

            //

            ch = getch();

            if ((ch == 27))

            {

            break;

             }

            printf("Tasto: %c numero: %d\n", ch, ch);

        }

    }

   
    printf("Programma terminato!");

    getchar();

    return 0;

}

 

Il programmino in questione presenta, nel più classico dei modi,  il main loop, ovvero il ciclo principale che si imposta su pressoché qualsiasi  software e che consente di iterare le varie operazioni fin quando non se ne richiede in maniera forzata l’uscita. Il codice stesso dovrebbe essere di immediata comprensione: il ciclo itera teoricamente all’infinito (while (TRUE)) e terminerà con un break non momento in cui il tasto digitato è appunto ESC.

 

Da notare che ho usato la funzione getch e non getchar in modo da non dover attendere la pressione del tasto Invio per confermare la digitazione del singolo tasto.

 

Figura 3- Il programma per la cattura dei valori dei tasti.

 

 

Muoviamo il cursore nella console

A questo punto, maturate le competenze per spostare in una certa posizione il nostro cursore e capito come possiamo intercettare i tasti, possiamo immaginare di muovere il nostro cursore nel punto in cui vogliamo tramite specifici tasti. Per semplificare il codice evitiamo di usare i tasti freccia. Infatti, la pressione dei tasti freccia non è particolarmente standard e tra l’altro restituisce 2 differenti valori piuttosto che uno solo, così come per gli altri tasti normali. In ogni caso, non è un gran problema in quanto possiamo immaginare di usare, al posto dei tasti freccia, una combinazione classica nota come WASD. Si tratta dei tasti che hanno appunto queste quattro lettere e che vengono usate nei giochi per sostituire le frecce stesse in quanto questi hanno una organizzazione a T rovesciata del tutto simile.

 

 

Figura 4 – Il confronto tra i tasti freccia  e la combinazione WASD

 

 

 

Come si intuisce anche dalla figura, i tasti A e D corrispondono ad avanti e indietro mentre W e S ai tasti sopra e sotto. Vediamo allora come leggere questi tasti e spostare il cursore in logica  conseguenza.

Servendoci del precedente codice scopriamo anche immediatamente quali sono i valori corrispondenti ai tasti di nostro interesse e che vi riporto in figura.

 

Figura 5 – I codici dei tasti della combinazione WASD.

 

 

 

 

 

 

 

 

 

Per evitare problemi dovremo ovviamente intercettare sia il codice per le lettere minuscole sia quelle per le maiuscole. Di seguito vi riporto una possibile e semplice implementazione di quanto ci siamo proposti di fare.

 

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <conio.h>


#define UP 1
#define DOWN 2
#define LEFT 3
#define RIGHT 4

#define MAX_X 80
#define MAX_Y 25

void gotoxy(short x, short y);

short pos_x, pos_y;

int main()
{
   short pos_x=0;

   short pos_y=0;
   
   gotoxy(0, MAX_Y+1);
   printf("Premere ESC per interrompere.\n");
   gotoxy(0,0);

   int ch;

   while (TRUE)
   {

   if ( kbhit() )
   {
   ch = getch();

   if ((ch == 27))
   {
       break;
   }

   else
   {

   switch(read_key(ch))
   { 
   case UP:

   pos_y--;

   break;

   case DOWN:

   pos_y++;

   break;

   case LEFT:

   pos_x--;

   break;

   case RIGHT:

   pos_x++;

   break;

   }

   //evito che valori diventino negativi o superiori al max consentito
   if (pos_x <0) pos_x=0;
   if (pos_y <0) pos_y=0;

   if (pos_x > MAX_X) pos_x=MAX_X;
   if (pos_y > MAX_Y) pos_y=MAX_Y;

   gotoxy(pos_x, pos_y);

   printf("X");

   }




   }

   }




   printf("Game over ;) ");

   getchar();

   return 0;

}




//

int read_key(int ch)

{

int direction=0;

if (ch==119 || ch == 87) //tasto W - sopra

{

direction=UP;

}

else if (ch==97 || ch == 65) //tasto A - sinistra

{

direction=LEFT;

}

else if (ch==115 || ch == 83) //tasto S - sotto

{

direction=DOWN;

}

else if (ch==100 || ch == 68) //tasto D - destra

{

direction=RIGHT;

}

return direction;

}


void gotoxy(short x, short y)
{
COORD pos ={x,y};
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}


Cercherò ora di commentare gli elementi più salienti di quanto proposto. Innanzitutto, definiamo alcune costanti utile per semplificare la leggibilità del codice stesso, iniziando con quelle utili a definire la direzione per i nostri tasti.

 

#define UP 1

#define DOWN 2

#define LEFT 3

#define RIGHT 4

 

Successivamente definiamo il limiti del nostro campo di gioco con le seguenti:

 

#define MAX_X 80
#define MAX_Y 25

 

Ovvero, in questo caso, 25 righe per 80 colonne. Per gestire la posizione corrente usiamo, invece, le seguenti variabili globali:

 

short pos_x, pos_y;

 

Detto questo, il codice è abbastanza semplice da interpretare considerando quanto già visto in precedenza. Cicliamo, dunque, fino alla pressione del tasto escape e con il seguente switch effettuiamo, modificando le variabili pos_x e pos_y  il movimento corrispondente alla scelta effettuata:

 

switch(read_key(ch))
{
   case UP:
      pos_y--;
      break;

    case DOWN:
         pos_y++;
         break;
 
    case LEFT:
        pos_x--;
        break;

    case RIGHT:
    pos_x++;
    break;
}

Come si può facilmente comprende abbiamo creato una specifica funzione read_key per capire in quale direzione andare in quanto la funzione in questione legge i codici dei tasti e restituisce la costante della direzione da prendere.

Infine, vale forse la pena di notare le righe di codice:

 

gotoxy(0, MAX_Y+1);
printf("Premere ESC per interrompere.\n");
gotoxy(0,0);

 

che rappresentano, a livello minimale, un modo per rendere l’interfaccia più pulita spostando le istruzioni per l’uscita dal gioco in una zona esterna al nostro campo di azione.

Ovviamente, il tutto è assolutamente embrionale e vuole solo dare indicazioni di massima su come organizzare un tipico gioco. Possiamo infatti immaginare, a solo titolo di esempio, come potremmo generare in una posizione casuale del campo di gioco un qualsiasi elemento e poi far raggiungere al nostro giocatore quella posizione, ad esempio, calcolando quanto tempo ci mette per raggiungerla e restituire un punteggio in base alla sua velocità di azione. Come al solito, l’unico limite è la fantasia!

 

Carlo A. Mazzone

 

Supportaci condividendo sui social il nostro articolo!

La struttura dati Union del C: a cosa serve realmente?

“Non nei numeri ma nell’unità sta la nostra grande forza.”

Thomas Paine

 

La struttura dati union del linguaggio C è di sicuro particolare e il suo  reale e concreto utilizzo può essere a volte sfuggente. Come dovremmo sapere, una union è del tutto simile ad una struct con l’unica  apparente differenza che di una union possiamo usare, in un dato momento, uno ed uno solo dei suoi membri. Infatti, l’occupazione di spazio di una union è relativa al massimo dello spazio occupato dal più grande dei suoi membri. Per averne una prova facciamo un esempio supponendo di avere due strutture dati: una struct e una union aventi entrambe tre membri di cui un intero, un float e un double:

#include <stdio.h>
#include <stdlib.h>

struct s
{
   int i;
   float f;
   double d;
};

union u
{
   int i;
   float f;
   double d;
};


int main(int argc, char *argv[])
{
   struct s myStruct;
   union u myUnion;

   printf("\nIntero byte: %d", sizeof(myStruct.i));
   printf("\nFloat byte: %d", sizeof(myStruct.f));
   printf("\nDouble byte: %d", sizeof(myStruct.d));

   printf("\nLa struct occupa %d byte.", sizeof(myStruct));
   printf("\nLa union occupa %d byte.", sizeof(myUnion));

   return 0;
}

 

In relazione al nostro test, prima stampiamo l’occupazione in byte dei singoli membri e poi l’occupazione delle singole strutture dati. Otterremo quanto presentato in Figura.

Struct union

 

 

 

 

 

 

Figura: L’occupazione in byte di struct e union.

Come si evince da una immediata osservazione, la struct occupa ben 16 byte sommando, infatti, i 4 dell’intero, i 4 del float e gli 8 byte del double. Al contrario, la union occupa solo 8 byte, ovvero la dimensione del suo membro massimo, il double.

Se questo è polimorfismo

Resta comunque la domanda di fondo: ma a cosa serve una union? Ebbene, il suo scopo è di norma quello di gestire in un’unica struttura dati valori di tipo differente che riguardano una stessa variabile. In un certo senso è un tentativo del C di essere polimorfo (cosa che il C++ fa in maniera assolutamente naturale). In somma sintesi, per polimorfismo si intende la possibilità di gestire con una stessa variabile differenti tipologia di dato (un intero, un float, …) a seconda delle circostanze di nostro interesse. Vediamo allora il seguente codice in cui immaginiamo una union per gestire una sorta di variant ovvero una variabili che può assumere differenti valori a seconda di una specifica assegnazione:

 

#include <stdio.h>
#include <stdlib.h>

enum Type {INTEGER, FLOATS, DOUBLE};

union u
{
   int i;
   float f;
   double d;
};

void stampa(union u *, int);

int main(int argc, char *argv[])
{
   union u myVar;
   int v_type; //il tipo attualmente utilizzato

   v_type = INTEGER;
   myVar.i = 12.66;
   stampa(&myVar, v_type);

   v_type = FLOATS;
   myVar.f = 12.66;
   stampa(&myVar, v_type);

   v_type = DOUBLE;
   myVar.d = 12.66;
   stampa(&myVar, v_type);
  
   return 0;
}

void stampa(union u *u, int v_type)
{
   switch(v_type)
   {
      case INTEGER:
      printf("Valore intero: %d\n", u->i);
      break;

      case FLOATS:
      printf("Valore float: %f\n", u->f);
      break;

      case DOUBLE:
      printf("Valore double: %lf\n", u->d);
      break;
   }
}

 

Vediamo allora di interpretare il codice in questione. Innanzitutto, definiamo la nostra union con 3 differenti membri: un intero, un float e un double.

 

union u
{
   int i;
   float f;
   double d;
};

 

Per gestire al meglio le tre differenti situazione utilizziamo una enumerazione:

 

enum Type {INTEGER, FLOATS, DOUBLE};

 

mentre per controllare quale tipo di dato andiamo di volta in volta ad utilizzare usiamo la variabile

 

int v_type;

 

Infine, per simulare un caso reale di utilizzo sfruttiamo uno switch all’interno di una funzione di stampa:

 

switch(v_type)
{
   case INTEGER:
   printf("Valore intero: %d\n", u->i);
   break;

   case FLOATS:
   printf("Valore float: %f\n", u->f);
   break;

   case DOUBLE:
   printf("Valore double: %lf\n", u->d);
   break;
}

 

Struct e union: quando l’unione fa la forza

In alcune situazioni è possibile preferire un approccio in cui l’informazione relativa al tipo di dato che vogliamo utilizzare è direttamente e strettamente collegato al dato stesso. In tali contesti è possibile integrare una union all’interno di una struct così come vi mostro di seguito:

 

#include <stdio.h>
#include <stdlib.h>

enum Type {INTEGER, FLOATS, DOUBLE};

struct mydata
{
   int which_one;
   union _value
   {
      int i;
      float f;
      double d;
   } value;
};

void stampa(struct mydata *);

int main(int argc, char *argv[])
{
   struct mydata x;

   x.value.i =12;
   x.which_one = INTEGER;
   stampa(&x);

   x.value.f =10.66;
   x.which_one = FLOATS;
   stampa(&x);

   return 0;
}


void stampa(struct mydata *x)
{
   switch(x->which_one)
   {
      case INTEGER:
      printf("Valore intero: %d\n", x->value.i);
      break;

      case FLOATS:
      printf("Valore float: %f\n", x->value.f);
      break;

      case DOUBLE:
      printf("Valore double: %lf\n", x->value.d);
      break;
   }
}

 

Come si può scoprire dopo un primo attento esame, il punto nodale della nostra organizzazione è data dalla struct seguente:

 

struct mydata
{
   int which_one;
   union _value
   {
      int i;
      float f;
      double d;
   } value;
};

 

La struct in questione ha innanzitutto il membro which_one che serve per tener traccia del tipo di variabile che vogliamo gestire. Anche in questo caso, così come nell’esempio precedente, usiamo la seguente enumerazione per tracciare in modo semplice il tipo di dati utilizzato in un dato momento:

 

enum Type {INTEGER, FLOATS, DOUBLE};

 

All’interno della struct abbiamo invece la nostra union con i vari tipi di variabili:

 

union _value
{
   int i;
   float f;
   double d;
} value;

 

Per il resto il codice dovrebbe essere di relativa semplice interpretazione.

 

Carlo A. Mazzone

Supportaci condividendo sui social il nostro articolo!

Un assaggio di STL con i vettori

“Nell’insegnamento non si può vedere il frutto di una giornata di lavoro. È invisibile e rimane così, forse per venti anni.”
Jacques Barzun

Si dice che i programmatori siano pigri. Di sicuro, se qualcuno ha già lavorato per noi, non si vede il motivo per rifare lo stesso lavoro una seconda volta. Uno di questi “qualcuno”, nel contesto del C++, si chiama Alexander Stepanov, il quale è il principale artefice di una specifica libreria di strumenti realizzata appositamente nella visione della programmazione generica: la Standard Template Library, meglio conosciuta con l’acronimo di STL.

Alexander Stepanov
Alexander Alexandrovich Stepanov, il principale artefice della Libreria STL.

 

Volendo schematizzare al massimo la libreria STL possiamo vederla come composta di tre elementi:

Contenitori
Iteratori
Algoritmi

I contenitori, detti anche in modalità anglosassone containers, sono i veri e propri aggregati di dati. Si tratta quindi di collezioni organizzate di elementi. A scopo di esempio pensate alla struttura dati coda.
Gli iteratori sono degli speciali puntatori che consentono di navigare, cioè di muoversi, all’interno delle strutture dati.
Gli algoritmi sono delle procedure preconfezionate per risolvere i classici problemi che si presentano in relazione alle strutture dati: ordinamento di dati, ricerca di specifici valori, ecc.
Per cercare di essere minimamente concreti di seguito vi propongo un codice minimale relativo all’uso dei vettori. Sebbene il termine vettore venga spesso considerato come sinonimo di array, un vettore (vector) è una struttura dati di tipo parametrico che può essere lavorata in maniera dinamica in quanto, contrariamente ad un array che viene gestito nell’area di memoria stack, esso vive nella sezione di memoria heap.

 

#include <vector>
using namespace std; //oppure devi usare istruzioni del tipo std::vector<int> v;

int main(int argc, char** argv)
{
   printf("I vettori (vectors) non sono array ;)\n\n");
   //Dichiaro un vector (le parentesi angolari sono giustificate dal fatto che si tratta di una classe template)
   //Un vector consente la gestione di memoria contigua permettendo di riferirsi ad essa in un modo del tipo: v[0], v[1]...
   //creiamo un vector per 10 interi (vengono inizializzati a 0)

   int n = 10;

   vector<int> array(n);

   //verifichiamo il suo contenuto
   printf("Vector inizializzato:\n");
   for(int i=0; i<n; i++)
   {
      printf("%d ", array[i]);
   }
   printf("\n\n");

   // valorizziamo il vector con interi da 1 a 10
   int x =1;
   for(int i=0; i<n; i++)
   {
      array[i] = x++;
   }

   //verifichiamo il suo contenuto
   printf("Vector valorizzato con interi da 1 a 10:\n");
   for(int i=0; i<n; i++)
   {
      printf("%d ", array[i]);
   }
   printf("\n\n");

   //inserisco alla fine dell'array un nuovo elemento intero con valore 66
   array.push_back(66);

   //verifichiamo il suo contenuto
   //Usiamo ora la il metodo size() per determinare la nuova dimensione del vector
   printf("Contenuto vector dopo inserimento di un elemento in coda:\n");
   for(int i=0; i<array.size(); i++)
   {
      printf("%d ", array[i]);
   }
   printf("\n\n");

   //ora voglio ridimensionare il vector eliminando così il valore inserito
   //determino quindi l'attuale dimensione del vector
   int temp=array.size();

   //ridimensiono il vector alla dimensione attuale meno 1
   array.resize(temp-1);

   //verifichiamo il contenuto del vettore
   printf("Vector dopo il resize:\n");
   for(int i=0; i<array.size(); i++)
   {
      printf("%d ", array[i]);
   }
   printf("\n\n");

   //Un altro modo per eliminare l'ultimo elemento del vettore
   array.pop_back();
   printf("Vector dopo eliminazione elemento in coda:\n");
   for(int i=0; i<array.size(); i++)
   {
      printf("%d ", array[i]);
   }
   printf("\n");

   return 0;
}


Di seguito l’output del codice in questione:

 

Ovviamente, si tratta di un codice del tutto minimale che ha il solo scopo di far comprendere le potenzialità dei vettori del C++. Nello specifico, dichiariamo innanzitutto il nostro vector affinché contenga 10 elementi interi

int n = 10;
vector<int> array(n);

La prima cosa degna di interesse da notare è poi data dal fatto che inseriamo in coda all’array, in manoera assolutamente dinamica, un nuovo elemento, usando la seguente sintassi.

 

array.push_back(66);

 

Faccio notare, incidentalmente, la classica notazione in stile programmazione orientata agli oggetti dove push_back è il metodo dell’oggetto array.

Ancora di grande interesse è l’effettuazione del ridimensionamento del vettore con l’istruzione resize.

Infine, vi mostro come sia possibile effettuare una sorta di nuovo ridimensionamento dell’array buttando via l’ultimo elemento con l’istruzione:

 

array.pop_back();

 

Ovviamente, come detto, il precedente è un esempio assolutamente minimale che vuole solo sollecitare alla scoperta di modalità differenti per la gestione delle strutture dati.

 

Carlo A. Mazzone

Supportaci condividendo sui social il nostro articolo!

Il C, la console testuale e i colori

Gli artisti possono colorare il cielo di rosso perché sanno che è blu. Quelli di noi che non sono artisti devono colorare le cose come realmente sono o la gente penserebbe che sono stupidi.

 Jules Feiffer

La console testuale, la nostra fidata cmd.exe o il nostro terminale Linux o macOS, sono notoriamente dei mondi spartani e minimalisti. Tuttavia, anche in questi contesti un tocco di colore può aiutare a rendere l’output maggiormente intuitivo e piacevole da gestire. Il problema è che per realizzare anche il più piccolo inserimento di colori, utilizzando il nostro codice C, dobbiamo faticare non poco a causa della eterogeneità dei vari sistemi operativi e ambienti di sviluppo.

Le sequenze di escape

Un primo approccio che possiamo provare a sfruttare è quello di pilotare il nostro terminale attraverso specifiche sequenze di comandi note come sequenze di escape. Più precisamente, si tratta di uno standard ANSI (ovvero dell’American National Standards Institute) che consente di inviare al terminale una serie di comandi, di norma utilizzando il carattere Esc seguito dalla parentesi quadra ‘[‘, con i quali controllare non solo i colori ma anche la posizione del cursore sullo schermo. Storicamente, si tratta di uno stratagemma molto datato che fu introdotto addirittura a partire dagli anni 70 e particolarmente 80 del secolo scorso per sostituire il vecchio metodo che consisteva nell’utilizzare comandi legati all’hardware dei singoli e specifici dispositivi. Nonostante siano passati moltissimi anni, questo metodo è ancora utilizzabile con una certa efficienza grazie al fatto che è possibile inviare comandi al terminale utilizzando caratteri ASCII standard.

Il terminale VT 100 della Digital

Figura 1  –  Il terminale VT 100 della Digital (https://commons.wikimedia.org/wiki/File:DEC_VT100_terminal.jpg).

Può essere interessante sapere che uno dei primi e più popolari terminali a supportare questo nuovo standard fu il VT100 della Digital. Personalmente, lo ricordo ancora con un po’ di malinconia in quanto questo fu il primo terminale con il quale mi imbattei all’Università degli Studi di Salerno nella seconda metà degli anni 80.

Unix sì, Windows “nì”

Il primo problema che riscontriamo con l’utilizzo delle sequenze di escape è che esse sono supportate in maniera pressoché nativa solo in ambiente Unix like e non sotto Windows. Cominciamo comunque a verificarne il loro utilizzo almeno sotto il contesto Linux per prendere confidenza con questo strumento.

Un primo stralcio di codice minimale con il quale fare una veloce prova può essere il seguente:

 

#include <stdio.h>

int main ()
{
   printf("\x1b[32mUn mondo a colori\n");
}

 

Come si intuisce il contenuto da analizzare è il seguente:

 

"\x1b[32mUn mondo a colori\n"

 

In tale contenuto riconosciamo facilmente che prima della stringa “Un mondo a colori” è presente una arcana sequenza di simboli:

 

"\x1b[32m"

 

Ebbene, in realtà non è nulla di particolarmente complesso. Infatti, come già detto, le sequenze di escape iniziano con il codice del carattere Esc seguito da una parentesi quadra aperta. Tale carattere di escape corrisponde al valore decimale 27 che, in esadecimale, corrisponde a 1b ed è proprio tale valore che inviamo al terminale usando la sequenza di due simboli “\x”.

In successione troviamo il valore 32 che corrisponde al colore verde e infine la lettera m che serve a segnalare al terminale che stiamo inviando un comando di gestione di tipo grafico.

Se compiliamo il file sotto Windows e proviamo a lanciarlo nella console cmd.exe otterremo un deludente risultato simile a quanto riportato in figura:

Figura 2 –  L’esecuzione con l’invio dei codici di escape con la cmd.exe.

Come si può osservare, in output troviamo in maniera grezza parte della sequenza inviata senza però nessuna modifica di colore. Al contrario, se lanciamo lo stesso eseguibile in un contesto Unix like, ad esempio nella finestra Bash del sottosistema Windows per Linux (configurabile sotto Windows 10) otterremo la corretta interpretazione del comando grafico, così come mostrato in figura:

Figura 3 –  L’esecuzione con l’invio dei codici di escape nel sottosistema Windows per Linux.

La cosa interessante da notare è che una volta impartito un certo comando di impostazione di un dato colore, tale setting rimane invariato finché non decidiamo di inviare il codice per un colore diverso oppure per resettare il sistema al bianco e nero inviando il valore zero. Di seguito, vi riporto del codice che dovrebbe chiarire il meccanismo in questione:

 

#include <stdio.h>

int main ()
{
   printf("\x1b[32mUn mondo a colori\n");
   printf("... tutto verde\n");
   printf("\x1b[0m");
   printf("ma fino a un certo punto.\n");
}

 

In output otterremo, come mostrato in Figura, che le prime due righe risulteranno in verde mentre la riga di testo finale, “ma fino a un certo punto.”, verrà mostrata in bianco su nero a causa del comando di reset:

 

"\x1b[0m"

 

dove riconosciamo ancora la sequenza \x1b che invia in esadecimale in carattere Esc, poi la parentesi quadra aperta e quindi il valore zero per il reset seguito dalla lettera m che segnala, come già detto, l’invio di un comando di tipo grafico.

Figura 4 –  L’esecuzione con l’invio dei codici per il reset delle impostazioni di colore predefinite.

 

Vediamo ora di scoprire l’elenco dei colori che possiamo gestire. Ebbene, i colori di base solo sostanzialmente solo otto ed i loro codici vanno da 30 a 37. Tuttavia, gli stessi otto colori possono essere utilizzati per cambiare il colore di sfondo della console con dei codici che vanno da 40 a 47. Di seguito vi propongo uno schema riassuntivo.

 

COLORE CODICE TESTO CODICE SFONDO
Nero 30 40
Rosso 31 41
Verde 32 42
Giallo 33 43
Blu 34 44
Magenta 35 45
Azzurro 36 46
Bianco 37 47

 

 

Ovviamente, volendo cambiare contemporaneamente il colore del testo e quello dello sfondo dobbiamo inviare due specifici e differenti comandi. Ad esempio, volendo impostare il testo nero su sfondo bianco dovremo inviare, rispettivamente, i valori 30 e 47. Di seguito un semplice esempio:

 

#include <stdio.h>

int main ()
{
   printf("\x1b[30m");
   printf("\x1b[47m");
   printf("Un mondo al contrario.\n");
   printf("\x1b[0m");
}

 

Incidentalmente, vi faccio notare come sarebbe possibile inserire i due comandi in un’unica stringa di testo accodando le due sequenze di escape scrivendo:

 

printf("\x1b[30m\x1b[47m");

 

Appurato che gli ambienti di derivazione Unix gestiscono senza problemi le sequenze di escape vediamo ora cosa ci riserva il mondo Windows. Purtroppo la possibilità di usare in maniera quasi naturale tali sequenze è limitata alle sole versioni di Windows 10.

 

NOTA. Vedi anche https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences.

 

Vediamo allora un programmino minimale che imposta l’ambiente al fine di utilizzare le sequenze in questione:

 

#include <stdio.h>
#include <windows.h>

#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING  0x0004
#endif

int main()
{
   //Catturo l'handle del dispositivo standard di output
   HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

   //uso tale handle per ottenere l'attuale modalità della console
   DWORD dwMode = GetConsoleMode(hOut, &dwMode);

   //Abilito le sequenze di escape mettendo in OR alla modalità corrente
   //del buffer dello schermo della console il valore ENABLE_VIRTUAL_TERMINAL_PROCESSING
   dwMode = dwMode | ENABLE_VIRTUAL_TERMINAL_PROCESSING;

   //Imposto la nuova modalità con la funzione  SetConsoleMode
   SetConsoleMode(hOut, dwMode);

   printf("\x1b[32mUn mondo a colori\n");
   printf("... tutto verde\n");
   printf("\x1b[0m");
   printf("ma fino a un certo punto.\n");

   return 0;
}

 

 

Come detto, l’esecuzione di tale codice su sistemi antecedenti ad un aggiornato Windows 10 fallirà miseramente.

Proviamo allora ad analizzare il codice in questione partendo dalla necessità di definire la costante ENABLE_VIRTUAL_TERMINAL_PROCESSING. Usiamo quindi le cosiddette include guard #ifndef per evitare la eventuale redefinizione della costante in questione che viene richiesta dal sistema per poter gestire in maniera corretta le sequenze di escape.

Per il resto, il commento nel codice dovrebbe essere sufficiente a comprendere il meccanismo di funzionamento del sistema in questione. Quello che facciamo è innanzitutto prelevare il riferimento (noto come handle) del dispositivo di output, ovvero della console, con l’istruzione:

 

HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

 

Usiamo allora questo handle per poter leggere l’attuale impostazione della console:

 

DWORD dwMode = GetConsoleMode(hOut, &dwMode);

 

Incidentalmente, segnalo che un dword, abbreviazione di “double word,” è un tipo di dati specifico di Windows. Tale tipo è definito nel file windows.h che abbiamo incluso in testa al nostro codice. Un dword è un intero senza segno a 32 bit e può quindi contenere un valore che va da 0 a 4.294.967.295.

 

Successivamente, aggiungiamo, tramite l’operatore OR la nuova impostazione al contesto corrente, usando la funzione SetConsoleMode:

 

dwMode = dwMode | ENABLE_VIRTUAL_TERMINAL_PROCESSING;
SetConsoleMode(hOut, dwMode);

 

A questo punto, il gioco è fatto e possiamo inviare le sequenze di escape di nostro interesse verso il dispositivo console.

 

La gestione degli errori

Ovviamente, per rendere il codice più robusto dovremmo preoccuparci di controllare con apposito trapping di errore se le operazioni richieste vanno a buon fine. A tal fine, vi segnalo come si possa usare la funzione GetLastError() per catturare l’eventuale errore generato dalle varie chiamate viste in precedenza. Per essere più chiaro, vi propongo la riscrittura del codice precedente con l’inserimento di vari check per testare se le operazioni richieste vanno o meno a buon fine.

 

#include <stdio.h>
#include <windows.h>

#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING  0x0004
#endif

int main()
{
   //Catturo l'handle del dispositivo standard di output
   HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

   if (hOut == INVALID_HANDLE_VALUE)
   {
      printf("Funzione GetStdHandle - Errore: %d\n", GetLastError());
   }

   //uso tale handle per ottenere l'attuale modalità della console
   DWORD dwMode = 0;

   if (!GetConsoleMode(hOut, &dwMode))
   {
      printf("Funzione GetConsoleMode - Errore: %d\n", GetLastError());
   }

   //Abilito le sequenze di escape mettendo in OR alla modalità corrente
   //del buffer dello schermo della console il valore ENABLE_VIRTUAL_TERMINAL_PROCESSING
   dwMode = dwMode | ENABLE_VIRTUAL_TERMINAL_PROCESSING;

   //Imposto la nuova modalità con la funzione  SetConsoleMode
   if (!SetConsoleMode(hOut, dwMode))
   {
      printf("Funzione SetConsoleMode - Errore: %d\n", GetLastError());
   }

   printf("\x1b[32mUn mondo a colori\n");
   printf("... tutto verde\n");
   printf("\x1b[0m");
   printf("ma fino a un certo punto.\n");

   return 0;
}

 

Come si vede, effettuiamo il controllo in relazione alla chiamate delle varie funzioni e, nel caso di effettivo errore, stampiamo con GetLastError lo specifico numero di errore. Ovviamente, per verificare sul campo tali situazioni dobbiamo porci in un contesto che generi effettivamente un errore. In figura vi mostro quello che può succedere in ambiente Windows 7 che, come detto, non consente l’uso delle sequenze di escape.

Figura 5  –  La generazione e il relativo trapping di un errore con le sequenze di escape sotto Windows 7.

Come si vede dalla figura in questione, l’errore generato è il numero 87. Spulciando la documentazione Microsoft, ad esempio all’URL https://docs.microsoft.com/en-us/windows/win32/debug/system-error-codes–0-499-, si scopre che tale numero corrisponde all’errore “The parameter is incorrect.”. In ogni caso, può essere utile sapere che è possibile rendere la gestione degli errori ancora più espressiva utilizzando la funzione FormatMessage per farsi restituire la specifica stringa descrittiva dello specifico errore.

Su Windows usiamo le API

Una valida alternativa su Windows per controllare i colori della console può essere quella di sfruttare una funzione dell’API di Windows nota come SetConsoleTextAttribute. Di seguito vi mostro la sua struttura e modalità di utilizzo.

Il suo prototipo è:

 

BOOL SetConsoleTextAttribute(
HANDLE hConsoleOutput, // handle del buffer dello schermo della console
WORD wAttributes  // colori per il testo e lo sfondo
);

 

Per rendere immediatamente comprensibile il suo funzionamento vi mostro subito un semplice esempio:

 

#include <stdio.h>
#include <windows.h>

int main() 
{
   HANDLE output = GetStdHandle(STD_OUTPUT_HANDLE);
   
   printf("Questo e' il colore di default\n");

   SetConsoleTextAttribute(output, FOREGROUND_RED|FOREGROUND_INTENSITY);
   printf("Il colore rosso e' proprio bello\n");

   SetConsoleTextAttribute(output, FOREGROUND_BLUE|FOREGROUND_INTENSITY);
   printf("ma anche il blu non e' male\n");
  
   return 0;
}

 

La prima cosa che possiamo notare è l’include relativo al file windows.h. Subito dopo, con la riga:

 

HANDLE output = GetStdHandle(STD_OUTPUT_HANDLE);

 

otteniamo un handle per il buffer dello schermo. Usiamo tale handle come primo argomento della funzione SetConsoleTextAttribute mentre come secondo argomento impostiamo, in due momenti diversi, due differenti colori con le costanti FOREGROUND_RED e FOREGROUND_BLUE. Banalmente si tratta dei colori rosso e blu. Vi faccio notare come si possa accodare, con l’operatore OR, rappresentato dal simbolo “|” (noto come pipe), un ulteriore attributo rappresentato dalla costante FOREGROUND_INTENSITY. Tale costante serve per far sì che il colore appena selezionato sia visualizzato con una maggiore luminosità.

Ovviamente, i colori disponibili sono diversi. Di seguito un estratto riassuntivo:

 

COLORE TESTO SFONDO
Blu FOREGROUND_BLUE BACKGROUND_BLUE
Verde FOREGROUND_GREEN BACKGROUND_GREEN
Rosso FOREGROUND_RED BACKGROUND_RED
Intensificazione del colore FOREGROUND_INTENSITY BACKGROUND_INTENSITY

 

 

 

NOTA. Per ulteriori informazioni sui buffer della console https://docs.microsoft.com/en-us/windows/console/console-screen-buffers.

 

Un altro elemento interessante da analizzare è dato dal fatto che le precedenti costanti di colore possono essere combinate, con l’operatore OR, non solo con la costante per esaltare la luminosità del colore stesso ma anche con altre costanti di colore per ottenere varie e differenti combinazioni. Ad esempio, la combinazione:

 

BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED

 

produrrà uno sfondo bianco che potrà essere esaltato in intensità accodando la costante BACKGROUND_INTENSITY e scrivendo quindi un comando del tipo:

 

SetConsoleTextAttribute(output, BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY);

 

Carlo A. Mazzone

Supportaci condividendo sui social il nostro articolo!

scanf e getchar: problema di input di dati per mescolanza di metodi diversi

Anche se si tratta di un problema abbastanza banale, ho notato che spesso si incespica in errori dovuti alla differente natura delle istruzioni di input del C, scanf e getchar, quando queste sono accodate l’una dopo l’altra per prelevare determinati valori inseriti dall’utente. Il problema è dato dal fatto che dopo una scanf rimane nel buffer della tastiera il  carattere di new line (nuova linea), ovvero, più semplicemente, la pressione del tasto “invio” stesso. Tale invio forza in automatico una “digitazione fantasma” nella eventuale successiva istruzione getchar.

Il piccolo programmino di seguito dovrebbe chiarire il problema e presentare la possibile soluzione:

 

 

 

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char argv[])
{
   printf("INPUT DA ESAURIMENTO\n");
   char ch1, ch2;

   printf("Inserisci il primo carattere: ");
   scanf("%c", &ch1);

   printf("Inserisci il secondo carattere: ");
   ch2 = getchar();

   printf("ch1=%c, Valore ASCII = %d\n", ch1, ch1);
   printf("ch2=%c, Valore ASCII = %d\n", ch2, ch2);

   printf("RIPROVA, SARAI PIU' FORTUNATO ;)\n");
   printf("Inserisci il primo carattere: ");
   scanf("%c", &ch1);
   fflush(stdin);

   printf("Inserisci il secondo carattere: ");
   ch2 = getchar();
   printf("ch1=%c, Valore ASCII = %d\n", ch1, ch1);
   printf("ch2=%c, Valore ASCII = %d\n", ch2, ch2);

   return 0;
}

 

Come si può vedere, il codice prima simula la situazione di errore e poi ci mette una pezza. Ci sono due modi principali per farlo.

Il primo è di usare la funzione

fflush(stdin);

che provvede a svuotare il buffer in questione, subito dopo la scanf e prima della getchar. Il problema che potremmo avere con tale funzione è che essa non è propriamente standard.

L’alternativa è di usare, al suo posto,  la riga di codice:

while ( getchar() != '\n' );

che cicla fino a beccare, e mandare ramengo 😉 il newline.

Per rendere ancora più interessante l’esempio stampiamo anche il codice ASCII dei caratteri inseriti. Nella prima parte dell’esecuzione si può allora toccare con mano la problematica appena illustrata osservando che il carattere ch2 ha come codice ASCII il valore 10 che corrisponde proprio al LF (Line Feed – https://it.wikipedia.org/wiki/Ritorno_a_capo) .

Carlo A. Mazzone

Supportaci condividendo sui social il nostro articolo!

Il successo di un tipo di dati: il casting delle variabili in C

di Carlo A. Mazzone

Il nome dell’articolo potrebbe suggerire un qualcosa collegato al mondo dello spettacolo: niente di più lontano dalla verità. Il casting, nel contesto informatico, non ha assolutamente a che fare con la selezione di un certo sviluppatore come attore in un qualche film ma piuttosto con l’attribuzione del tipo di dati più adatto ad una data variabile per una determinata circostanza implementativa.

Inizio con una semplice constatazione: talvolta il risultato di certe operazioni tra tipi di dati può dare risultati del tutto inaspettati. Ma andiamo con ordine ponendoci questa domanda: cosa accade quando assegno ad una variabile il valore di un’altra variabile appartenente ad un tipo di dati diverso?

Mi spiego meglio; quando scrivo qualcosa del tipo:

x=y;

se x ed y sono dello stesso tipo, semplicemente il valore di y viene copiato in x. Tuttavia, se x è ad esempio di tipo intero ed y di tipo float inevitabilmente la parte frazionaria di y verrà persa nell’assegnazione del valore ad x, al limite con un avvertimento (warning) da parte del compilatore.

Ad esempio, il seguente codice:

int main(int argc, char *argv[])

{

int x;

float y=5.5;

x=y;

printf(“Il valore di x e’: %d\n”, x );

printf(“Il valore di y e’: %.2f\n”, y );

return 0;

}

produrrà come output:

Il valore di x e’: 5

Il valore di y e’: 5.50

In generale, infatti, le uniche conversioni che non generano problemi sono quelle che consentono di ampliare la dimensione di una variabile. Ad esempio, nessun problema, ovviamente, nel caso contrario quello appena visto in cui assegniamo un intero ad una variabile float ottenendo come risultato che la variabile float avrà come parte intera il valore intero del numero assegnato e come parte frazionaria il valore zero.

Il valore di x e’: 6

Il valore di y e’: 6.00

Questi tipi di conversione vengono detti conversioni implicite in quanto realizzate automaticamente dal compilatore. In altri casi, però, è necessario “forzare” un tipo di variabile ad essere diversa da quella che risulterebbe in maniera naturale: si parla allora di conversione esplicita. Tali conversioni vengono definite in modo gergale cast oppure casting, ed usando a volte espressioni come “castare una variabile”.

Vi propongo allora una situazione tipica:

int main(int argc, char *argv[])

{

int x=7, y=2;

float d;

d=x/2;

printf(“Il valore di d e’: %.2f\n”, d );

return 0;

}

poiché d è stata dichiarata come float ci si aspetterebbe come risultato il valore 3,5. Sbagliato! L’operazione di divisione tra due interi viene appunto intesa come un fatto “privato” tra interi che da come risultato un valore intero, nel nostro caso il valore 3, che solo successivamente viene assegnato alla variabile con la virgola d. Tale problema è comunissimo e si verifica ad esempio nel caso in cui si deve calcolare la media di un dato numero di elementi interi per il quali, nonostante si prevede una variabile di tipo float si otterrà comunque un numero intero. Per risolvere la situazione si usa allora il casting di cui vi dicevo con la seguente sintassi:

(tipo_dati) espressione

Ad esempio, nel nostro caso sarà sufficiente scrivere:

d=(float)x/2;

per ottenere in stampa il valore desiderato ed atteso di 3,5.

Supportaci condividendo sui social il nostro articolo!

CodeBlocks: installazione sotto Ubuntu

Code::Blocks è un ottimo IDE gratuito per scrivere applicazioni in C e C++. Esso è disponibile sia per Windows che per Linux. Tale caratteristica lo può far preferire in alcuni contesti rispetto a soluzioni come quelle offerte dall’ambiente Microsoft Visual C++ anch’esso gratuito nella versione Express .

L’installazione sotto Windows è estremamente semplice e non richiede nessun chiarimento particolare. In questo brevissimo tutorial vi propongo l’installazione dell’ambiente in questione sotto la distribuzione Linux Ubuntu.

Per prima cosa è necessario scaricare dal sito http://www.codeblocks.org/ la versione desiderata (32 o 64 bit). Da notare come siano disponibili pacchetti anche per le distribuzioni Debia, Fedora e Suse.

Il file scaricato è un archivio compresso (tar.gz). E’ quindi necessario decomprimerlo. A tal fine è possibile utilizzare il tasto destro del mouse sul file in questione e scegliere la voce “Estrai qui”. Verrà creata una cartella contenente i vari file necessari con estensione .deb

Un corretto ordine di installazione potrebbe essere il seguente:

libcodeblocks0_8.02-0ubuntu1_i386.deb
libwxsmithlib0_8.02-0ubuntu1_i386.deb
libwxsmithlib0-dev_8.02-0ubuntu1_i386.deb

e successivamente gli altri pacchetti. Questo a causa del fatto che alcuni pacchetti ne richiedono altri per l’installazione.

Per l’installazione dei singoli file/pacchetto è possibile fare doppio click sui singoli file nell’interfaccia grafica oppure usare (via terminale) il comando:

sudo apt-get install nomepacchetto

dove nomepacchetto è il nome dei vari file da installare.

A questo punto dovrebbe essere possibile lanciare l’ambiente CodeBlocks dal menu principale (voce Applicazioni -> Programmazione).

Provate a compilare una semplice applicazione di tipo console con il classico “Hello world!”.

Nel caso dovesse manifestarsi, con la prima compilazione, l’errore:

Linking console executable: bin/Debug/test1

/bin/sh: g++: not found

usate da terminale il comando:

sudo apt-get install g++

Buona programmazione a tutti.

Carlo Mazzone

Supportaci condividendo sui social il nostro articolo!