Appunti Fondamenti di informatica

PRECEDENZA

- Fattori (tra parentesi)

- Operatori unari post-fissi

- Operatori unari prefissi

- Not

- Meno e più unario

- Binari:

1. moltiplicativi (*, /, %)

2. additivi (+, -)

3. relazione (<, <=, >= ...) * ASSOCIATIVI A SX (da sx a dx)

4. uguaglianza (= -, =)

5. logici (nell’ordine &&, ||)

6. assegnamento (= ...) ASSOCIATIVO A DX

WARNING! Cortocircuito

Il calcolo di un’espressione contente && e il termine appena si può decidere se

l’espressione è vera o falsa con certezza; le altre espressioni non vengono nemmeno

valutate.

Se && ha come primo risultato 0 (cioè vero) non valuta gli altri e restituisce

direttamente falso.

Se || ha come primo risultato 1 (cioè falso) non valuta gli altri e restituisce

direttamente vero.

STREAM

Uno stream è un buffer (memoria temporanea) che va considerato come un flusso di

informazioni posizionato su caselle di un byte ciascuno.

Lo stream è usato principalmente per operazioni di lettura/scrittura si associati a

dispositivi fisici come tastiera, monitor…

- Stream di ingresso CIN: associato alla tastiera del terminale. Si preleva dallo

stream un carattere/numero alla volta con lo spostamento di un puntatore fino

alla marca di fine stream o a un carattere non previsto e ogni chiamata

restituisce l’indirizzo dello stream coinvolto poiché >> è associativo a sx (ignora

gli spazi bianchi a meno che non si usino le frazioni).

Quando nel programma si ha la chiamata al CIN, esso si arresta e aspetta

informazioni, ciò che viene scritto compare a video e va a riempire lo stream

appena si preme l’invio, da lì in poi si prelevano i dati per il programma. Quando

non si inserisce qualcosa di consistente, il prelievo non avviene e lo stream si

porta in una condizione di errore che può essere ripristinato chiamando la

funzione cin.clear() e questo avviene anche quando si tenta di leggere la

marca di fine stream (ctrl+D).

- Stream di uscita COUT: associato al monitor del terminale. Si calcola ciò che si

vuole mostrare, si copia nello stream un carattere alla volta e visto che << è

associato a sx, il ritorno è lo stesso stream e a video si ha ciò che è presente

nello stream nel formato predefinito dal compilatore. Di solito si accompagna

sempre con un “ENDL” che manda a capo per un miglior ordine visuale nel

terminale.

Gli stream però possono essere collegati anche a file (file-stream) e ci si può lavorare

includendo la libreria <fstream>, ne esistono di tre tipi:

Lettura

 Scrittura

 Scrittura alla fine del file (“APPEND”, quando è già presente qualcosa nel file)



Modalità d’uso:

1. Si crea lo stream (f stream ff) e si apre con ff.open(“nomeFile.txt”, ios::

in/out)

2. Si usa con la stessa procedura di quelli predefiniti ff<<i oppure ff>>i

3. Si chiuse lo stream ff.close()

Dopo ogni chiusura è sempre possibile riutilizzare lo stream.

Nel caso lo stream si ponga in una posizione di errore, si può usare la funzione

ff.clear() per portarlo in uno stato corretto (meglio controllare spesso)

- Stream di errore CERR: ha le stesse caratteristiche del cout e si usa nello stesso

modo tranne che il cout si usa in qualsiasi tipo di uscita, il cerr si usa quando,

dopo un controllo, si deve mandare a video un messaggio di errore.

ISTRUZIONI STRUTTURATE

Istruzione composta: si possono rendere un’unica istruzione un qualsiasi insieme

 di istruzioni costituenti un “blocco” (una parte di codice compresa fra parentesi

graffe)

Istruzione condizionale:

 IF if (condizionaleLogica) {

 Istruzioni da eseguire se la

condizone risulta vera Si possono anche contenere

} più if tenendo conto che

l’else si riferisce all’if pù

vicino.

else {

istruzioni da esefuire se la

condizione risulta falsa

}

SWITCH switch (condizionale) {

 case 1 operazione;

istruzioni per questo caso;

break;

case 2 operazione; case 3 operazione;

istruzioni

break;

default; istruzioni;

break;

}

Istruzione ripetitive:

 WHILE while (condizione){

 Istruzioni;

}

