[Pillola] Leggere il C/C++

Come primo, importantissimo concetto del C/C++, bisogna richiamare il concetto di Variabile e di Tipo; Bisogna capie bene che le due cose sono disgunte ma fortemente legate, e nella fattispecie:

1. il < TIPO >: è la definizione burocratica di un dato elemento, ovvero ogni tipo possiede delle proprietà che lo caratterizzano
2. la < Variabile >: è l'istanza di un Tipo di dato, ovvero è una realizzazione pratica della teoria definita nel Tipo

Detto questo, cosa sicuramente molto noiosa per chi conosce il C/C++ da un po' ( ma vi assicura che è noiosa anche per chi lo ha appena iniziato a studiare, difatti questa parte viene sottovalutata e spesso saltata, e ciò pregiudica la comprensione totale sel linguaggio ), possiamo dire quindi che, una variabile è una evocazione di tutta la teoria che si porta dietro un tipo. Vediamo cosa chiediamo a un Tipo:

1. <TIPO> ha una sua dimensione in memoria
2. <TIPO> ha una sua algebra
   (ovvero dati due tipi diversi, <tip1> e <tip2>, non è necessario che questi si comportino in egual modo, rispetto al punto di vista binario, a uno specifico operatore. Questa osservazione verà discussa piu' profondamente nel seguito)

Che ogni tipo di dato debba avere una sua dimensione in memoria è abbastanza semplice da capire, quindi non credo che ci si debba soffermare su questo punto.
Per quanto riguarda l'algebra bisogna spendere un po' di parole: Noi siamo abituati a ragionare con gli operatori che conosciamo dalle scuole elementari, e ci viene difficile pernsare che nessuno vieta di utilizzare operatori diversi che diano lo stesso risultato.
Ovviamente, ora se un matematico leggesse queste mie righe credo che prenderebbe una alabarda e mi verebbe a cercare, questo perchè le cose non sono realmente cosi, ma credo che sia l'unico modo ( l'unico rapito ed indolore ) per spiegare che l'operatore SOMMA ( il "+" ) non deve essere per forza definito come tutti noi lo conosciamo.
In algebra, esistono delle leggi, leggi molto particolari che si chiamano Assiomi; questi sono leggi puramente astratte, che parlano di insiemi e operatori generici, e dicono che se gli si fornice un insieme e due iperatori definiti come a voi piace, e l'insieme di tali elementi soddisfa tutti gli assiomi, allora quello che avete ottenuto è un'algebra che funziona.

Ora, probabilmente vi ho confuso un po' le idee, ma senza aver troppa paura bisogna capire che io posso definire un'algebra in cui 1+1 faccia 0;



Tornando al nostro C, abbiamo spiegato tutto questo per dire che ogni tipo di dato ha prorpietà, che vengono trasferite quando si crea una variabile sullo stampo di questi tipo. Il C vi fornisce dei tipi di dato primitivi, e si chiamano primitivi perche' è possibile definire nuovi tipi di dato partendo da questi ( cosa che non vedremo ora ); I tipi primitivi sono:

1. int: identifica tipi di dato intero
2. float: identifica tipi di dato con la virgola
3. char: identifica tipi di dato carattere

Logicamente sono solo questi i tipi di dato con cui si lavora, ma ne esistono anche altri ed esistono anche delle cosette che dendono ad orlare questi tipi;
Per il nostro scopo basterebbe avere solo int e char, e infatti usaremo solo quelli. ( comunque, ne esistono molti altri... per esempio unsigned int deve essere considerato come un tipo di dato puramente diverso da int )

Iniziamo a parlare un po' di int e char:

Il Tipo int Word che riserva in memoria: 4 Pecurialità sugli operatori: int temp; &temp : restituisce il valore di memoria in testa alle 4 word temp: restituisce il valore contenuto (opportunamente codificato) nelle 4 word

Il Tipo char Word che riserva in memoria: 1 Pecurialità sugli operatori: char temp; &temp : restituisce il valore di memoria temp: restituisce il valore contenuto (opportunamente codificato)

Gli Operatori

Come riferimento esterno possiamo prendere la seguente pagina: wiki - Operators in C and C++
Esistono molti operatori per questo linguaggio ( mai abbastanza se dobbiamo essere sinceri ), ed è quasi un obbligo conoscerli tutti per poter aquisire uno stile di programmazione elegante e funzionale; Ciò non toglie che se non si possiede una memoria di ferro, e si tende a dimenticare velocemente le cose ( come chi scrive queste righe ad esempio ), non è un dramma ammettere di non esser capaci di ricordarsi tutto, anche perche' è abbastanza semplice ragionarci su e arrivarci con la logica ogni volta che serve ( oltre al fatto che, esiste sempre google... )

I conetti fondamentali da sapere sugli operatori sono:

• Il numero di argomenti che l'operatore vuole
• Il <Tipo> di dato che gli operatori possono processare
• Il <Tipo> di dato che gli operatori emettono

Devo fare una piccola precisazione; In genere si parla di <valore> e <tipo> di ritorno, io preferisco parlare di Emissione per una questione puramente lessicale. Nella mia breve esperienza ho notato che uno dei punti piu' ostici da comprendere è legato al modo in cui vengono presentati certi concetti, che sono molto banali, ma presentati con un linguaggio quasi Dantesco.

Stando alla lista degli operatori presentata nel link ( o anche recuperata su google ), vi sono due tipi di operatori, quelli che accettano due argomenti e quelli che ne accettano uno. La sintassi di riferimento è la seguente:

• <Argomento Sinistro> <OPERATORE> Argomento Destro
• <OPERATORE> <Unico Argomento Destro>
• <Unico Argomento Sinistro> <OPERATORE>

