appunti3s:programmazione_imperativa
Differences
This shows you the differences between two versions of the page.
Both sides previous revisionPrevious revisionNext revision | Previous revision | ||
appunti3s:programmazione_imperativa [2019/07/28 10:29] – [Linguaggio C++] profpro | appunti3s:programmazione_imperativa [2023/04/04 17:52] (current) – [IDE (Integrated Development Environment)] profpro | ||
---|---|---|---|
Line 1: | Line 1: | ||
+ | >> per tornare all' | ||
+ | |||
+ | |||
+ | ====== Programmazione imperativa ====== | ||
+ | ===== Linguaggio C++ ===== | ||
+ | In queste pagine si utilizzerà il linguaggio C++ per tradurre gli algoritmi. | ||
+ | Al momento della scrittura di queste parole, l' | ||
+ | |||
+ | Link esterno | ||
+ | |||
+ | * https:// | ||
+ | |||
+ | Il linguaggio C++ è un linguaggio generico (general purpose) orientato agli oggetti con cui si possono realizzare sia programmi ad interfaccia grafica che programmi ad interfaccia testuale. | ||
+ | I programmi ad interfaccia grafica solitamente sono più grandi da realizzare, quindi si deve necessariamente iniziare con quelli più semplici da riga di comando. | ||
+ | ===== Uso del compilatore g++ ===== | ||
+ | La compilazione permette di ottenere un file eseguibile a partire da un file sorgente (testuale). | ||
+ | Esistono numerosi compilatori per i programmi in linguaggio C++, sia liberi che proprietari. | ||
+ | * [[http:// | ||
+ | * g++ è l' | ||
+ | La compilazione consiste di due operazioni: | ||
+ | - // | ||
+ | - //linking// (collegamento del file oggetto con altri file oggetto indispensabili) | ||
+ | {{ : | ||
+ | Il modo più semplice di capire come funziona un programma compilatore è provare i seguenti esempi da riga di comando: | ||
+ | * Codice per ottenere un file oggetto (file.o) a partire dal codice sorgente (file.cpp) | ||
+ | < | ||
+ | * Codice per ottenere un file eseguibile (file.exe) a partire dal codice sorgente (file.cpp). Oltre alla compilazione, | ||
+ | < | ||
+ | Per eseguire un programma ad interfaccia testuale, si dovrebbe aprire prima il //prompt dei comandi// e digitare il percorso e il nome del programma che si vuole eseguire. | ||
+ | |||
+ | ===== Editor a sintassi evidenziata ===== | ||
+ | Alcuni esempi di programmi che colorano le parole chiave sono: | ||
+ | * http:// | ||
+ | * http:// | ||
+ | ===== IDE (Integrated Development Environment) ===== | ||
+ | |||
+ | Invece di usare un semplice editor di testo, esistono degli ambienti di sviluppo integrati con il compilatore. Ad esempio: codelite, qtcreator, codeblock, kdevelop. | ||
+ | |||
+ | Su questi programmi, per compilare basta premere lo strumento " | ||
+ | |||
+ | {{ : | ||
+ | |||
+ | https:// | ||
+ | ===== Imperativo e Dichiarativo ===== | ||
+ | Si è visto che i linguaggi possono essere compilati o interpretati. | ||
+ | In base al tipo di istruzioni si distinguono anche linguaggi imperativi e dichiarativi. | ||
+ | |||
+ | Un linguaggio di programmazione di tipo // | ||
+ | |||
+ | Un linguaggio di programmazione di tipo // | ||
+ | |||
+ | ===== Funzione main() ===== | ||
+ | Per esercizio spiegare a parole cosa viene svolto da ogni programma.... | ||
+ | |||
+ | <file cpp 01.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | // contiene il codice minimo, cioè indispensabile | ||
+ | // anche quando il programma non effettua nessuna operazione | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | Il codice di ogni programma scritto in linguaggio C++ contiene sempre una funzione chiamata //main()//, che significa " | ||
+ | La sequenza di istruzioni inizia con la parentesi graffa aperta e termina con la parentesi graffa chiusa. Oltre alla funzione main() ci possono essere anche altre funzioni. | ||
+ | |||
+ | Quando viene eseguito un programma, il sistema operativo manda in esecuzione solo la funzione main() e questa si conclude con il comando //return 0//. | ||
+ | ==== Valore restituito ==== | ||
+ | Di che valore si tratta? Chi restituisce questo valore? A chi lo restituisce? | ||
+ | La funzione //main()// mediante l' | ||
+ | |||
+ | Oltre al main() ci possono essere molte altre funzioni che restituiscono un valore. Vedere [[appunti3s: | ||
+ | ====Note sul precedente codice ==== | ||
+ | |||
+ | * Il fatto che la funzione //main()//, alla fine, restituisca al sistema operativo un valore intero, **dovrebbe** essere sempre indicato con //int// davanti al nome //main()//. | ||
+ | * Le istruzioni in C++ devono essere terminate con un //punto e virgola// (;). | ||
+ | * Ogni blocco di codice che rappresenta un'// | ||
+ | * Le righe che iniziano con due slash (/) sono considerate commenti (una spiegazione per aiutare il lettore). | ||
+ | |||
+ | ===== Parole chiave ===== | ||
+ | Molte delle parole scritte in un programma sono parole della lingua inglese ma hanno un significato speciale per il computer. Se per errore si sbaglia una sola lettera su una sola parola, il programma può diventare // | ||
+ | |||
+ | Per esercizio **trovare gli errori** in questi programmi. | ||
+ | |||
+ | <file cpp 01error.cpp> | ||
+ | // questo programma contiene degli errori da trovare | ||
+ | // suggerimento: | ||
+ | int main() | ||
+ | { | ||
+ | retrun 0; | ||
+ | } | ||
+ | </ | ||
+ | <file cpp 02error.cpp> | ||
+ | // questo programma contiene degli errori da trovare | ||
+ | // suggerimento: | ||
+ | int main | ||
+ | { | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | |||
+ | ===== Variabili ===== | ||
+ | <file cpp 02.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | int somma; // definizione di una variabile locale (della funzione main) | ||
+ | somma = 11+2; // il programma modifica il contenuto della memoria ma non e' visibile nessun effetto... | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | Le variabili sono delle zone di memoria (paragonabili a dei contenitori) dove viene memorizzato un valore numerico. Le // | ||
+ | * Una variabile che si trova dentro il codice di una funzione è chiamata " | ||
+ | * Ogni variabile ha un nome identificatore che la distingue: nella stessa funzione //non// ci possono essere due variabili con lo stesso nome. | ||
+ | * Ogni variabile ha un //tipo di dato// (numerico, carattere, ecc.) e quindi occupa una certa quantità di memoria. | ||
+ | * Su ogni tipo di dato si possono eseguire solo alcuni tipi di operazioni. | ||
+ | ===== Tipo di dato ===== | ||
+ | |||
+ | Il valore contenuto in una variabile può essere modificato, ma deve essere sempre dello stesso tipo. | ||
+ | Ad esempio, tipo intero (-3, 44, ...), tipo carattere alfanumerico (' | ||
+ | * Ogni tipo di dato (intero, carattere, ecc.) richiede una quantità di memoria diversa dall' | ||
+ | * Ogni tipo di dato offre la possibilità di effettuare un certo tipo di operazioni invece di altre: il tipo carattere non può essere sommato come il tipo intero. | ||
+ | * In C++, una variabile può essere di un solo tipo di dato, quindi il linguaggio è detto // | ||
+ | * Esiste la possibilità di traferire un valore di un certo tipo (ad esempio, carattere), in una variabile di un tipo diverso (ad esempio, numerico intero) ma ci sono delle regole rigidissime da rispettare... (vedere operazione di [[appunti3s: | ||
+ | |||
+ | In C++ esistono tipi primitivi (built in), come //int//, //bool//, //char//, //float//, //double//, ma il programmatore può creare anche nuovi tipi di dati. | ||
+ | Inoltre la libreria standard fornisce nuovi tipi di dati come //string//, // | ||
+ | |||
+ | ==== Casting ==== | ||
+ | I seguenti operatori permettono di cambiare il tipo di un dato, ad esempio da numero intero a numero con virgola mobile: | ||
+ | |||
+ | * static_cast | ||
+ | * const_cast | ||
+ | * reinterpretet_cast (con puntatori) | ||
+ | * dynamic_cast (con puntatori ad oggetti classe) | ||
+ | Inoltre, in C++ si può usare per il casting la stessa sintassi del linguaggio C (// | ||
+ | === static_cast< | ||
+ | Ad esempio, date due variabili intere //i// e //j//: | ||
+ | * < | ||
+ | * < | ||
+ | // (tra un double e un int) </ | ||
+ | |||
+ | ===== Inizializzazione ===== | ||
+ | Al momento della // | ||
+ | < | ||
+ | |||
+ | Nel caso in cui l'area di memoria rimanesse non inizializzata, | ||
+ | |||
+ | ===== Assegnazioni ===== | ||
+ | Una variabile può, durante la sua vita, contenere diversi valori. L' | ||
+ | < | ||
+ | Il valore da memorizzare si trova a destra del segno di //uguale//, la variabile dove il valore viene memorizzato si trova a sinistra dell' | ||
+ | < | ||
+ | Per questo motivo spesso l' | ||
+ | < | ||
+ | In C++ è lecito assegnare una variabile su se stessa: | ||
+ | < | ||
+ | Una assegnazione su una variabile può modificare se stessa (attenzione! eseguire prima l' | ||
+ | < | ||
+ | La precedente scrittura, ovviamente, non deve essere letta come se fosse un' | ||
+ | |||
+ | |||
+ | |||
+ | ==== Operazioni su int ==== | ||
+ | |||
+ | Le classiche operazioni aritmetiche hanno un preciso ordine di precedenza. In questo elenco quelle più in in alto hanno precedenza maggiore, mentre quelle che si trovano sulla stessa riga hanno lo stesso ordine di precedenza: | ||
+ | |||
+ | * negazione, incremento e decremento: < | ||
+ | * aritmetici < | ||
+ | * aritmetici < | ||
+ | * confronto < | ||
+ | * logici < | ||
+ | * logici < | ||
+ | * assegnazione < | ||
+ | |||
+ | === Incremento === | ||
+ | L' | ||
+ | |||
+ | <code cpp incremento.cpp> | ||
+ | #include < | ||
+ | int main() | ||
+ | { | ||
+ | int a=0, b=0, x=100; | ||
+ | a = ++x; // prima incrementa x, poi esegue l' | ||
+ | // x vale 101, a vale 101 | ||
+ | | ||
+ | |||
+ | b = x++; // prima esegue l' | ||
+ | // x vale 102, b vale 101 | ||
+ | | ||
+ | | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | Questi effetti " | ||
+ | < | ||
+ | |||
+ | === La verità === | ||
+ | In realtà, anche se i commenti nel precedente programma sembrano spiegare correttamente il risultato che si ottiene | ||
+ | |||
+ | Per sapere cosa accade veramente bisogna conoscere bene il significato del termine // | ||
+ | Anche l' | ||
+ | |||
+ | Si deve immaginare che venga prima eseguita l' | ||
+ | - < | ||
+ | - l' | ||
+ | - dentro x viene memorizzato 102 | ||
+ | - x++ restituisce 101, come se fosse sostituito dal valore 101, come nella seguente fittizia istruzione: | ||
+ | - < | ||
+ | |||
+ | Viceversa l' | ||
+ | |||
+ | ===== Input e output ===== | ||
+ | |||
+ | Quelli che seguono sono due esempi di output sul terminale: | ||
+ | |||
+ | <file cpp 03.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | |||
+ | #include < | ||
+ | // che cosa contiene il file iostream? | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | int somma; | ||
+ | somma = 11+2; | ||
+ | std::cout << somma << std::endl; | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | <file cpp 04.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | #include < | ||
+ | int main () | ||
+ | { | ||
+ | std::cout << 11+2 << std:: | ||
+ | std::cout << 11/2 << std:: | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | ==== std::cin - std::cout - std::cerr ==== | ||
+ | CONSOLE INPUT, OUTPUT ed ERROR | ||
+ | |||
+ | Sono oggetti che appartengono alla libreria standard, con header: | ||
+ | < | ||
+ | Appartengono al namespace //std//. Non sono funzioni, ma oggetti (di tipo classe). | ||
+ | |||
+ | Per approfondire il significato del namespace //std// vedere [[appunti3s: | ||
+ | |||
+ | === operatore Extractor >> === | ||
+ | Extractor preleva // | ||
+ | < | ||
+ | * è insensibile agli eventuali spazi iniziali (o tabulazioni) | ||
+ | * termina la lettura al primo spazio (o invio o tabulazione) | ||
+ | * la funzione // | ||
+ | * la funzione // | ||
+ | |||
+ | === operatore Insertion << === | ||
+ | Insertion deposita // | ||
+ | < | ||
+ | * il valore speciale // | ||
+ | |||
+ | < | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | // visualizza solo un semplice testo (sempre lo stesso) | ||
+ | #include < | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | std::cout << "Ciao a tutti!" | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | <file cpp 06errore.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | // legge un dato alla volta dalla tastiera e lo visualizza | ||
+ | |||
+ | #include < | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | int mioNumero1; | ||
+ | std::cout << "Per favore scrivi due numeri separati dallo spazio bianco: "; | ||
+ | std::cin >> mioNumero1; | ||
+ | std::cout << "Hai inserito: " << mioNumero1 << std:: | ||
+ | |||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | <file cpp 06.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | // legge un dato alla volta dalla tastiera e lo visualizza | ||
+ | |||
+ | #include < | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | int mioNumero1, mioNumero2; | ||
+ | std::cout << "Per favore scrivi due numeri separati dallo spazio bianco: "; | ||
+ | std::cin >> mioNumero1 >> mioNumero2 ; // legge entrambi i numeri separati dallo spazio | ||
+ | std::cout << "Hai inserito: " << mioNumero1 << " e " << mioNumero2 << std:: | ||
+ | |||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | |||
+ | <file cpp 07.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | // visualizza anche i simboli in codifica UTF-8 | ||
+ | |||
+ | #include < | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | std::cout << "Per favore scrivi un numero intero: "; | ||
+ | int mioNumero; | ||
+ | std::cin >> mioNumero; | ||
+ | std::cout << "Tu hai in tasca " << mioNumero << " | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | <file cpp 07errato.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | // contiene degli errori che devono essere trovati | ||
+ | |||
+ | #include < | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | int mioNumero; | ||
+ | std::cout << "Per favore scrivi un numero intero: "; | ||
+ | std::cin >> mioNumero; | ||
+ | std::cout << "Tu hai in tasca " << mioNumero << " | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | |||
+ | |||
+ | L'uso delle direttive al compilatore diverrà più chiaro nei prossimi capitoli | ||
+ | |||
+ | ===== Virgola mobile ===== | ||
+ | L' | ||
+ | |||
+ | <file cpp 08.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | #include < | ||
+ | int main () | ||
+ | { | ||
+ | float divisione; | ||
+ | // | ||
+ | divisione = 11.0/2.0; | ||
+ | std::cout << divisione << std::endl; | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | ==== Manipolatori permanenti ==== | ||
+ | I manipolatori di output permettono di trattare il testo prima di visualizzarlo. | ||
+ | Alcuni hanno un effetto temporaneo, molti hanno un effetto permanente (vanno annullati esplicitamente) | ||
+ | |||
+ | <file c base.cpp> | ||
+ | #include < | ||
+ | #include < | ||
+ | int main() | ||
+ | { | ||
+ | std::cout << 44 << std:: | ||
+ | std::cout << std:: | ||
+ | std::cout << std::hex << 44 << std:: | ||
+ | std::cout << std:: | ||
+ | std::cout << std::dec << 44 << std:: | ||
+ | std::cout << std:: | ||
+ | std::cout << std::fixed << 99.123465 << std:: | ||
+ | std::cout << std:: | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | ==== Errori di conversione ==== | ||
+ | |||
+ | Per i numeri interi (positivi o negativi) la conversione tra sistema base 10 e base 2 del computer è sempre esatta e priva di errori. | ||
+ | Dal punto di vista matematico invece possono accadere dei problemi con i numeri decimali (con virgola). | ||
+ | vedi [[http:// | ||
+ | |||
+ | I numeri decimali vengono memorizzati in due valori, mantissa ed esponente: | ||
+ | MANTISSA * BASE< | ||
+ | |||
+ | Anche le calcolatrici usano questa notazione esponenziale: | ||
+ | |||
+ | * La prima osservazione: | ||
+ | * Una seconda osservazione: | ||
+ | |||
+ | In tutti i casi appena descritti, poiché il computer ha un numero di cifre limitato, commetterà sicuramente un errore nel calcolo... | ||
+ | |||
+ | < | ||
+ | Tabella tratta da http:// | ||
+ | Converting Result | ||
+ | 0.1 0. | ||
+ | 0.1 × 2 = 0.2 < 1 0.0 | ||
+ | 0.2 × 2 = 0.4 < 1 0.00 | ||
+ | 0.4 × 2 = 0.8 < 1 0.000 | ||
+ | 0.8 × 2 = 1.6 ≥ 1 0.0001 | ||
+ | 0.6 × 2 = 1.2 ≥ 1 0.00011 | ||
+ | 0.2 × 2 = 0.4 < 1 0.000110 | ||
+ | 0.4 × 2 = 0.8 < 1 0.0001100 | ||
+ | 0.8 × 2 = 1.6 ≥ 1 0.00011001 | ||
+ | 0.6 × 2 = 1.2 ≥ 1 0.000110011 | ||
+ | 0.2 × 2 = 0.4 < 1 0.0001100110 | ||
+ | </ | ||
+ | |||
+ | <file cpp 09.cpp> | ||
+ | |||
+ | // questo programma è stato scritto da Fabio | ||
+ | // | ||
+ | // mostra che la differenza 1.1 - 1.0 non fa 0.1 | ||
+ | // perché per esprimere 0.1 (in base 2) comporta degli errori di troncamento. | ||
+ | // Gli errori diventano visibili solo quando si guardano un numero elevato di cifre | ||
+ | // in un sistema a 32 bit, il risultato della differenza dovrebbe essere | ||
+ | |||
+ | #include < | ||
+ | #include < | ||
+ | int main () | ||
+ | { | ||
+ | float differenza; | ||
+ | differenza = 1.1-1.0; | ||
+ | std::cout << std:: | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | |||
+ | ===== Uso delle costanti ===== | ||
+ | Confrontare i seguenti due programmi... | ||
+ | <file cpp 10.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | // per calcolare la propria eta' | ||
+ | |||
+ | #include < | ||
+ | #include < | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | std::string mioNome; | ||
+ | std::cout << "Per favore scrivi il nome: "; | ||
+ | std::cin >> mioNome; | ||
+ | |||
+ | int mioAnnoNascita; | ||
+ | std::cout << "Per favore scrivi l'anno di nascita: "; | ||
+ | std::cin >> mioAnnoNascita; | ||
+ | |||
+ | std::cout << mioNome << ", quest' | ||
+ | << 2012-mioAnnoNascita << " anni." << std::endl; | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | <file cpp 11.cpp> | ||
+ | // questo programma è stato scritto da Fabio | ||
+ | // a volte è necessario creare dei valori costanti che | ||
+ | // il programmatore può modificare facilmente in un solo punto del codice | ||
+ | |||
+ | #include < | ||
+ | #include < | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | const int annoAttuale=2012; | ||
+ | |||
+ | std::string mioNome; | ||
+ | std::cout << "Per favore scrivi il nome: "; | ||
+ | std::cin >> mioNome; | ||
+ | |||
+ | int mioAnnoNascita; | ||
+ | std::cout << "Per favore scrivi l'anno di nascita: "; | ||
+ | std::cin >> mioAnnoNascita; | ||
+ | |||
+ | std::cout << mioNome << ", quest' | ||
+ | << annoAttuale-mioAnnoNascita << " anni." << std::endl; | ||
+ | return 0; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | |||
+ | ===== Stile di indentazione ===== | ||
+ | L' | ||
+ | |||
+ | esempio: http:// | ||
+ | |||
+ | Lo stile da usare è abbastanza libero, ma va usato coerentemente. | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | =====Enumeration===== | ||
+ | [[appunti3s: | ||
+ | ===== Verifica ===== | ||
+ | - Cosa significa main()? | ||
+ | - Cosa significa return? | ||
+ | - Che significa il punto e virgola? | ||
+ | - Cosa significano le parentesi graffe? | ||
+ | - Cosa significa il termine assegnazione? | ||
+ | - Che cosa significano il doppio slash %%//%%? | ||
+ | - Fare un esempio di indentazione, | ||
+ | - Quali sono i tipi primitivi semplici del linguaggio C++? | ||
+ | - Che significa linguaggio " | ||
+ | - Che significa linguaggio " | ||
+ | - Programmi imperativi da scrivere: | ||
+ | - esercizio: chiedere due numeri e visualizzare la somma | ||
+ | - esercizio: chiedere due numeri e visualizzare la media aritmetica | ||
+ | - esercizio: chiedere un nome e un anno di nascita e poi visualizzare nome ed età | ||
+ | |||
+ | >> per tornare all' | ||