Lezione 4. L’assignment: un importante operatore

L’ultima volta, nella Lezione 3, ci siamo occupati delle operazioni base in C++ ma non abbiamo parlato dell’operatore più interessante, ovvero l’ASSIGNMENT che viene rappresentato dal simbolo = e, fondamentalmente, dà una variabile ad un nuovo valore.

Se, per esempio, ho un iniziale int a = 3 e voglio cambiare il suo valore in 5 scriverò a = 5. Questo può essere messo in pratica anche con le stringhe. L’assignment serve ogni qualvolta vogliamo dare ad una variabile un nuovo valore. Vediamo, allora, un piccolo esempio e scriviamo un programma che trova la ripetizione delle parole all’interno di un testo:

//Controlla le parole che sono state ripetute
#include "iostream" 
#include "string"
using namespace std;

int main ()
{
    string previous = ""; //parola precedente; "non una parola"
    string current;       //parola corrente (parola più recente"
    while (cin>>current) {   //leggi una sequenza di parole
         if (previous == current) //controlla se la parola è uguale all'ultima
             cout <<"parola ripetuta: " <<current <<'\n';
         previous=current;
    }
}

Questo tipo di codice fa normalmente parte della maggior parte di software dedicati ai controlli grammaticali. 

Allora, come sempre abbiamo aperto il programma specificando il tipo di librerie (iostream e string) e l’utilizzo di std di cui si è parlato in maniera più approfondita nella Lezione 1 e nella Lezione 2.

Guardiamo, ora, il corpo della funzione. Nella prima riga avvertiamo il nostro programma che la parola iniziale “non è una parola”. Mentre string current permette immediatamente al computer di leggere la parola usata, ovvero la parola corrente.

Il while-statement nota che l’affermazione successiva, ovvero cin >> current, verrà ripetuta finché l’operazione non avrà successo; ciò significa anche che l’operazione cin >> current continuerà finché ci saranno caratteri da leggere. Ricordiamoci che CIN si riferisce allo standard input stream definito dalla libreria e che l’operatore >>  (get from, prendi da) specifica dove l’input dato deve leggere, in questo caso la parola corrente.

Notiamo l’uso dell’operatore IF  (che significa “se”) già notato nella lezione precedente il quale, qui, specifica che se la parola precedente è uguale a quella corrente allora il programma dovrà specificarlo scrivendo “parola ripetuta: X”. Ciò significa che il programma legge una parola e la compara a quella che la precede: se sono uguali lo scrive. 

Infine useremo l’assignment per dire al programma che la parola precedente diverrà quella corrente man mano che continuerà a leggere il brano.

Sarà evidente, inoltre, la presenza di quattro parentesi graffe { } anziché due: questo perché il nostro programma sta svolgendo due specifiche azioni: controllare il brano e, nel mentre, scrivere le parole ripetute.

L’assignment ovviamente non è utilizzabile solo per le stringhe ma anche per gli int, ovvero i numeri interi. Spesso, infatti, nei programmi si utilizza l’aumento di una variabile, spesso aggiungendo 1, tant’è che è stata creata per questo una sintassi specifica: ++counter che significa e si può anche scrivere counter=counter+1. Questo tipo di assignment viene chiamato Composite assignment operators. Vi sono, comunque, molti modi di cambiare il valore di una variabile basandosi sul valore di riferimento, come per esempio:

a+=2     //significa a = a+2
b-=7     //significa b = b-7
c*=3     //significa c = c*3

Proviamo, quindi, a cambiare il programma qui sopra dandogli un’idea di dove si trovino le parole all’interno della sequenza così da fargliele contare e dare poi l’output.

//Controlla e conta, poi, le parole ripetute
#include "iostream"
#include "string"
using namespace std;

int main ()
{
    int_number_of_words = 0;
    string previous = "" ;  //parola precedente;"non una parola"
    string current;         //parola corrente: la più recente 
    while (cin>>current) {
           ++number_of_words; //aumenta il numero parole
           if (previous == current) //controlla se la parola 
                           precedente è uguale a quella corrente
                cout <<"word number" <<number_of_words;
                cout <<"repeated: " <<current <<'\n';
           previous=current;
     }
}
     

L’ordine iniziale presente nel corpo della funzione, ovvero int_number_of_word = 0, dice al nostro programma di iniziare a contare da zero: ogni volta che viene rilevata una parola si incrementa il conto con il comando ++number_of_words che può scriversi anche in altre due modi, ovvero, number_of_words+=1 oppure number_of_words=number_of_words+1.

Fate attenzione quando nominate le variabili poiché non potrete utilizzare caratteri speciali e dovrete sempre iniziare sempre con una lettera.

Questi sono esempi di nomi di variabili corretti:

w
number_of_things
fourier_transform
z3
Square

I seguenti, invece, non sono nomi di variabili:

2x             //un nome DEVE iniziare con una lettera
time$to$shop   //$ non è una lettera, un numero o un underscore
Start menu     //lo spazio non va MAI utilizzato

Possono trovarsi in giro, però, dei nomi che iniziano con l’underscore (ovvero _ ) come, per esempio, _foo ma questi sono riservati per l’implementazione e le entità di sistema: evitando di scriverli noi stessi non creeremo confusione, in un secondo momento, tra i nomi che abbiamo creato e quelli che sono stati generati dal sistema.

Riassumiamo, quindi, un po’ di definizioni tanto per rinfrescare la memoria:

TYPE, definisce un set di valori e di operazioni per un object.

OBJECT, è una regione di memoria che contiene un valore di un dato type.

VALUE, è il valore, ovvero un set di bits nella memoria che vengono interpretati secondo un type.

VARIABLE, è una variabile, ovvero un object a cui si è dato un nome.

DECLARATION, è un’affermazione che da un nome ad un object.

DEFINITION, è una declaration che mette da parte la memoria per un dato object.

Un programma si dice essere TYPE-SAFE quando gli objects al suo interno vengono utilizzati tenendo conto delle regole del loro type.

Ci sono dei modi per operare in modalità non type-sape come, per esempio, usare una variabile senza averla inizializzata ma è sconsigliato farlo! Nel caso, comunque, per vari motivi si decida di non usare il type-safe il compiler non sarà in grado di aiutarci ad individuare eventuali errori e, quindi, dovremmo affidarci semplicemente a noi stessi per ricontrollare il codice.