Problem Solving E Programmazione In C
- ISBN/EAN
- 9788838786419
- Editore
- Maggioli Editore
- Collana
- Idee e strumenti
- Formato
- Brossura
- Anno
- 2013
Disponibile
42,00 €
Prima di scrivere un programma è necessario individuare la soluzione del problema in termini di algoritmo, per poi scrivere il programma nel linguaggio scelto. Questa è una sfida che mette alla prova la capacità di capire i requisiti, i dati a disposizione e di trovare una strategia che porti alla soluzione desiderata.
Pochi libri di programmazione affrontano questo aspetto importante. "Problem solving e programmazione in C", uno dei testi più utilizzati nella didattica a livello internazionale, costituisce un'eccezione: spiega come risolvere problemi mediante lo sviluppo di programmi utilizzando il linguaggio C. Gli autori possono così discutere in modo approfondito le scelte fatte nello sviluppo del programma, spiegando gli obiettivi e le motivazioni che stanno alla base del codice sviluppato.
Il volume presenta tutti i costrutti fondamentali del linguaggio C, offrendo un’immagine dettagliata delle sue potenzialità per progettare soluzioni ben organizzate leggibili e riusabili. Un’ampia selezione di casi di studio ed esercizi proposti permette di consolidare le conoscenze.
Indice
- Panoramica sui sistemi di calcolo e la programmazione
- Introduzione al linguaggio C
- Progettazione top-down mediante sottoprogrammi
- Istruzioni di selezione
- Cicli
- Puntatori e programmazione modulare
- Array
- Stringhe
- Ricorsione
- Strutture e unioni
- File di testo e binari
- Programmazione in grande
- Strutture dati dinamiche
Gli autori Jeri Hanly è docente di Computer Science presso la University of Wyoming e altri atenei statunitensi.
Elliot Koffman è professore presso il dipartimento di Computer and Information Sciences della Temple University ed è un esperto riconosciuto a livello mondiale nel campo della didattica per l'informatica. È autore di numerosi e apprezzati volumi dedicati ai linguaggi di programmazione. Nel 2009 ha ricevuto il riconoscimento ACM-SIGCSE for Oustanding Contribution to Computer Science Education. L'edizione italiana è curata da Cristiana Bolchini, docente presso il Dipartimento di elettronica e informazione del Politecnico di Milano.
Maggiori Informazioni
| Autore | Hanly Jeri R.; Koffmann Elliot B.; Bolchini C. |
|---|---|
| Editore | Maggioli Editore |
| Anno | 2013 |
| Tipologia | Libro |
| Collana | Idee e strumenti |
| Num. Collana | 0 |
| Lingua | Italiano |
| Indice | Prefazione.......................................................................................................................................xv L’utilizzo del linguaggio C per insegnare a sviluppare programmi...........................xv Puntatori e organizzazione del testo......................................................................xvi Concetti di ingegneria del software.......................................................................xvi Aspetti pedagogici...............................................................................................xvii Ringraziamenti...................................................................................................xviii Note alla traduzione........................................................................................................................ xix Capitolo 1 – Introduzione ai calcolatori e alla programmazione...........................................................1 1.1 I calcolatori elettronici, ieri e oggi.................................................................. 2 1.2 L’architettura del calcolatore........................................................................... 5 Memoria........................................................................................................ 6 L’unità centrale di elaborazione....................................................................... 9 I dispositivi di ingresso/uscita........................................................................10 Reti di calcolatori.........................................................................................10 1.3 Il software del calcolatore...............................................................................12 Il sistema operativo........................................................................................12 Le applicazioni..............................................................................................14 Linguaggi per calcolatori...............................................................................15 Eseguire un programma.................................................................................18 1.4 Il metodo di sviluppo del software.................................................................19 Il metodo di sviluppo del software.................................................................19 Attenzione: il fallimento fa parte del processo.................................................22 1.5 L’applicazione del metodo di sviluppo del software........................................22 1.6 Etica professionale per i programmatori.........................................................25 Privacy e uso improprio di dati......................................................................25 Violazioni (hacking)......................................................................................25 Plagio e pirateria...........................................................................................26 Uso improprio delle risorse...........................................................................26 Capitolo 2 – Panoramica del linguaggio C.........................................................................................31 2.1 Gli elementi del linguaggio C........................................................................32 Direttive al preprocessore...............................................................................33 Riquadro della sintassi per le direttive al preprocessore...................................33 Sottoprogramma main...................................................................................34 Termini riservati............................................................................................35 Identificatori standard....................................................................................35 Identificatori definiti dall’utente....................................................................36 Lettere maiuscole e minuscole.......................................................................37 Stile di programmazione – La scelta dei nomi degli identificatori...................37 2.2 Le dichiarazioni di variabile e i tipi di dato....................................................38 Dichiarazione di variabile..............................................................................38 I tipi di dati...................................................................................................39 Le differenze tra tipi di dati numerici.............................................................40 Il codice ASCII.............................................................................................42 2.3 Istruzioni eseguibili.......................................................................................43 I programmi in memoria...............................................................................44 Istruzioni di assegnamento.............................................................................44 Assegnamento a una variabile di tipo char......................................................46 Operazioni di acquisizione/visualizzazione e sottoprogrammi........................46 Il sottoprogramma printf................................................................................47 Il sottoprogramma scanf.................................................................................49 Il costrutto return..........................................................................................51 2.4 Forma generale di un programma C..............................................................52 Stile di programmazione – Spazi nel codice...................................................53 Commenti nei programmi.............................................................................54 Stile di programmazione – L’uso dei commenti..............................................55 2.5 Espressioni aritmetiche..................................................................................56 Gli operatori / e %........................................................................................56 Tipo di dato di un’espressione.......................................................................58 Istruzioni di assegnamento con tipi misti........................................................58 Conversione di tipo mediante il cast..............................................................59 Caratteri come interi.....................................................................................59 Espressioni con più operatori.........................................................................60 Scrivere formule matematiche in C...............................................................63 Imprecisioni numeriche.................................................................................64 2.6 La formattazione di numeri in uscita dai programmi......................................69 La formattazione di valori di tipo int.............................................................69 La formattazione di valori di tipo double.......................................................70 Stile di programmazione – Eliminare spazi bianchi extra................................71 2.7 Modalità interattiva, batch e file dati..............................................................71 Redirezione dell’input...................................................................................72 Stile di programmazione – Echo o prompt.....................................................73 Redirezione dell’output.................................................................................73 2.8 Errori comuni...............................................................................................74 Errori di sintassi.............................................................................................74 Errori di run-time.........................................................................................76 Errori non rilevati.........................................................................................76 Errori logici..................................................................................................79 Capitolo 3 – Progettazione top-down mediante sottoprogrammi......................................................85 3.1 Costruire programmi a partire da informazioni esistenti.................................86 3.2 Sottoprogrammi di libreria............................................................................94 Sottoprogrammi predefiniti e riuso del codice...............................................94 Utilizzo del grigio per evidenziare nuovi costrutti..........................................96 Le librerie di sottoprogrammi C....................................................................96 Uno sguardo in avanti....................................................................................99 3.3 Progettazione top-down e diagrammi di struttura........................................100 3.4 Sottoprogrammi senza parametri..................................................................102 Prototipi......................................................................................................103 Definizione di un sottoprogramma..............................................................104 Posizionamento dei sottoprogrammi............................................................106 Stile di programmazione – L’utilizzo di commenti in un programma con sottoprogrammi....................................................................................107 Ordine di esecuzione dei sottoprogrammi e del main...................................107 Vantaggi dell’uso di sottoprogrammi............................................................108 Visualizzare le istruzioni all’utente...............................................................109 3.5 Sottoprogrammi con parametri in ingresso...................................................111 Sottoprogrammi void con parametri in ingresso...........................................112 Sottoprogrammi con parametri in ingresso e un unico risultato....................113 Stile di programmazione – Commento interfaccia del sottoprogramma.....................................................................................115 Sottoprogrammi con molteplici parametri....................................................116 Corrispondenza tra i parametri della lista.....................................................118 L’area dati di un sottoprogramma.................................................................118 Fare il test di sottoprogramma con un sottoprogramma di collaudo..............119 3.6 Introduzione alla grafica (facoltativo)...........................................................120 Creazione di una finestra.............................................................................120 Alcuni sottoprogrammi grafici comuni........................................................121 Stile di programmazione – La notazione “a cammello”.................................123 Colori dello sfondo e di primo piano...........................................................123 Disegnare rettangoli.....................................................................................124 Disegnare cerchi, ellissi e archi.....................................................................126 Stile di programmazione – Scrivere programmi grafici di uso generale............................................................................................128 Insidie – L’ordine scorretto dell’uso dei sottoprogrammi modifica il disegno......................................................................................131 Fette di torta ed ellissi colorate.....................................................................131 Aggiungere testo ai disegni..........................................................................133 3.7 Errori comuni.............................................................................................135 Capitolo 4 – Istruzioni di selezione.................................................................................................145 4.1 Strutture di controllo...................................................................................146 4.2 Condizioni..................................................................................................146 Operatori relazionali e di uguaglianza..........................................................147 Operatori logici...........................................................................................148 Precedenza degli operatori...........................................................................149 Valutazione a cortocircuito..........................................................................150 Tradurre condizioni dal linguaggio naturale al linguaggio C.........................151 Confrontare i caratteri.................................................................................153 Assegnamento logico...................................................................................153 Calcolare il complemento di una condizione...............................................155 4.3 Il costrutto if...............................................................................................157 Il costrutto if con due alternative.................................................................157 Il costrutto if con una sola alternativa...........................................................159 Un confronto tra il costrutto if con una e con due alternative......................159 Stile di programmazione – Formato del costrutto if.....................................160 4.4 Il costrutto if con blocchi di istruzioni.........................................................162 Stile di programmazione – Scrivere costrutti if con blocchi di codice...........163 Seguire l’esecuzione di un costrutto if..........................................................163 4.5 Passi decisionali negli algoritmi....................................................................165 Stile di programmazione – Uso coerente dei nomi nei sottoprogrammi........172 Stile di programmazione – Sottoprogrammi coesi........................................173 Stile di programmazione – Uso delle macro costanti per migliorare la leggibilità e facilitare la manutenzione......................................................173 4.6 Ancora problem solving...............................................................................174 Informazioni sul flusso dei dati nei diagrammi di struttura............................174 Modificare un programma introducendo dei sottoprogrammi.......................174 4.7 Costrutti if annidati e decisioni con alternative multiple...............................177 Confronto tra if annidati e sequenze di if.....................................................178 Formato di decisioni ad alternativa multipla con if annidato.........................178 L’ordine delle condizioni in una decisione ad alternativa multipla.................180 Stile di programmazione – Validare il valore delle variabili............................182 Costrutti if annidati con più di una variabile................................................182 4.8 Il costrutto switch........................................................................................187 Confronto tra il costrutto if annidato e il costrutto switch............................190 4.9 Errori comuni.............................................................................................192 Capitolo 5 – I cicli...........................................................................................................................205 5.1 L’iterazione nei programmi..........................................................................206 5.2 I cicli di conteggio e l’istruzione while........................................................208 L’istruzione while........................................................................................208 5.3 Accumulazione di una somma o di un prodotto in un ciclo.........................211 Stile di programmazione – Scrivere cicli generici........................................213 Moltiplicare una lista di numeri...................................................................214 Operatori di assegnamento composto..........................................................214 5.4 L’istruzione for............................................................................................216 Stile di programmazione – Formattazione del costrutto for..........................217 Operatori di incremento o decremento.......................................................218 Incrementi e decrementi di valori diversi da 1..............................................220 Visualizzare una tabella di valori..................................................................222 5.5 Cicli con condizione generica.....................................................................223 Stile di programmazione – Eseguire le elaborazioni del ciclo in un sottoprogramma.................................................................................228 5.6 Progettazione dei cicli.................................................................................229 Cicli controllati da un valore sentinella........................................................230 Utilizzare il costrutto for per scrivere un ciclo controllato da un valore sentinella.................................................................................232 Cicli controllati dalla fine del file.................................................................232 Cicli infiniti causati da dati errati.................................................................234 5.7 Cicli annidati...............................................................................................235 5.8 Il costrutto do-while e i cicli controllati da una variabile flag.......................239 Cicli controllati da una variabile flag per la validazione dei dati acquisiti.......240 5.9 Metodi iterativi...........................................................................................243 Parametri di tipo sottoprogramma................................................................243 5.10 Debug e test dei programmi........................................................................251 Utilizzo di programmi di debug...................................................................252 Debug senza il debugger..............................................................................252 Errori dovuti a un’iterazione di troppo o una di meno.................................253 Test.............................................................................................................254 5.11 I cicli nei programmi di grafica (facoltativo).................................................254 Animazioni.................................................................................................257 5.12 Errori comuni.............................................................................................260 Capitolo 6 – Puntatori e programmazione modulare.......................................................................277 6.1 I puntatori e l’operatore di dereferenziazione...............................................278 Riferimento indiretto..................................................................................279 Puntatori a file............................................................................................279 6.2 Sottoprogrammi con parametri in uscita......................................................282 Significato del simbolo *.............................................................................287 6.3 Chiamate multiple a sottoprogrammi con parametri in ingresso e uscita.......289 Stile di programmazione – I tipi di sottoprogramma da preferirsi..................292 6.4 Visibilità dei nomi.......................................................................................294 6.5 Parametri formali in uscita utilizzati come parametri attuali..........................296 6.6 Problem solving illustrato............................................................................300 Sottoprogrammi per il calcolo con frazioni..................................................306 6.7 Debug e test di un programma completo.....................................................314 Suggerimenti per il debug di un programma completo................................316 6.8 Errori comuni.............................................................................................316 Capitolo 7 – Array..........................................................................................................................333 7.1 Dichiarazione e accesso a un array...............................................................334 Inizializzazione di un array..........................................................................335 Memorizzare una stringa in un array di caratteri..........................................336 7.2 Indici di array..............................................................................................337 7.3 Utilizzo di cicli per l’accesso sequenziale agli array.......................................339 Calcolo statistico facendo uso di array..........................................................339 Stile di programmazione – Usare le variabili di controllo di un ciclo come indici di un array..............................................................342 7.4 Elementi di un array come parametri di un sottoprogramma........................343 7.5 Un array come parametro di un sottoprogramma.........................................345 Array come parametri..................................................................................345 Corrispondenza dei parametri di un sottoprogramma nel caso di array.........346 Array come parametri di ingresso................................................................348 Restituire un array come risultato................................................................349 Array parzialmente riempiti.........................................................................352 Pile.............................................................................................................354 7.6 Ricerca di un elemento e ordinamento di un array......................................357 Ricerca all’interno di un array.....................................................................358 Ordinamento di un array.............................................................................359 7.7 Array paralleli e tipi di dato enumerativi......................................................362 Tipi di dato enumerativo.............................................................................364 Array con indice di tipo enumerativo...........................................................367 7.8 Array multidimensionali..............................................................................369 Inizializzazione di un array multidimensionale.............................................371 Array con molte dimensioni........................................................................372 7.9 Esempio dettagliato della manipolazione di un array....................................374 7.10 Programmi grafici con array (facoltativo).....................................................382 Disegnare un poligono................................................................................382 Stile di programmazione – Usare un array di caratteri per memorizzare un messaggio....................................................................384 Generazione di un numero casuale..............................................................384 Inizializzare un generatore di numeri casuali................................................385 Disegnare una griglia...................................................................................385 7.11 Errori comuni.............................................................................................390 Capitolo 8 – Le stringhe..................................................................................................................405 8.1 Nozioni di base sulle stringhe......................................................................406 Dichiarare e inizializzare variabili di tipo stringa...........................................406 Array di stringhe.........................................................................................407 Acquisizione/visualizzazione con i sottoprogrammi scanf e printf.................407 8.2 Sottoprogrammi della libreria string: assegnamento e sottostringhe...............412 Assegnamento tra stringhe...........................................................................412 Sottostringhe...............................................................................................414 8.3 Stringhe più lunghe: concatenazione e acquisizione di un’intera riga in ingresso.........................................................................420 Concatenazione...........................................................................................420 Distinzioni tra caratteri e stringhe................................................................421 Acquisizione di un’intera riga di testo..........................................................422 8.4 Confronto tra stringhe.................................................................................425 8.5 Array di puntatori.......................................................................................427 Array di stringhe costanti.............................................................................432 8.6 Operazioni sui caratteri...............................................................................433 Acquisizione/visualizzazione di caratteri......................................................433 Analisi e conversione di caratteri..................................................................435 8.7 Conversioni da stringa a numero e da numero a stringa................................437 8.8 L’elaborazione illustrata di stringhe..............................................................443 8.9 Errori comuni.............................................................................................451 Capitolo 9 – Ricorsione...................................................................................................................463 9.1 L’essenza della ricorsione.............................................................................464 9.2 Tracciare l’esecuzione di un sottoprogramma ricorsivo.................................469 Tracciare l’esecuzione di un sottoprogramma che restituisce un valore..........469 Tracciare l’esecuzione di un sottoprogramma void.......................................470 Pile di parametri e variabili locali.................................................................473 Realizzazione di una pila di parametri in linguaggio C................................475 Quando e come eseguire la traccia di un sottoprogramma ricorsivo..............475 9.3 Sottoprogrammi matematici ricorsivi...........................................................476 9.4 Sottoprogrammi ricorsivi con array e stringhe come parametri....................482 9.5 Risoluzione di problemi tramite l’uso della ricorsione..................................488 9.6 Un caso di studio classico per la ricorsione: le torri di Hanoi.......................495 Confronto tra sottoprogrammi iterativi e sottoprogrammi ricorsivi...............498 9.7 Errori comuni.............................................................................................500 Capitolo 10 – Strutture e unioni......................................................................................................509 10.1 Tipi di dato strutturato definiti dall’utente...................................................510 Definizione di tipo per variabili struttura.....................................................510 Modificare i campi di una variabile struttura................................................512 Ripasso sulla precedenza tra gli operatori.....................................................513 Manipolazione di intere variabili strutture....................................................514 Stile di programmazione – Convenzioni per i nomi dei tipi.........................514 10.2 Strutture come parametri in ingresso e uscita...............................................515 10.3 Sottoprogrammi che restituiscono una variabile struttura.............................520 10.4 Problem solving con tipi strutturati..............................................................523 10.5 Array paralleli e array di strutture.................................................................530 Array paralleli..............................................................................................530 Dichiarazione di un array di strutture...........................................................531 10.6 Tipi di dato unione (facoltativo)..................................................................539 10.7 Errori comuni.............................................................................................545 Capitolo 11 – Elaborazione di file di testo e file binari......................................................................557 11.1 File in ingresso e uscita: ripasso e ulteriori dettagli.......................................558 La tastiera e lo schermo come stream di testo...............................................558 Caratteri newline ed EOF...........................................................................559 Sequenze di escape......................................................................................559 Formattazione dell’uscita con il sottoprogramma printf................................560 Variabili di tipo puntatore a file....................................................................561 Sottoprogrammi che ricevono un puntatore a file come parametro..............563 Chiudere un file..........................................................................................563 11.2 File binari....................................................................................................567 11.3 Ricerca in un database.................................................................................572 11.4 Errori comuni.............................................................................................581 Capitolo 12 – Programmazione in grande.......................................................................................589 12.1 Utilizzare l’astrazione per gestire la complessità............................................590 Astrazione procedurale................................................................................590 Astrazione sui dati.......................................................................................591 Mascheramento dell’informazione...............................................................592 Codice riutilizzabile....................................................................................592 12.2 Librerie personali: i file di intestazione.........................................................593 File di intestazione.......................................................................................593 Precauzioni nella progettazione di file di intestazione...................................596 12.3 Librerie personali: file di implementazione...................................................597 Usare una libreria personale.........................................................................599 12.4 Classi di memorizzazione............................................................................600 Variabili globali............................................................................................600 Classi di memorizzazione static e register.....................................................603 12.5 Modificare sottoprogrammi per l’inclusione in una libreria..........................605 12.6 Compilazione condizionale.........................................................................607 12.7 Passare parametri al sottoprogramma principale............................................610 12.8 Definire macro costanti con parametri.........................................................613 Uso delle parentesi nel corpo di una macro..................................................614 Scrivere una macro su due o più linee..........................................................616 12.9 Errori comuni.............................................................................................617 Capitolo 13 – Strutture dati dinamiche...........................................................................................627 13.1 Puntatori.....................................................................................................628 Puntatori come parametri di sottoprogrammi..............................................629 Puntatori che rappresentano array e stringhe................................................630 Puntatore a strutture....................................................................................630 Riepilogo degli usi dei puntatori.................................................................630 13.2 Allocazione dinamica della memoria............................................................632 Effettuare l’accesso a un campo di una struttura allocata dinamicamente.......634 Allocazione dinamica di un array con il sottoprogramma calloc....................635 Ripulire le celle nello heap..........................................................................636 13.3 Liste concatenate.........................................................................................637 Strutture con campi puntatore.....................................................................638 Connettere più nodi....................................................................................638 Vantaggi delle liste concatenate....................................................................640 13.4 Operatori per liste concatenate....................................................................642 Attraversare una lista....................................................................................643 Creare una lista acquisendo dati in ingresso..................................................644 Cercare un valore in una lista.......................................................................646 Evitare di seguire un puntatore a NULL......................................................647 13.5 Rappresentare una pila con una lista concatenata.........................................648 13.6 Rappresentare una coda con una lista concatenata........................................651 13.7 Liste ordinate...............................................................................................656 13.8 Alberi binari................................................................................................667 Albero binario di ricerca..............................................................................669 Ricerca in un albero binario di ricerca.........................................................669 Costruire un albero binario di ricerca..........................................................670 Visualizzare un albero binario di ricerca.......................................................673 13.9 Errori comuni.............................................................................................676 Appendice A – Approfondimento sui puntatori...............................................................................685 A.1 Aritmetica dei puntatori..............................................................................685 A.2 Puntatori a puntatori...................................................................................687 Appendice B – Le librerie standard del linguaggio ANSI C................................................................691 Appendice C – Operatori del linguaggio C........................................................................................709 Operatori bit a bit................................................................................................711 Appendice D – Codifiche di caratteri...............................................................................................715 Appendice E – Parole riservate del linguagio ANSI C........................................................................717 Indice analitico..............................................................................................................................719 |
Questo libro è anche in: