Programmazione procedurale - Appunti completi

Il linguaggio ANSI C

Inclusione di libreria

#include <fileDiIntestazioneDiLibreriaStandard> Oppure #include "fileDiIntestazioneDiLibreriaDelProgrammatore"

Funzione main

Ogni programma C deve contenere almeno la funzione main, il cui corpo si compone di una sezione di dichiarazioni di variabili locali e di una sezione di istruzioni. La prima istruzione che viene eseguita in un programma C è la prima istruzione della funzione main. Le rimanenti istruzioni vengono poi eseguite una alla volta nell'ordine in cui sono state scritte.

Identificatori

Gli identificatori del linguaggio C sono sequenze di lettere, cifre decimali e sottotratti che non iniziano con una cifra decimale. Gli identificatori denotano:

• Nomi di costanti simboliche (KM_PER_MI)
• Tipi (int, void, double)
• Variabili (miglia, chilometri)
• Funzioni (main, printf, scanf)
• Istruzioni

Gli identificatori si dividono in:

• Riservati (int, void, double, return)
• Standard (printf, scanf)
• Introdotti dal programmatore (KM_PER_MI, miglia, chilometri)

Tipi di dati predefiniti

Ogni identificatore di costante simbolica, variabile o funzione ha un tipo ad esso associato, il quale stabilisce l'insieme di valori che l'identificatore può assumere e l'insieme di operazioni nelle quali l'identificatore può essere coinvolto. Il linguaggio C mette a disposizione diversi tipi predefiniti:

• int: insieme dei numeri interi
• double: insieme dei numeri reali, divisi in virgola fissa o mobile
• char: insieme dei caratteri, racchiusi tra apici. L'estensione di tipo stringa determina le sequenze finite di caratteri, racchiuse tra virgolette
• void: l'assenza di parametri o l'assenza di risultati da restituire

Funzioni di libreria per l'input/output interattivo

File di intestazione di libreria standard: stdio.h

Funzione di libreria standard per acquisire dati tramite tastiera: scanf (stringaFormato , sequenzaIndirizziVariabili)

Stringa formato:

• %d = int
• %lf = double in virgola fissa
• %le = double in virgola mobile
• %lg = double in generale
• %c = char
• %s = stringa

Sequenza indirizzi variabili: sequenza di indirizzi di variabili separati da virgola (tali indirizzi sono solitamente ottenuti applicando l'operatore "&" agli identificatori delle variabili)

Funzione di libreria standard per stampare su schermo: printf(stringaFormato , sequenzaEspressioni)

Stringa formato:

• %d = int
• %f = double in virgola fissa
• %e = double in virgola mobile
• %g = double in generale
• %c = char
• %s = stringa
• \n = andare a capo
• \t = tabulazione

Sequenza espressioni: sequenza eventualmente vuota di espressioni separate da virgola.

Funzioni di libreria per l'input/output tramite file

Dichiarare una variabile di tipo puntatore a FILE per ogni file da gestire: FILE *variabileFile;

FILE: tipo di dato standard definito in stdio.h
*: tipo puntatore

L'operazione di apertura specifica se il file deve essere letto (nel qual caso il file deve esistere): variabileFile = fopen("nomeFile","r"); oppure scritto (nel qual caso il precedente contenuto del file, se esistente, viene perso): variabileFile = fopen("nomeFile","w");

Funzione di libreria standard per leggere da un file aperto in lettura: fscanf(variabileFile, stringaformato , ssequenzaIndirizziVariabili)

Se fscanf incontra il carattere di terminazione file, il risultato che essa restituisce è il valore della costante simbolica standard EOF definita in stdio.h.

Funzione di libreria standard per verificare se è stata raggiunta la fine di un file aperto in lettura: feof(variabileFile)

Funzione di libreria standard per scrivere su un file aperto in scrittura: fprintf(variabileFile, stringaformato , psequenzaEspressioni)

Chiudere ogni file dopo l'ultima operazione di lettura/scrittura su di esso: fclose(variabileFile)

Espressioni

Definizione di costante simbolica

Direttiva di definizione di una costante simbolica: #define identificatoreDellaCostante valoreDellaCostante

Consente di raccogliere tutti i valori costanti usati nel programma, dando loro dei nomi da usare all'interno del programma che dovrebbero richiamare ciò che i valori costanti rappresentano. Ciò incrementa la leggibilità del programma.

Dichiarazione di variabile

Funge da contenitore per un valore. Diversamente dal valore di una costante, il valore di una variabile può cambiare. Dichiarazione di variabile: tipo identificatoreVariabile = valoreIniziale;

Operatori aritmetici

• Unari prefissi
  • +espressione
  • -espressione
• Binari additivi infissi
  • espressione1 + espressione2
  • espressione1 - espressione2
• Binari moltiplicativi infissi
  • espressione1 * espressione2
  • espressione1 / espressione2
  • espressione1 % espressione2 (resto della divisione tra le due espressioni)

Operatori relazionali

• Binari d'ordine infissi
  • espressione1 < espressione2
  • espressione1 > espressione2
  • espressione1 <= espressione2
  • espressione1 >= espressione2
• Binari d'uguaglianza infissi
  • espressione1 == espressione2
  • espressione1 != espressione2
• Vero = 1
• Falso = 0

Operatori logici

• Unari prefissi
  • !espressione
• Binari infissi
  • espressione1 && espressione2
  • espressione1 || espressione2

Operatore condizionale

(espressione1) ? espressione2 : espressione3

Operatori di assegnamento

• variabile = espressione
• variabile += espressione
• variabile -= espressione
• variabile *= espressione
• variabile /= espressione
• variabile %= espressione
• variabile op= espressione → variabile = variabile op espressione

Operatori di incremento/decremento

• Unari postfissi
  • variabile++
  • variabile--
• Unari prefissi
  • ++variabile
  • --variabile

Operatore virgola

Binario infisso

• espressione1, espressione2
• Risultato = espressione2

Precedenza e associatività degli operatori

1. Unari aritmetici, logici, di incr / decr = + - ! ++ --
2. Aritmetici moltiplicativi = * / %
3. Aritmetici additivi = + -
4. Relazionali d'ordine = < > <= >=
5. Relazionali d'uguaglianza = == !=
6. Logici moltiplicativi = &&
7. Logici additivi = ||
8. Operatore condizionale = ?:
9. Assegnamento = = += -= *= /= %=
10. Virgola = ,

Istruzioni

Istruzione di assegnamento

Espressione di assegnamento terminata da ";"

Istruzione composta

Sequenza di una o più istruzioni, eseguite una alla volta nell'ordine in cui sono state scritte.

Istruzioni di selezione: if, switch

Esprimono una scelta tra diverse istruzioni composte, dove la scelta viene operata sulla base del valore di un'espressione aritmetico-logica.

Istruzione if:

• Singola alternativa
  • if (espressione) istruzione;
  • L'istruzione viene eseguita solo se l'espressione è vera.
• Due alternative
  • if (espressione) istruzione1; else istruzione2;
  • Si esegue istruzione2 se l'espressione è falsa.
• Più alternative
  • if (espressione1) istruzione1; else if (espressione2) istruzione2; else istruzione3;
  • Le espressioni vengono valutate una dopo l'altra, fino a trovare una vera;

Istruzione switch:

switch (espressione) {
    case valore1,1:
    case valore1,2:
    case valore1,M: istruzione1
    break;
    case valore2,1:
    case valore2,2:
    case valore2,M: istruzione2
    break;
    default: istruzioneNumero+1
    break;
}

L'espressione su cui si basa la selezione deve essere di tipo int o char. Se il suo valore è uguale a uno dei valori indicati in una delle clausole case, tutte le istruzioni composte che seguono quella clausola case vengono eseguite fino a incontrare un'istruzione break. Se invece il valore dell'espressione è diverso da tutti i valori indicati nelle clausole case, viene eseguita l'istruzione composta specificata nella clausola opzionale default.

Istruzioni di ripetizione: while, for, do-while

Esprimono l'esecuzione ripetuta di un'istruzione composta, dove la terminazione dell'iterazione dipende dal valore di un'espressione aritmetico-logica detta "condizione di continuazione".

Istruzione while

• while (espressione) istruzione;
• L'istruzione composta che si trova all'interno viene eseguita finché l'espressione è vera.

Istruzione for

• for (espressione1, espressione2, espressione3) istruzione;
• espressione1 = espressione di inizializzazione delle variabili presenti nella condizione di continuazione;
• espressione2 = condizione di continuazione
• espressione3 = espressione di aggiornamento delle variabili presenti nella condizione di continuazione.
• L'istruzione for equivale alla seguente istruzione con while:

  espressione1;
  while (espressione2) {
      istruzione;
      espressione3;
  }
          

Istruzione do-while

• do istruzione; while (espressione)
• L'istruzione do-while è una variante dell'istruzione while in cui l'istruzione composta che si trova all'interno viene sicuramente eseguita almeno una volta, ed equivale alla seguente istruzione con while:

  istruzione;
  while (espressione) istruzione;
          

Diversi tipi di controllo della ripetizione:

• Ripetizione controllata tramite contatore (quando si conosce a priori il numero di iterazioni)
• Ripetizione controllata tramite sentinella (quando non si conosce il numero di iterazioni)
• Ripetizione controllata tramite fine file (caso particolare del precedente)
• Ripetizione relativa all'acquisizione con validazione di uno o più valori

Istruzione goto

Il flusso di esecuzione delle istruzioni di un programma C può essere modificato in maniera arbitraria tramite la seguente istruzione: goto etichetta; la quale fa sì che la prossima istruzione da eseguire non sia quella ad essa immediatamente successiva nel testo del programma, ma quella prefissata da etichetta:, dove etichetta è un identificatore.

Esempio:

(1) if (n % 2 == 0)
(2) goto scrivi_pari;
(3) printf("Il numero è dispari.\n");
(4) goto continua;
(5) scrivi_pari: printf("Il numero è pari.\n");
(6) continua: ...

Se n è pari, allora il flusso di esecuzione è (1)-(2)-(5)-(6), altrimenti è (1)-(3)-(4)-(6).

Teorema fondamentale della programmazione strutturata

I programmi sono rappresentabili graficamente attraverso schemi di flusso, i quali sono costituiti da blocchi e da nodi. Condizione necessaria affinché uno schema di flusso sia strutturato è che esso abbia un unico nodo di inizio e un unico nodo di fine.

Teorema fondamentale della programmazione strutturata (Böhm e Jacopini): dato un programma P e uno schema di flusso F che lo descrive, è sempre possibile determinare un programma P' equivalente a P che è descrivibile con uno schema di flusso F' strutturato.

Se uno schema di flusso non è strutturato, è possibile renderlo tale applicando le seguenti regole:

• Risoluzione: duplicare e separare blocchi condivisi aggiungendo ulteriori nodi collettori
• Interscambio: scambiare le linee di ingresso/uscita di nodi collettori adiacenti
• Trasposizione: scambiare un blocco di azione con un nodo collettore o un blocco di controllo, a patto di preservare la semantica.

Procedure

Formato di un programma con più funzioni su un singolo file

Il concetto di progettazione top-down consiste nella suddivisione di un problema complesso in sottoproblemi più semplici. Questo viene ottenuto mediante l'uso di procedure o funzioni, che consentono un'architettura più modulare del programma. In C, una funzione è una sequenza di istruzioni logicamente correlate che lavorano su un insieme di dati parametrizzati. Avere più funzioni all'interno di un singolo file ha diversi vantaggi, tra cui maggiore leggibilità del programma, possibilità di suddividere il lavoro tra più programmatori e riuso del software.

Il formato di un programma C con più funzioni su un singolo file è composto così:

• Direttive al preprocessore (Inclusione di libreria)
• Definizione dei tipi (Che possono essere diversi da quelli già visti)
• Dichiarazione delle variabili globali (Fuori dalle funzioni)
• Dichiarazione delle funzioni (esclusa Main)
• Definizione delle funzioni (a partire da Main)

È importante che le funzioni vengano dichiarate prima di essere definite, altrimenti il compilatore emetterà messaggi d'errore. L'esecuzione del programma inizia sempre dalla prima istruzione della funzione main e continua seguendo l'ordine testuale delle istruzioni presenti nella funzione main e nelle funzioni che vengono via via invocate. Inoltre le variabili globali sono utilizzabili all'interno di ciascuna funzione che segue la loro dichiarazione, a meno di eventuali dichiarazioni locali con lo stesso nome.

Dichiarazione di funzione

La dichiarazione di una funzione C serve a comunicare al compilatore che esiste una funzione con un determinato nome e tipi di parametri, e quale tipo di valore restituirà. La sintassi per la dichiarazione di una funzione è:

• tipoRisultato identificatoreFunzione(tipiParametriFormali);
• tipoRisultato: rappresenta il tipo del valore restituito dalla funzione alla chiamata. In caso la funzione non restituisca alcun valore, questo tipo è void.
• identificatoreFunzione: è il nome della funzione.
• tipiParametriFormali: rappresenta i tipi degli argomenti della funzione, separati da virgole. In caso di mancanza di argomenti il parametro è void.

La dichiarazione di funzione va scritta prima del main o in un header file e serve al compilatore a verificare la corretta chiamata della funzione. La dichiarazione non include il corpo della funzione, che deve essere scritto in un punto successivo del codice. È importante sapere che una funzione deve essere dichiarata prima di essere utilizzata in caso contrario il compilatore non saprebbe a quale funzione si sta facendo riferimento.

Definizione di funzione e parametri formali

La definizione di una funzione C è la porzione di codice che contiene il corpo della funzione e che viene eseguito quando la funzione viene chiamata. La sintassi per la definizione di una funzione è:

• tipoRisultato identificatoreFunzione(dichiarazioneParametriFormali){ dichiarazioneVariabiliLocali; istruzioniDellaFunzione; }
• tipoRisultato: rappresenta il tipo del valore restituito dalla funzione alla chiamata. In caso la funzione non restituisca alcun valore, questo tipo è void.
• identificatoreFunzione: è il nome della funzione.
• dichiarazioneParametriFormali: è la lista dei parametri che la funzione accetta come input. Ogni parametro è composto da un tipo di dati e un identificatore. In caso di mancanza di argomenti, questa parte può essere omessa.
• dichiarazioneVariabiliLocali: rappresenta le dichiarazioni delle variabili che vengono utilizzate solo all'interno della funzione.
• istruzioniDellaFunzione: sono le istruzioni che compongono il corpo della funzione e che vengono eseguite quando la funzione viene chiamata.

La definizione di una funzione include anche l'intestazione della funzione, ovvero la prima riga con la sintassi tipoRisultato identificatoreFunzione(dichiarazioneParametriFormali). L'intestazione deve coincidere con la dichiarazione della funzione, a meno dei nomi dei parametri, che sono necessari solo per fare riferimento ai parametri all'interno del corpo della funzione.

I parametri formali sono i parametri dichiarati nell'intestazione della funzione, sono utilizzati solo all'interno del corpo della funzione e non hanno alcun valore di default, ogni volta che una funzione viene chiamata gli argomenti devono essere specificati. Inoltre gli identificatori dei parametri formali e delle variabili locali sono utilizzabili solo all'interno del corpo della funzione, questo significa che non possono essere utilizzati o acceduti al di fuori della funzione in cui sono dichiarati.

Invocazione di funzione e parametri effettivi

L'invocazione di una funzione C è il meccanismo attraverso il quale una funzione viene eseguita. La sintassi per l'invocazione di una funzione è:

• identificatoreFunzione(parametriEffettivi)
• identificatoreFunzione: è il nome della funzione che si vuole invocare.
• parametriEffettivi: sono gli argomenti che vengono passati alla funzione durante la chiamata. Si tratta di una sequenza di espressioni separate da virgole. In caso di mancanza di argomenti questa sequenza può essere omessa.

I parametri effettivi devono corrispondere per numero, ordine e tipo con i parametri formali della funzione invocata. In caso contrario il compilatore genererà un errore. Inoltre se un parametro effettivo e il corrispondente parametro formale hanno tipi diversi tra int e double, verranno applicate le regole per la conversione di tipi viste in precedenza.

Quando una funzione viene invocata, l'esecuzione del programma passa alla prima istruzione all'interno del corpo della funzione chiamata, interrompendo l'esecuzione della funzione chiamante. Una volta completate tutte le istruzioni all'interno della funzione chiamata, l'esecuzione del programma ritorna alla funzione chiamante riprendendo dalla successiva istruzione dopo la chiamata della funzione.

Istruzione return

L'istruzione return in C è utilizzata per restituire un valore dalla funzione chiamata alla funzione chiamante. La sintassi è: return espressione;. Se la funzione è di tipo void, l'istruzione return può essere utilizzata per uscire anticipatamente dalla funzione.