Appunti Fondamenti di informatica

Precedenza degli operatori

(tra parentesi)

• Operatori unari post-fissi
• Operatori unari prefissi
• Not
• Meno e più unario
• Binari:
• Moltiplicativi (*, /, %)
• Additivi (+, -)
• Relazione (<, <=, >= ...) associativi a SX (da sx a dx)
• Uguaglianza (= -, =)
• Logici (nell’ordine &&, ||)
• Assegnamento (= ...) associativo a DX

Warning! Cortocircuito

Il calcolo di un’espressione contenente && 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 associati a dispositivi fisici come tastiera, monitor...

Stream di ingresso e di uscita

• 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 chiude 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 condizione risulta vera
      // Si possono anche contenere più if tenendo conto che l’else si riferisce all’if più vicino.
  } else {
      // istruzioni da eseguire 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;
  }
          

Istruzioni 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 (condizione);
          

  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.

Istruzioni di salto

• Continue -> istruzione di salto. Si trova sempre all’interno di un ciclo e rimanda direttamente 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 funzione 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 includendo la <stdlib>.

Funzioni

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 di 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 non esserci, oppure, se presenti, 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 caso si 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.

Sulla 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 corpo 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 variabili 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, in base ai casi ne conviene più una che l’altra.

Tipi derivati

• Riferimenti: si ha quando si assegna un altro nome ad una variabile già esistente non occupando ulteriore spazio in memoria. Non è possibile creare riferimenti a valori ma solo a variabili e per le variabili costanti perché non si deve poter modificare la variabile del riferimento. Servono nel passaggio per riferimento per le funzioni 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.