Se la condizione è vera si entra nel while, altrimenti si salta tutto e le istruzioni

vengono ripetute fino a quando la condizione non risulta falsa (si rivaluta ogni volta)

DO do {

 Istruzioni;

}

while body

Si usa quando si vuole far eseguire comunque, almeno una volta (caso in cui la

condizione del while è subito falsa)

FOR for (inizializzazione; condizione; incremento) {

 Istruzioni;

}

Si esegue come se fosse:

1. Inizializzazione

2. While (condizioni)

3. Incremento e rivalutazione

Si usa il for se la variabile inizializzata serve solo all’interno del corpo

Continue -> istruzione di salto. Si trova sempre all’interno di un ciclo e rimanda

 diretamente alla rivalutazione della condizione

Go to identifier -> istruzione di salto. Svolge lo stesso compito di break e

 continue ma permette di andare in qualche parte specifica del codice (come i

JUMP in assembler). Ne è sempre sconsigliato l’uso

Return value -> istruzione di salto. Si trova solo nelle funzioni (quindi anche nel

 main) e fa terminare l’esecuzione della stessa; è operazionale e se non è

presente la fuzione termina quando raggiunge la fine del suo body

Exit (o) -> istruzione di salto. Serve ad interrompere completamente

 l’esecuzione del programma e si può usare includento la <stdlib>

FUNZIONE

La funzione è un pezzo di codice che viene isolato in modo da poter essere utilizzato

più volte senza doverlo riscrivere

Caratteristiche:

Nome

- per identificarla, anche se possono coesistere funzioni con stesso nome

se hanno argomenti diversi o il numero diverso, e serve anche nella chiamata

du funzioni *

Tipo di ritorno,

- è ciò che restituisce ogni volta la funzione dopo essere stata

eseguita; tra i tipi di ritorno ci sono tutti quelli fondamentali sommati al tipo

void che indica la funzione senza ritorno (di solito capita con la stampa), oppure

riferimenti

Argomenti

- che possono anche nonmesserci, oppure, se presenti, ne va

specificato il tipo e il passaggio di questi nel main può avvenire in due modi: per

valore (copiando semplicemente il valore) oppure per riferimento, se si vuole

permettere alla funzione di modificare una variabile del main, in quel casosi dice

che ha effetto collaterale.

P.s gli argomenti che compaiono nella dichiarazione della funzione ** sono detti

formali, mentre quelli che compaiono nel main sono detti attuali.

Su una funzione si può operare in tre modi diversi:

- Dichiarazione *: se si indicano semplicemente i tre elementi sopra elencati

senza il corpo stesso: tipoRitorno_nome (ar1, ar2…) = intestazione

- Definizione: se oltre all’intestazione della funzione si specifica anche il coorpo

della stessa funzione

- Chiamata *: avviene nel main ed è del tipo “nome” (argomenti attuali) e serve a

specificare in quale parte del programma serve l’uso della funzione specificata.

Si possono inizializzare variabli fuori dal main e da altre funzioni si tratta delle variabili

globali che sono accessibili da tutte le funzioni del programma.

Appendice:

- Ricorsione (trattata meglio in algoritmi): si ha quando una funzione richiama se

stessa all’interno del suo corpo. Per poterla scrivere è necessario trovare dei

casi base a cui far ricondurre alla fine tutte le serie di chiamate ricorsive dettate

dai passi ricorsivi. In genere c’è un argomento di controllo dal cui valore

dipende la scelta delle istruzioni da eseguire. Per ogni funzione ricorsiva esiste

la corrispondente iterativa w, in base ai casi ne conviene più una che l’altra.

TIPI DERIVATI

- Riferimenti: si ha quando si assegna una ltro nome ad una variabile già

esistente non occupando ulteriore spazio in memoria. Non è possibile creare

riferimenti a valori ma solo a variabili e oer le variabili costanti pervhè non si

deve poter modificare la variabile del riferimento. Servono nel passaggio per

riferimento per le funzion ma può essere anche il tipo del ritorno.

WARNING! Non si devono restituire variabili che terminano il loro tempo di vita

con la funzione stessa.

- Puntatori: sono variabili che contengono indirizzi e vanno sempre inizializzati

altrimenti puntano ad una parte casuale della memoria; se inizializzato come

costante punterà verso la stessa variabile: int*constp = &q

Si può anche inizializzare un puntatore a puntatore con: int** p = &q