Ricordiamo anche che gli operatori hanno una prioprità di esecuzione, ma ne parleremo successivamente. Per ora noi useremo sempre le parentesi tonde per isolare le varie operazioni da eseguire.
A questo punto bisogna capire come una frase in C/C++, relativamente complessa, viene processata e letta. L'algoritmo che dovete tener a mente è il seguente:

Tecnicamente non è necessario ricordarsi tutto il flowchart, basta ricordarsi questi pochi passaggi:

1. Emetto il Dato
2. Posso Operare? (Fare l'operazione)

• Si: Calcolo e torno al punto 2
• No: Torno al Punto 1

A questo punto, facendo riferimento solo al tipo di dato int, iniziamo a fare degli esempi relativamente complessi per comprendere come la nostra mente deve operare per risolvere le espressioni scritte:
Espressione molto facile, e quindi so che siete tentati di saltare questa parte, ma vi prego di portarle molta attenzione, perche' qui si capisce come funziona il gioco:

1. 
   Devo identificare, nell'espessione scritta, la/le parte/i piu' nidificata:
   
   result = (( ifrit + cnt ) % laurt) * ( ++ifrit - cnt ) + laurt;
   
   
   


2. A questo punto dovrei far partire l'algoritmo sopra citato, e lo facciamo mentalmente:
   Osservando le parti evidenziate:
   • ( ifrit + cnt )
   • ++ifrit
   Notiamo che i nomi ifrit e cnt sono ancora delle hendle, quindi bisogna prima emetterli, ovvero sostituirli mentalmente col il valore che contengono in memoria:
   
   result = (( 1 + 7 ) % laurt) * ( ++<0xFC> - cnt ) + laurt;
   
   
   Ricordo che l'operatore ++ vuole l'indirizzo di memoria come dato di ingresso ( io ho ipotizzato che ifrit sia alla locazione 0xFC)
   
   


3. Possiamo proseguire e risolvere i pezzi appena osservati, i quali faranno un calcolo ed emetteranno un dato:
   • ( 1 + 7 ) restituirà un int con valore 8
   • ++<0xFC> incrementerà il contenuti della cella in questione, ed emetterè un int con il valore contenuto in essa, ovvero in questo caso farà passare ifrit al valore 2, ed emetterà un int con valore 2
   Pertanto:
   
   result = ( 8 % laurt) * ( 2 - cnt ) + laurt;
   
   Ricordanto che 8 e 2 sono tipi di dato int
   
   


4. Nuovamente, devo identificare la/le parte/i piu' nidificata:
   
   result = ( 8 % laurt) * ( 2 - cnt ) + laurt;
   
   


5. Stesso identico discorso fatto precedentemente, ovvero devo emettere il valore contenuto dalle hendle nelle espressioni, quindi ottengo:
   
   result = ( 8 % 2) * ( 2 - 7 ) + laurt;
   
   


6. Idem come sopra, calcoliamo:
   • ( 8 % 2) restituirà un int con valore 0
   • ( 2 - 7 ) restituirà un int con valore -5
   Pertanto:
   
   result = 0 * (-5) + laurt;
   
   


7. Credo che ora siate abbastanza sciolti per capire che l'epressione 0 * (-5) non ha bisogno di emissioni, e dopo il calcolo emetterè un int con valore 0. E anche se sembra eccessivo, scriviamo che dopo questa operazione otteniamo:
   
   result = 0 + laurt;
   
   


8. Nuovamente, emettiamo il valore contenuto da laurt:
   
   result = 0 + 2;
   
   e ora facciamo la domma:
   
   result = 2;
   
   


9. Ultimo passo, bisogna emettere le nostre hendle:
   
   <0xF0> = 2;
   
   
   e ora proseguire con il calcolo, ovvero scrivere nella locazione 0xF0 il valore 2.
   
   


10. Per dovere di cronaca, bisogna ricordare che dopo l'assegnamento, avviene un'emissione di un int con il valore 2

Piu' semplice a farlo che a dirlo, in qualsiasi caso ripercorriamo velocemente le operazioni fatte senza commentarle:

1. result = (( ifrit + cnt ) % laurt) * ( ++ifrit - cnt ) + laurt;
2. result = (( 1 + 7 ) % laurt) * ( ++<0xFC> - cnt ) + laurt;
3. result = ( 8 % laurt) * ( 2 - cnt ) + laurt;
4. result = ( 8 % 2) * ( 2 - 7 ) + laurt;


5. result = 0 * (-5) + laurt;
6. result = 0 + laurt;
7. result = 0 + 2;
8. result = 2;
9. <0xF0> = 2;


10. 2

Ottimo,

abbiamo trovato l'autore!
Magari con qualche altro post posso aprire una sezione dedicata di pillole!
...un posto dove la dipendenza da pillole non nuocerà alla salute!

E' da tanto che non facevo una dimostrazione di questo tipo!
Mi ricorda i tempi di algebra.
...pure non vedendo la foto direi che sei fresco di università!

Saluti,

Mauro

Mauro Laurenti ha scritto: Ottimo,

abbiamo trovato l'autore!
Magari con qualche altro post posso aprire una sezione dedicata di pillole!
...un posto dove la dipendenza da pillole non nuocerà alla salute!

E' da tanto che non facevo una dimostrazione di questo tipo!
Mi ricorda i tempi di algebra.
...pure non vedendo la foto direi che sei fresco di università!

Saluti,

Mauro

piu' che fresco, sono ancora nel forno dell'uni xD

...cottura lenta e lunga!

Io ho dato...e come vedi dopo l'università ci si puo' ancora divertire!
Ma ho il vantaggio di non fare esami...solo brutte figure!

Saluti,

Mauro