Descripción: Istruzioni precise per realizzare oltre 100 effetti magici senza bisogno di avere maturato esperienza o abilità particolari. Ogni trucco è identificato da un livello di difficoltà da 1 a 5 ed è spi...
Descripción completa
cantoFull description
Descrição: FRANCO CERRI E MARIO GANGI
Corso Di Chitarra Blues
tratto da "Psicomagia una terapia panica" di Alejandro Jodorowsky
Cómo Programar C++ (Español-9ºEdición-Paul Deitel y Harvey Deitel)Descripción completa
Lo scopo di questo libro ............................ .................................................................... xi La metodologia di insegnamento .................................................................................. xii Lapprendimenro attraverso il codice ................................ ......... ...................... xii Laccesso al Wodd W ide Web .......................................................................... xii Obiettivi ............................ ..................................... ...... ................................... xi i
: Consigli e suggerimenà ........................... ... ...................................... ....... ....... xiii Esercizi di autovalutazione ............................................................................... xiv Esercizi ........... .. ..... ....................................... ... ........................................ ........ xiv Indice analitico ...................................................... .......................................... xiv Panoramica sul libro .. .......... ......... ............................. ............................................ ....... xiv C APITOLO I : N OZIONI SULLA ELABORAZIONE ELETTRONICA ••.... ... .•• ...••. ..• •..•.. .••. ...••. I
1.1
Inn:oduzione ...................................................................................................... 1 Che cosa è un computer? ................................................................................... 3 1.3 L'organizzazione del compucer ........................................................................... 3 1.4 L'elaborazione batch, la multiprogrammazione e il timesharing ........................ 4 1.5 L'elaborazione personale, distribuita e dient/server .......................................... 5 1.6 I linguaggi macchina, assemb.ly e di alto livello ....................... .. ...................... .. 6 1.7 La sroria del 7 1.8 La libreria standard del 8 1.9 Gli altri linguaggi di alto livello .......................................................................... 8 1.1 O La programmazione strutturata .................................................................. ........ 9 1.1 1 Le basi dell'ambiente c ................................................................................... 10 1.1 2 Note generali sul Ce su questo libro .... ................... ... ..................................... 12 1.13 Il Concurrenr C ................ .................. .. ... .... .................. ....... ..................... ...... 13 1.1 4 La programmazione orientata agli oggetti e il C++ .............................. ... ......... 13 Esercizi di autovalutazione .............. .................................... .......................................... 14 Risposte agli esercizi di autovalutazione ............... .................. ...................................... 14 Esercizi ..................................... .................................................................................... 15 Letture consigliare ....... ... ................... ........................................................................... 16 1.2
ISBN 88-7303-669-4 Traduzione cli Michele Trulli Revisione di Ivan Scagnetto Impaginazione di Guido e Gianfranco Giuseppini Realizzazione editoriale di Spock s.a.s. di Augusto Vico e c. Editor: Alberto Kratter Thaler Copertina e pcogetto grafico: Enrico Marcandalli Responsabile di produzione: Vitiano Zaini
Tutti i di.ritti sono riservati a norma di legge e a norma delle convenzioni intèrnazionali. Nessuna parte di questo ]jbro può essere riprodotta con sistemi elettronici, meccanici o altri, senza l'autorizzazione scritta dell'Editore. Nomi e marchi citati nel testo sono generalmente depositati o registraci dalle rispettive case produttrici.
c ................................................................................................... c ..................................................................................
CAPITOLO
2:
INTRODUZIONE ALLA PROGRAMMAZIONE IN C ...•. .... •......•.••• .•••• ••. ...•••
I9
2. 1 2.2
lnuoduzione ................... ......................................................................... ........ 19 Un semplice programma C: v.isualizzareuna riga di tesro .. .............................. 19 2.3 Un altro semplice programma C: sommare due interi .... ................................ 23 Nozioni sulla memoria .. .................................................................................. 28 2.4 2.5 L'arianetica del C ............................................................................................ 29 2.6 Prendere delle decisioni: gli operatori di uguaglianza e relazionali .................. 33 Esercizi di autovalutazione ..... .. ............. ........................ ... ............. ................................ 37
Email education@apogeonline .com U.R.L. www . apogeonline. com ISBN 88-7303-669-4 Tmduzione di Michele Trulli Revisione di l van Scagncu o l mp aginazione di Guido e Gianfranco Giusèppini RcaJizzazlone eclito ria le di Spock s.a.s. cli Augus to Vico e c. Editor: Alberto K.rnttcr Tbitler Copertina e progetto g rafi co: Eru:ico M arcandalli .Responsabile dJ proclnrionc: 'Vitiano Zaini
Tuto i diritti sono riservaci u norma di le~ e a no.an,1 delle convenzioni intc:roaz1on:ùi. Nessuna pane di questo libro può esi.erc ciprodoua con s1stcmj elettronici, mcccaruct o aJm, senza l'aucorizzaz1one senna dell'Edito!e. N omi e mardu citati nel resto sono generl}lmente depos1catì o ccgistraa dalle rispettive case produrtnct.
Lo scopo di questo libro ................................................. ........................................... .... xi la metodologia di insegnamento .................................................................................. xi i I.:apprendimcmo aa:raverso il codice ..........•..•................................................. xii t.:accesso al Wotld Wide Web .................... .. .................................................... xii Obic:n.ivi .......................................................................................................... xii Il codice e gli esempi ................. .. .................................................................... xii
Consigli e suggenmentt .... ........... ........~ ..... ................. .. ................................. x 111 E..~e rci·1.i di autovalucazione ............ .......... ........ .............. .. ........ ................. ... .. ... xiv Esercizi .............. ............................... ...... .. ..... ................ .................................. xiv 1n
1.1 1.2 1.3 l.4
Inrrod uzione .................................................. ............... ............................... ...... 1 C he cosa è un computer?................................................................................... 3
L'organizza:Lione del computer ........................................................................... 3 L'elabor.nione bacch , la multiprogrammazione e il timesharing ........................ 4 l.5 L'elaborazione personale. dimihuita e dient/server .......................................... 5 1.6 I linguaggi macchina, asscmbly e di aJro liveliQ................................................. 6 1.7 La scoria del 7 1.8 La l.ibrcna scand..ard del e .................................................................................. 8 1.9 Gli altri linguaggi di alto livello .......................................................................... 8 LIO La programmazione scrucrurara .......... ............................................... ................. 9 L.11 Le basi dell'ambic:n cc: e ................................................................................... 1o 1. U Note generali sul C e su qucst0 lib ro ............................................................... 12 I .1 3 li Concurrent 13 1. L4 La programmaz:ione orientata agli oggetti e il C++ ......... ................................. 13 ·Esercizi d.i aurovaJurazi<;> ne ........ .............. .............. ..................................... ................... 14 R:isposcc agli esercizi di aucovalurnziMc .................... .. .......... ............ ........................... 14 Tuercizi ............ ......................... ............ ............ ,.. .. .. ... .. .. .. . .. .. .. .. .. .. .. . .. .. ... . .. .. . .. . .. .. .. . ... .. 15 Letture consigliate ................................................................ ........................................ 16
e ...................................................................................................
e ...............................................................................................
C APITOLO
2.1 2 .2 2.3 2 .4
2: INTRO DUZIONE ALLA PROGRAMMAZIO N E IN C
.••..•. .•••.. ••.•..•...••••.•.••..•
19
fn rroduriooc: .................................................................................................... 19 Un semplice programma C: visualizzareuna riga di resco ................................ 19 Un altro semplice programma C: sommare due interi .................................... 23 Norion.i sulla memoria ....................................- .............................................. 28 1.5 L'arirmetica dcl C ....... ............................................. ........................................ 29 2.6 Prendere delle decisioni: gli operatori di uguaglianza e relazionali .................. 33 Esercizi di aucovalut:u.ionc ............................................................................................ 37
SOMMARIO
IV
Risposcc agli esercizi di aurovalutazione ....................................................................... 39 Esercizi ................................................................. ........................................... ............. 40 CAPITOLO
3: Lo SVILUPPO DI PROGRAMMI STRUTTURATI .• ...••.•••.•..•......•••.••••• . . ......•. 45
3.1 3.2 3.3
I
Introduzione .................................................................................................... 45 Gli algoriuni ................................. ................................. ................................. . 45 Lo pseudocodicc .............................................................................................. 46 ~.4 Le strutture di cona·ollo ................................................................................... 47 3.5 L;i ·scrui:o.u:a di selezione lf ................................. .............................................. 49 3. 6 La suutcura di selezione lf/El~e ............................ ,..............................,,.......... 51 3.7 La scrucrura <.li iterazione wbile ............... ......... ........ ........ ................................ 55 3.8 Formulazione degli aJgoàani: srudio di un caso 1 (icerazione Gontrollaca da un concarore) ........................................................... 56 3.9 Formulazione degli algoritmi con processo top-down per raffinamenri successivi: srudio di un caso 2 (irer.Wene controllata da un valore sentineUa) ................................................. 58 3.1 o rormulaziçne degli algoàcm.i con processo rop-down per raffi n;unemi successivi: studio di un caso 3 (suurrure di conrroUo nidificare) ...................................................................... 65 ·3.11 Gli ope.rarori di assegnamentò ......................................................................... 69 3.12 Gli opcrarori di incremento e di decremento .................................................. 70 Esercizi di aucovalucazione ............................................................................................ 73 .Risposte agli esercizi di aurovalutazione ............................................................ ........... 74 Esercizi ................................................... ...................................................... ,............... 76 CAPITOLO
I
4: IL CONTROLLO DEL PROGRAMMA ........... ....••....••.••....•.......•. .....•...••.• 85
4.1 4.2 4.3 4.4 4_5
lnuoduzione .................................................................................................... 85 Gli elemem:i della iterazione ............................................................................ 85 Jcei;azioBe cÒntrollara da un contatore ...............................................""·········· 86 La strurcura di icera7Àone for ..... ............................ ................ ..... ... ........... ........ 88 La struttura for: noce e osservazioni ................................................................ 91 4,.6 Esempi di utilizzo della srrurrura tor ................................................................ 92 4.7 La sm:rrrura di selezione mulcipla swicch ··········································-·············· 95 4.8 la struinl.Ea di iterai.ione do/while ................................................................. 101 4.9 Le isrn1zi0ni break e concioue ............................................................... .. .. .... 103 4. 10 Gli operatori logid .................................. .............."····························.. ········· 105 4.1 ·1 Confondere gli operacori di uguaglianza (:=) e di assegnamento C•=.) .••.•••••..••• I08 4.12 Riassumo ddla programmazione sr:rurturaca .................................................. 110 Esercizi di aurovalurazione. .................... .. ..... ...... .... ................. ............ .. .. ........... .... . ... I 15 Risposte agli eserçizi di autovaJuraz.ioqe ..................................................................... 117 Esercizi ................................................................................................. ...................... J 18 'C APITOLO
lnrroduzione .................................................................................................. 125 1 moduli di programma jn_ e ......................................................................... 125 Le funzioni della libreria maremacica ................................. ......................... ... 126 te funzioru .................................................................................................... 127
-=-- -_
SOMMARIO
V
Le definizioni di funzione ................................. ... ................................. ......... 129 I prototipi di funz.lone ............. ...................................................................... 133 I file di inresrazione ....................................................................................... 136 Invoca.re le funi.ioni: chiamata per valore e per dferimento .......................... 137 Generazione di numeri casuali ...................................................................... 138 Esempio: un gioco d'azzardo ................................. ................................. ....... 142 Le classi di memoria .................................................................. ................... 145 Le J:egole di visibilità ...................................... ,.............................................. 1.48 La ricor~ione ................................................................................................. 151 Esempio di ut:ilizzo della ticorsione: la serie di Fibonacci ............................. 155 Ricorsione e iterazione .................................................................................. 158 di autovalucazione .......................................................................................... 161 Risposte agli esercizi di autovalucazione ..................................................................... 163 Eserci?.i ............................................................................................... ........................ 165 5.5
La dichiarai.ione dei ven:qri ........................................................................... 177
6.4
Esempi di ucili220 dei vecroci ......................................................................... 178 Passare i vertori alle funzioni .................................................................. ....... 190 6.6 L'ordinam.coco dei verto.ri ................ .......................................... ,................... 195 6.7 Srudio di un caso: calcolate la media, la mediana e la moda usando i vettori 197 6.8 La ricerca nei vettori .................................................................... ,................ 201 6.9 I vercori mulcidimensionali ............................................................................ 206 Esercizi di autovalutazione .......................................................................................... 212 Risposte agli es~rcizi di aurovalurazione .................................................... ._............... 2 14 Eserci2i ................. ............................................................................................... ,...... 215 Esc::,rcizi sulla rieorsione ..................................... .. ...................................... ................. 225
6.5
CAPITOLO
7.1
7: I PUNTATORI ................. ........................ ................... ...... ... .......... 227
Introduzione ........................................................................................... _...... 227 7.2 Dichiarazione e iniziaJjzzazione dci puntarori ................................................ 227 7.3 Gli operatori sui puntatori ............................................................................. 228 7.4 la chiamara per riferimento delle fun?.ioni .................................................... 231 7:5 Ucilizz.are il qualifìcarox:e const con i punratol'i ................................. ............. 235 7.6 L'ordina.mento a bolle utilizzando una chiamata per riferimento ................... 241 7.7 Le espressioni con i puntatori e l'aàtmetica dci puntatori ............................ 246 7.8 La relazione tra i puntatoci e i verrori ............................................................ 249 7.9 l vettori di puntatori ................................. ..................................................... 253 7.10 Srudio di un caso: simulazione di un mescolacore e discribucore cli carte ...... 254 7.11 I puntatori a fun1,ionj ................................................... .. ,............................... 259 Esercizi di aurov-aluta.7.ione ........................................... ,.............................................. 264 Risposce agli esercizi cli aucovalutàrione ...................... ., ............................................. 266 -Esercizi ....................................................................................................................... 267 Sezione speciale: cosrruire il vostro computer ............................................ ·-············· 270
SOMMARIO
Vl
8: I CARATTERI E LE STRINGHE ............................. ............................. . 281 lnrrod:uzione ........................................................ ,......................................... 281 8.2 1 concerti fondamenrali deUe stringhe e dei ca.racreri ..................................... 281 8.3 La libreria per la gestione dei carartcri ................................. ......................... 283 8.4 Le fu.m.iorù per la conversione deUe srringhe ................................................. 289 8.5 Le funzioni deUa libreria per l'iopuc/oucpur standard .................................... 293 8.6 Le funzioni per la manipolazione delle stringhe incluse neUa libreria per la gcscione delle so:inghc;: .......................................................................... 297 8.7 Le fi;m~ioni di confromo.in:cluse nella libreria per la gestione delle so.inghe .. 299 8.8 Le fu.rrzion i d i ricerca incluse nella libre.ria pcr ta -gestione delle stringhe ...... 302 8.9 Le funzioni per la manipòlai.iorn: della mc.moria incluse nella libreria per la gestione dcl le stringhe .......................................................................... 308 8. 1O Lè alrre fu.oz.ioni della libreria per La gestione delle stringhe .......................... 312 Esercizi di aurovalurazione .......................................................................................... 3 L3 Risposte agli esercizi di autovalutazione ................................. .................................... 3 14 Eserciz.i .... ·······-··· ...... .. .................................................................. ............................. . 315 Sezione speciale: esercizi di manipolazione avanzata: dclle stringhe ............... ;............ 31 8 Un progetto impegnativo per la manipolazione delle stringhe ..................................... 322 CAPIT OLO
8.1
CAPITOLO
9: lA FORMATTAZJONE DELL'INPUT/OUTPUT . .......... ................. .... ........ 323
SOMMl\RJO
10.1 1 Le cascanti d i enumerazione ................. ............. ...... ................................. ..... 371 Esercizi di autovalutazione .... ........................... ...... .. ................................. ........... .. ..... 373 Risposte agli esercizi di aucovalucazi.on e .... ........................................ ............ .. ........... 375 Esercizi ........................ ........... ......................................................... ........................... 375 CAPITOLO
11. I 11.2 11.3
C APITOLO
12.1
I 0: LE STRUTTURE,
LE UNIONl1 LÀ GESTIONE DEI BIT E LE EN UMERAZIONI
349
ln rrod~one
10.1 10.2
................................ .... ......................................... ..................... 349 La definizione delle srrurrure .. ................................... .................................... 349
10.3
Inizializzare le srrurrure .......... ..................................... ................................. .. 352 Accedere ai membri delle suunure ................................................................ 352 Usare le suurrure con Le fun~ioni ................................. .................................. 354
] 1.4 Creare un file ad accesso sequenrt.iale ............ ................................................ 382 11.5 Leggere i dari da un file ad a-ccesso sequenziale ............................................. 387 11.6 I file ad accesso casuale ................................................................................. 392 11.7 Creare un fùe ad accesso casuaJe ........................ ........................................... 393 11.8 Scrivere i dari in modo casuale in. un file ad ac::éesso casuale ................_........ 395 11.9 Leggere i dari in modo casuale da un fìle ad accesso casuale ......................... 398 11.10 Studio di un caso: un progratllJilll pe.r l'elaborazione delle mll1s;I2Ìoui .......... 399 Esercizi di aurovaluraz.ionc .................. ........................................................................ 404 Risposte agli esercizi di autovalutazione .................................................................. ... 405 'Esercizi ................................................................... ..................................................... 406
9.1
CAPITOLO
11 :
Introduzione .......................................... .. ............ .......................................... 379 La ger.arGh ia dei dari ...............-...................................................................... 379 I fil.e e g.li Strea.in .... .................. ................................. ........... ............. ... ........ .. 38 1
9.2
lnrroduzione .................. ........ ........................ ..................... ........................... 323 Gli srrearn ...... .. .... ......................... ...... .......... ...... ....................... ............. ....... 32.3 9.3 f oanattit'e l'output con priurf ........... ............................................................ 324 9.4 Visua.lizz.are gl.i interi .......... ........................................................................... 324 9.5 Visualizzare i owneri in virgola mobile ......................................................... 326 9.6 Visualizzare le stringhe e i caratteri ............................................................... 328 9.7 Gli altri indicatori di conversione ...................., ............................................. 329 9.8 Visualizzare co11 le d imensioni di campo e le p .recisioni ................................ 330 9..9 Utiliz1..are j H.ag nella srri:oga.di coum'>.llo del fo.anato ................................. ... 333 9.1 O Visualizzare i ~lerterali e le s.e.que112e di escape: ................................................ 336 9.1 l Pormarciire l'input con scanf. .. ....................................................................... 336 Esercizi di aurovaJutazione ........................................... ............................................... 342 Risposte agli esercizi di aucovalucazione ................................. .................................... 344 ..Esercizi ....................................................................................................................... 345
Vll
I 2:
L E STRUTTURE D I DATI ..................... . ................. ........................
Le liste concarenace ..... .......................................................................... ........ 414 Le pile ............................. ..................................... ............................... ........... 422 Le code ........................................................................................................ .. 428
12.7 Gli alberi .............................. .......... ................................................................ 434 Esei:cizi di :turqvalut:az.ione .................................................................. ........................ 439 -a· .. di aurovaluEaZione . . t,rspoSte agli eserClZJ ..................................................................... 4"11 Esercizi .............................................................. ............... ......... ... ............................ .. 442 Sezione speciale: costruite il voStro compilatore .... .................................................... 449 Primo passaggio ............................................................................................. 452 Secondo passaggio ........................................................... ........................... ... 454 Un esempio completo .................... .............. ........ .... ......................... ............. 454 Un ~e passo per passo del processo di compilazione ............................... 456 C APITOLO
13:
I L PREPROCESSORE .......... ......... .............. ..... ........... . .. .... .............
463
Typedef.......................................................................................................... 354 Esempio: simulazione di un. mescolatore e distributore di carre
13.5
ad alt.a. efficienza .......................................................................................... .. 355
13.6
L0.8 Le un.ioni .. ..................................................................................................... 3 57 L0.9 Gli operatori bicwise ...................................................................................... 360 10.10 l campi dj bit: ................................................................................................ 368
Tnrroduz.ione ................................. ................................................. ,............... 463 La ~rriva del preprocessore # include ...................................... ................... 463 La diretàva del preprocessore #defìne: le cosranù simboliche ....................... 464 La diren:iva del preproces.soce #define: lt: macro ..... ...................................... 464 La compilazione c0ndizi0nale .................. ....................... ,.............. ................. 466 l e direttive del prcprocc,:ssorc #errar e #pragma .........................- ......... ....... 468
13.7 1 3.8
Cli operatori# e ## ............. .......................................... ................................ 468 I numeri di riga ................................. ............................................................ 469
13.9
Le cosranci simboliche predefinite ........................................................... .. .... 469
10.4 10.5 1.0.6 L0 .7
13.1 13.2 13.3 13.4
./ . , ......).·,. . ~'f~1, • :ç~ ~~-
1
Vili
SOMMARJO
13. J O Le asserzioni .......................... -....................................................................... 469 ~erciz.i di autovalutazione .......... ................................................ .......................... ...... 470 R1spo~t~ agli esercizi di aurov-.tlutazi.one ..................................................................... 471 Eserc1z1................................................................................................................... .... 472 UPITOLO
Introduzione .................................................................................................. 473 Re~rezioo.are l~in~~t:/?utpuc sa sistemi UNIX e DOS .................................. 473 GL1 elcn~hi variabili di a:rgomenci .................................................................. 474 Usare gli argomemi della riga di comando .................................................... 477 1 .I 14.5 Noce sulla compilazione cl.i programmi fqrmari da vari file sorgente ............. 478 Chius~a dei pr~g~ c:pn Exit: e Acexir .................................................... 480 1!.6 Il qua116carore di npo Volatile ........................................................ ............... 481 1 .7 J:·8 l Sllffissi per le costanti ~n(èrè e in virgola mobile ..... .................................... ·4 82 1 .9 Ancora sai file .. ,............................................................................................ 482 14.10 La ges'l!ione dei segnali ................................................................................... 484 14.11 Allocaz.ione dinamica della memoria: le funzioni calloc e rea11oc ................... 4.85 .14. l~ . IJ salto iacondìzi()nacq: goto ............. ............................................................. 486 Eserc1z.1 di aucpvaluraiione ................................................ .................. .. ...................... 489 Rispo~t~ agli esercizi di aurovalur;u.iqne ........................ ............................................. 489
lA SINTASSI DEL C ............. ............... ......................................... 49 1 Sommario della sin cassi del linguaggio ....................................................................... 491 A PPENDICE A :
A. l A.2 A.3
Grammacica lessicale ..................................................................................... 491 Grammatica della suunura della frase ........................................................... 495 Oircrcive del preprocessore ........................................................................... . 501
APPENDICE
B. l ~.2 B·~ .~ 8B ·~ B:7 ·
818 B.9
B.10· B.l l B.12 B.13 B.14
B: LA LIBRERIA STANDARD ........ ........................................................ 503
Erroci ............................................................................................ 503 Oefiniziòni comuni ...................................................................... 503 Diagnostica .................................... ............................................... 504 Gestione dei caratteri ............................... ................... .................. 504 Localizz.~one ....................................... ........................................ 505 ~r~e:~~~~c~~srher.~m> ··~·_..................................................... ..................... ..... 509· ) P.JV> ................. ·•·· .. ···· ...... ·••·•· ..................................... 51 I Gesrione dei segnali ...................................................................... 512 .Argomenti v.ariabili ...................................................................... 513 lnpur/Oucpur .................................................................... .. ........... 514 Urilirà generiche ............................................................................ 525 Gestione delle stringhe .................................................................. 532 Data e ora ...................................................................................... 536 Lim.ici dell'imp1e.mencazione .......................................................................... 539
D: LINSIEME DEI CARATTERI ASCI I ................................................... 545'~
A PPENDICE
E: I SISTEMI NUMERICI ................................ ..................................... 547
lncrodu.zione .............................................................. .................................... 547 L'abbreviazione dci numeri binari in oaali ed esadecimali ........................... 550 La conversione dei numeri oaali ed esadecimali in binari ............................ 551 La conversione da binario, orcale o esadecimale in decimale ........................ 552 La conversione da decimale a binario, ocrale o esadecimale ........ .................. 553 E.5 I numeri binari negativi: la notazione con rnmplernenco a due ..................... 554 E.6 Esercizi di aurovaluraz.ione .......................................................................................... 555 Risposte agli esercizi di aucovalurazione ..................................................................... 556 Esercii.i ................................ .. .......... ............................. ..... .................................. ..... .. 557
Benveouci nel mondo del C. Q uesco libro è scaro scrirro da un padre, l:larvey M. Deitel, e da. suo figlio, Paulj. Deicel. JI padre ha programmaco e/o insegnaco la programmazione per 38 anni, menrre il figlio h:1programmato e/o insegnar.o la programmazione per 18. Il padre p·rogramma e insegna grazie all'esperienza maturam; il figlio, invece, programma e insegna gazie a un'inesa.uribile riserva di energia. Il padre pwita alla chiarezza, U figlio alle presta"!li.oni. H padre cerca l'eleganza e I.a bellezza, iJ figlio vuole soprammo risultati eone.reti. lnsieme hann0 cercaco di rcafu.zarc un libro che speriam0 possiate trovare mi.le, complero e diverre.nce.
Lo scopo di questo libro Il Professor Harvey M. Deird ha cenuco corsi universirari. inrrodurrivi sulla programmaz.ione pe!r 20 anni, punrando soprarruno a insegnare come sia possibile sviluppare programmi ben scrirri e ben srrurcuraci. Molà dci suoi inscgnamenà riguardano i concetti fondamentali della programmazione, con particolare ~i suU'ucilizzo efficace deile strutture d i q>nrrollo e sulla funzionalità. Questi argomenti vengono presentati all'interno di quesro libro esanamente nel modo in cuj il Professor Deicd li ba sempre proposti ai propri .srudeori universirari. t
In base aila noma esperienza, gli srudenti affronranp i temi presentaci io questi capitoli n~llo sresso modo in cuiaffrontaoo i corsi di Pascal. Gè, comunque, un'importante differénza:: gli srudemi sono escre.mame.nre motivaci dal farro che sranno imparando un linguag-
gio che porranno ucilizzare immediacameme quando lascer.lDilo l'università e a.ffromeran-
.110 il mondo del lavoro. Turro quesro aumenta notevolmente il I.oro entusiasmo nei confronci del
e, nonostante ci siil moltissimo da impatare.
U l10StEO obiettivo er.a. chiaro: offrire un testo .sul C d6LÌ.naco ai corsi W'liversirari a livéilo inrroi:lurrivo, per quegli studenti che non bruino -ak:una esperienza nell'ambito del.la programmazione, pur fornendo, allo sresso rempo, la ~omplerezza rcorica e pratica ricb ie· sra ai tradizionali corsi avanzati di C.
11 resro segue lo srandard ANSl C; rene(e presence d1e moire funzionalità dell'ANSI C .nòn sono implementate nell.e versioni pre-ANSI deJ C. Per avere informazioni più derca:gliate sul linguaggio vi conviene consultare il manuale di riferimemo dd vostro sisrcma o pn;>curarvi una copia dd documento ANSiflSO 9899: l 990, "Amecican National Scandar9 for lnformaòon Sysccms-Programming Language C", clell'AmericanNationaJ Standards 1nsòrure, 11 Wcsc 42od Streec, New York, New York 10036.
Xl!
PREFAZrONE
La metodologia di insegnamento Questo libro contiene un'ampia varierà cfj esempi, esercizi e progerri che prendono spunto da moire situazioni e che offi:ono agli smdenri la possibilità di risolvere problemi reali. Il libro prende in esame i principi dclla progena:iione dd software, insistendo sulfimponanza della chiarezza dei programmi ed evicando J'uso cfj cerminologfa complessa a favore cfj esempi chiari e cLretti, il cui cocLce sia scaco collaudato sulle piaccaforme C più diffuse.
l:apprendimento attraverso il codice D libro presenta una grande quantità di esempi basaci sul cocLce. Ogni argomento viene presencaco neU'ambico di un programma C completo e funzionante, seguito sempre da una o più finestre che mostrano l'oarput del p rogramma in questione. Viene quindi usato il Llriguaggio per insegnare il Llnguaggio, e la lettura di questi programmi offre un'esperienza molto simile alla loro eseéuzione reale su di un éomputer.
L:accesso al World Wide Web Tu ero il codice presente nel lìhro si m;>va .anche in lnrerner, nel booksite abbinato a quesco libro, all'indirizzo http: I /www. apogeonline. com . education . booksite. Il nostro consiglio è quello di scaricare turro il cç>dice, eseguendo poi ogni singolo programma via via che appare nd resto. Potere anche modificare iJ codice degli esempi e vedere cosa succede, imparando cosl a programmare prograìiimando. Tutto questo marcriaJe è protetto da dirirci d 'aucore, quindi urilizzatelo liberamente per studiare il e, ma noo pubblicatene alcuna parre senza l'esplicito permesso da pane degli aurori e ddla casa editrice.
Obiettivi Ogni capirolo inizia con la presenrazione degli Obiativi. Gli srudenci possono cos} sapere in anticipo ciò che andranne ad apprendere e, alla fine della l.errura del capitolo, porranno
verificare se hanno raggiunro o meno questi obiettivi.
PREFAZIONE
Xlii
.
.
.
Consigli e suggerimenti
d . 1 roo-rammazione per amcare glt srudenr1 a . . nguar ~udlla p 0iluppo di pr~grammi. Questi consigli Il libro offre mola sugge:iro.en~1mporcann J e o sv più · r e Coilaua() tip1c(), En·()re Buo na abitudine . . _L. concenrrarst sug I asperu le sez10111 . ' • cn1amare 6 miti acrraverso ,,n;r 'enza, Qb,ettivo p()rtabilità, lngegnma del software. . "JJ"'' Ob.u:mvo o vengono a punto, messa .
.
ali"
.
,
B uona abitudine
interto!!Iammare e la.chiarezza, e hi . . . d li cniche er la scrittura U concerro più imporranre per c mma a p · 0 P ·' no delle sezioni Buona abitudine vengono pre_s~tare e e ~il' di programmi chiari, comprensibili e pi.ù facilmente ges
I.
d · . ono a cen linguaggio nuovo un volta rinia r la affr . . se:iìon i Errore ti.pico ai urano gli Le Tucci gli sn1d;nt1 che _. · . ·., com me ere re rrequencemen • stu.denri a evirare di commettere I Plll comun i.
Errore tipico
o~caeng~i ps~essi ~rrori.
,
Collaudo e messa a punto
.
Quesce seiioni forniscono consig~ circa le attività di tese e debuggrng dei programmi C, anche a livello prevenavo.
b~e
·
.
Obienivo efficienza
c~rso
nosrr~b~pdC:~ti~U:~ l'obi~civo .
.
nare
li studenri come scnvere programmi
più imporrante di qualsiasi alla Jn. , vogliono normalmenre im parare a scnve. . ch1an e compre.nst h ti.l.izzino poca memoria, l di programmauone. Gli swdenu'. p~o, d. . h 0 esegum i.n mo o ve oce~ c e u . à di comandi e che offrano presrazioni eccelre programrru auntma quanut . hi d c e ven?~ cb . offion. o sugg·erimenti su come migliorare le . . effic1enui ~o ~na e neLe esezioni Obiettl/Jo lenti. prestazioni dci propri programmi.
Il codice e gli esempi Le funzionalità del C vengono preseruare nelJ'ambiro di programmi completi e funzionanti. Ogni programma è scguiro dalle immagini degli ourpuc che vengono prodotti, cosl che gli studenti possano assicurarsi della corrc:rcezla _d ei risultati. I programmi presencati vanno da poche linee di codke a esempi compo~ti da varie centinaia di righe. Gli studenti doVIebWeb http: \\ www. apogeonl1ne. com/ education I bero scaricare cucco il codke dal booksi te, eseguendo poi ogni progµtnma via via che questo viene preseararo all'incemo del resto.
~i.co
.
Obiettivo ponabilità
Al · un'applicazione e, questaè plementando grammaron. pensano ehe, di cl' mente porta)I ile .su rurrn" ,,,.... p1'attàfiorme·' sforcunacamente, oon · 1 pro · cun b'L' , .: ... 0 g·U sruden ti t scrivere: co ce . sta 11nme 1ara di do ·1 sempre cost Le se-l.Ìoni Obiettivo port4 .t..it:a a1u:3°. . tm:'
realmente portabile, fornendo inoltre i nfo~aztom su come raggiungere quesco elevato livelJo di portabilità.
C .. ,
L
sia tn gra
Ingegneria del software
Figure e immagini 11 libro offre un'ampia varietà di grafìcj, immagini e outpuc di programmi. Nelle sezioni dedicare alle srrua.ure di contrqllo_, per ciempio, appaiono vari diagrammi di flusso molto ucili. [N()ta: l diagrammi di Busso non vengono presenrati come uno srrumenro di sviluppo, ma ricorriamo a- una breve presenra:iione basara su questi diagrammi per specificare le singole: operazioni di ogni struttura di conrrolJo C.]
Llnguaggt~
efficacenell'ambiro della progerrazione del sofrware, e . . d 0 in esame gli asper[i architetturali e molto Il C è un di sisremi software, specialmenre le sezioni Ingegneria .del sofrwarulJ.ae pr~n o~ . .. rea izzaz 1one ali eh 1. flwscono s e ~ su vasta scala· Molce di quesre informazioni saranno unli agli progerru caso d1. s1.stem1 nel studenri nei corsi più avanzaci, olcre che nel mondo dd lavoro.
XJV
PREFAZIONE
Esercizi di autovalutazione
Capitolo 4 - I l controUo del programma: raffina le nozioni di programmazione smmuram
gr
. d ~ Jibro propone moJci esercizi corredati di. risposte così che J sru ~ntJ po~~o prepararsi alle esercicaz.ioni vere e proprie. Gli sruden:ri d~ bb vre ero essere incoraggiati a svolgere turti questi esercizi di aucovalutazione.
.e .inrroduce altre srrurcw·e di controllo; esamina in dettaglio l'icerazione e paragona i cidi _conrrollaci da un contatore con quelli conrrollati da tm valore seminclla. La Struttura for è pres'enraca come uno strumento adatto a implementare i cicli conrroUati da un concarore. Sono inrrodocre anche la scrumua di sele'Lione swi tch e quella di irerazione do /while. Il
Esercizi
spicola termina con una discussione sugli operatori. logici.
eh . . Ogni capirolo si conclude coo uo insieme di eserciz·1 d.1 e permettono agli vano tipo, 1 · · L . . insegnanti di dart .. ai:e e propne ez1onJ alle esigenze pa.rricolari di ogru' classe Cli , a esercm . . . ., . verifica no I apprendimenro dei concett:· d . denri di scrivere singole istr . . . . . i el e1 re~mu:i1 ~JU imponanci, chiedono agli sruuz1oru> ptcco e porzioni di funzio . fun . . z1oni e programmi n1, . . . . ali · compled fino ad arnvare a cos.i:ru21one di rnten progeru.
Indice analitico al' · · di Alla Boe del Llbco è possibile trov-ar legge questo libro per la prima ~oJ~ ~~:t"'procgre~ttco. cchompl leco, molto ur~e s~a a chi aron e o usa.no come nFenmento. ·
Panoramica sul libro . Capitolo i - Nozioni sulla elaborazione elettronica· s . . p1:ga cosa sono J compurer, come funzionano e in che modo possono essere programmaa. Questo capicolo introduce la . proo-rarnrru.zi rivoiuzione n°::e~~:;:u:~~:;';~t perché qu:sro insi~me di tecniche abbia favorito una p~og~.rru:1 1 : TI capscolo offre una breve storia dello sviluppo dei lingu · di · . cchin . r programmazione, dai linguaggi aggi . a, ~J inguaggs assembly, ai linguaggi di alco livello. ~ dis~ussa anche l'o . . d 1 rma Il capicolo indude uo'inrrodl17.ione alI' b' agd1~e e mgu~o d1 programmazione C. am ienre 1 programmazione del C. fc . .- . Capitolo 2 - Introduzione alla P rogrammaz1one . d · m · orrusce •· un Lntro UZJOne Stnterica ai • . programmi di SCrÌrtura. C e offie aritmetiche del C Dopo ave . d'-:1° ((aeramento. derragltaro delle operazioni decisionali e . r sltu . taro questo cap1mlo, lo scudcnce avrà imparato a scrivere rogrammi se 1" . P mp 1c1 ma comp ea.
e
::-:::ttu.rau:
. . , . · Capitolo 3 - Lo sviluppo di pro e pro~a?tlrnence_il capiro.lo più impq.rtànte del testo, specialtnerrce nozione di algoritmi (proced:e) pè: 1 ? I te. srud • • rm success1v1, una . ii tecruca unporrance per produrre in. mo o c:orrerro _programmi srrurrurari. Esso presenta u:n popolare strumento di . - al1 . I aiuto a progettazione dei programm · 1, ov:ero~~ O pseudocodice Strutturato. f metodi e gli approcci usaci nd C . j aptto o 3 sooo applicab1l1 alla programma. . zione struttttrata in o . lin capirolo aiuta lo scud~ce a ~~19 di pr.ogrammaz.ion~ n~~ s~lo a quella in C. Questo programmazione che lo prepareranno ad affrontare gli . ppa:~ ~elle buone ab1_rudin1 programmazione p1u consisten ti del resro dd eserC1Z1 libro.
eh:
1/
.?1
-·--
xv
PaEEAZIONE
::e
--
Capitolo 5 - Le fum.io.ni: trarra della progettazione e co.scruzione dci moduli del programma. Il linguaggio include funzioni d i libreria sraodard., funzioni dclìnice dal prograrnmarore, la ricorsione e la possibilità di effeccuare delle çhiamace per valore. Le tecniche presentare sono essenziali per la produzione e la comprensione di programmi strutmrar.i, specialmente di queUi piì.1 grandi, e del software elle i progmmmarori di sistemi e di applieazioni svilupperanno più probabilmente nelle app1icazioni del mondo reale. La srrategii\ "dividi e conquisrà' è presentata come un mezzo efficace per risolvere i problemi più ®mplessi; le fi.111?..ioni aiutano il programmatore a suddivide.re i programmi complessi in compònenci plì.1 semplici d1e inceragiscono rra di.1Qru, Agli studenti piaçe avere a che fare con i numeri tasuali e le simulazioni e apprez.zan.o la rrag;iz!one del gioco di dadi craps che fu un uso eleganre d elle munure di conrrollo. il eap:irnlo offre una soHda inrroduzione alla .r:ieorsione e include una tabella che riassume i 31 èséropi ed esercizi s ulla ricorsione distribuici nel resro del libro. Alcuni libri affrontano la ricorsione solo verso la loro fme, .ma noi pensiamo che sia meglio trattare l'argomento in modo graduale Ilei corso di rutto il lib.ro. I.:esceso gruppo di 39 esercizi p resenraco alla fine del Capitolo include vari proble.mi clissici sulla ricorsione come le Torre d i Hanoi.
e
Capitolo 6 - L venoci: discure la srrurrurazione dei dari in vettorì, cioè gruppi di d ati corrdaci è dello stesso tipo. U capitolo presenra numerosi esempi sia sw verrori con un solo indice che su quelli con indice doppio. .Limportanza della smmurazione dei dati è ampramenre riconosciura al pari dell'utilizzo delle srmrrur~ di controllo nello sviluppo di programmi srrurruraci. Alcuni esempi del capimlo appr-ofondiscono varie tipiche elaborazioni dei vettori, la scampa degli isrogrammi, la classificizlone dei dari, il passaggio dei verrori alle funz ioni e UJÙn troduzione all'analisi dei sondaggi di opinione. Un pumo cararrerisrico di questo capitolo è un'accurata presentazione della ricerca binaria, un enorme miglioramemo di quella lineare. Gli esercizi alla fine del capitolo l.ocludono una vasca selezione di probleini inreressanri e sti molanri , Questi includonQ t~çniche di ordina.memo migliorare, la progercaiione di un sis.cema di prenotaz.ionì per linee aeree, W'l'incroduzione al concerto d-efla Turtle Graphlc (resa famosa dal linguaggio LOGO) 'e i problemi del giro dd cavallo e délle otto regine che !rmoducono la nozione d i prog.rani.miliorle euristica, molto urilizzata ' ' nel<::ampo deU'inrelligenza artificiale.
Capitòlo 7 ~ T puntatori: prcsenra una delle caratteri_stichè più parenti del linguaggio C. U capirolo fornisce spiegazioni dertagHace sugli operatori dej puncacori, sulla chiamata per rifetimento, sulle espressioni con puntatori, sull'arirmerica d ei pumarori, sulla relazione u:a. puntatori e vettori, sui venori d i puntarori e sui punracori a funzioni. GH esercizi del capitolo includono una simulazione della classica gara tra.. la rarraruga e la lepre e vari algoritmi per il mescolamento e la distribuzione delle cane. È inclusa anche una speciale s~one in.ncolara "Cosrruice il vostro computer", che spiega la programmazione in linguaggio macchina e prosegue con un progerto che èompreiìde-Ja progertazione e l'implemencazìone di un simulatore che permerta al lecrore di sciivere e far funzionare i p rogrammi sviluppati in linguaggio macchina. Questa caratteristica unica del libro sarà ucile soprarruc-
XVI
PREFAZI01.~R
al I.errore che vorrà ca~e i.l reale fuazio namc:nro dei compu ter._Ai nostri srud~nci piace questo progetto e spesso implementano sostanziali mi<>li,oramenfr molri di questi sono pJ·op0sci alJ'inrnrno degli eserci7.i. Nel Capitolo 12, ~'alua scri~ne spedale ~iderà il lerror; attraverso la_ cosrr~z.ione d_i un çompilamre; il linguaggio macchina prodoa:o dal compilator_e sarà poi esegruto con il sirnularorè di lingua ggio macchina prodocco nel Capi~~
XVII
1:0
.
Capitolo g - l caratteri e le stringhe: mma dei prin.cipj fondamenrali dell'elaborazione dei da~i non n_umerid..n capitolo include una panoramica comp leta delle funziohi per l'elabo r-az1one dei canlttcri e delle scrifilghe disponibili neUa libreri a del C. Le tecnidìe discusse in ~uesro contesto sono ampiamçnre utilizzate nello sviluppo dj woi:d processor, software di u;np~~~on~ e applicaziçn i per l'daboriiz.ìone del tesco. Allo scudence piaceranno gli éserC12J. sw luner1ck, sul~a gen~razione ~suale di poesie, sulla éo.nversione dall'inglese al pig Launo, s~a. generazione d1 parole d1 sette lettere che equivalgono a un numero telefonico dato, sull allineamcnro dd testò, sulla protez.ione dègLi assegni, sulla scrirtura della cifra di un assegno in lettere, sulla generazione del Codice Morse , sulle co1wersioni metriche e sulle lettere di sollecito. L'ultimo esercizio invirn lo stude nte acl utilizzare un dizionacio compute~aro per creare un generatore di cruciverba! Capitolo .9 - U, fo.rmattaz.ione ~ell'Input/Output: presenta rurce le potenti capaci~à di forma:n:az,1one di pnruf e scanf. D1scureremo ddle capac ità di formattaz.ione del I' oucpur ru ftrintf, come l'rnurz,io~i letterali, la forzarura.del seg110 positivo, la stampa degli zeri iniziili, l'uso ddla .numé.ra210ll€ esponenziale, !'a.So dei numeri oro ed esadecimali e il controllo delle dùn~nsion~ di campo e dclla precisione. Dìscureremo tutte le scquçnze di es~pe di princf per 11 movtmeru:o del cursare, per la $rampa dei cararr eri speciali e per la produzione di un allarme acuscico. Esamineremo curce le possibilità di formacta7.Ìone dcll'inpm: di scanf incluso l'in?~t di spe~ifìci tipi di dari e come ignorare dei catatceri spedfìci presenti sullo scream. ~1 1:°Pu:. D1s~uterern~ ru:r~ le :~pecifìcbe di conversione dj scanf per leggere i n~eç él.eamah, ottali, esàdecJrnalt, in Vtrgola mobile, i caratteri ed i valori di una srrin:ga. D1scureremo della scansione dell' input in modo che corrisponda (o meno) ai caratteri uìdusi in un gruppo d:i stansione. Gli esercizi del capito lo verificano virtualmenre rune le eapacirà di inpur/ourpur foananato.
C:apitoio 10 - ~ .stru~~' le ~on.i, le elaborazione de.i bit: e Penumernzione: prcsenca diverse caratterist1ch~ 1mporrana. Le srrucrure sono come i record del Pascal e di alrri linguaggi: esse raggruppano dati di ti.pi diversi. Le scrutt ure sono usace rrcl Capi.colo 11 per formare file composti da record di infonnazioru. Nel Capitolo J 2 le srrurrure sono Wìate in~ieme ~· p~tacoci e ~H'allocazione dinamica d~lla memo ria, per formare strutture dinamiche ru daa come le lisce concarenace, le code, Le pile e· gli alberi . Le union i consentòno ~i utliiizare un'area di memoria per diversi cipi di daro in tempi differenti; que.sra condiviSJ(>ne ridurre. la ~uan~tà di memoria principale o s~c::òndacia richiesra da un prògramlllll'. Le. enumerazioru forlllScono un modo conveniente per definire delle costanci simbolic:J:e u.rili; ciò ai':11'4 a rendere i programmi più amoesplica:r ivi. te porenci capacità di manipola2~one dd b1c ~el C Consentono ai programmacori di scrivere programmi thc USaD(1> Je cap~c~t:à a basso livèilo dell'harclwate. Ciò aiuca i progr ammi ad elaborate ming he di bic, ad .lmposcare a on o a off i singoli bit e ad immaga?:lÌ.n 'are le informaz,ioui in modo più l':Ornparro. Tali capacità, spesso disponibili solo ne.i linguaggi assembly di basso livello,
euò
sone parcicolarmence appr~te d~ programmar~~ ne.li.a scrirrura ~i sofcware per i si.st_e~i . elativi e per la gestione delle rea. Una caratte.nst1ca cli questo captrolo è la nuova vers10ope ad alra efficienza della simulazione del me.scoIacore e dism'bmore di n. ' ~ccellente opportunità per l'insegnante per porre L'nccento sulla qualit carre. '<-uesra e una à degli algorrrmi. Ca:p1colo l1 - L'eJ.aborazione dei file: disc~re d~e. ~ecnic he ~~are per .elaborare i file ~ stò ad accesso se~uenz.ialc e casual e. Il captto lo 1111z1a con un 1D.rroduz1one alJa gerarchi.a te dei .dati: dai bic ai'-i byre, ai campi, ai recor d, aJ"fì1le. S · ' presenta~ ucccsswam emc e. una semplice panoramica sui. file e sugli scream del C. I file ad acces~o seql).e!1z1ale s~no discus:... · usando una serie dj ere programmi che mostrano come aprue e çh1udere 1 file, come SJ immagawinare i dari in modo sequenziale in un file e .I . come legge~~ i~ mo do sequeDZJa e '. dari da un file. Si discnre dei file ad ace.esso casuale usand o una serie di quarrro pr.ogrammt che mostrano come creare un file ad accesso ca5uale, come leggere e se.rivere i dati con acc~o q1.5uaJe, e c9me lcgge.i:e J daci in modo sequenziale cl.a ~m file ad ~c~esso casual~. _li quarto programma combina molce ce~ic he. ~ accesso. ai .file, ~1a seque~7.1~ che ~asual.1, 1~ un programma completo per Felaboraz1one ~1 tr3:°saz1on!. Gli s~udenu ~ei nosa;i semm aa indllscriali ci hanno detto che dopo aver studiato _il mater iale suU elaboraz.1one dei file, sono mci capaci di produrre programmi corposi per l'~abo razione dati che sono stati immedi:i-iamente utili all'imerno delle loro aziende. Capitolo 12 - Le strutt ure di dati: discute le ;ecnic he usate P,er ~reare del!e scru~rure dinamiche di dari. U capitolo inizia di.scurendo dc.Ile strutture ncors1ve e deU aJ1ocaz.1o~e din11IDica deUa memoria e pi:osegue con um discussione su come_ creru:e e conserva:e van~ struuure dinamiche di dati come le lisce concareriace, le code (o Ime di arcesa), le pile e gli alberi. Per ogni tipo di struttura di dati presentiamo dei. prégrammi funzion.anti e com~leti e mosrciamo degli esempi di ourpuc. li Capirolo 12 c?nse nce .aJl? s°:'~enre di f.ad~on~ggiare effè:ttivamence i punrarori. li capitolo include molu esempi di ut1lnzo dell m,dirC'Z.lone e della doppia indirei.ione (un concetto parcicolarrnenre difficile). Uno dei problemi ~ega~ alJ'mifu.zo dei pumatori è che gli studenti hanno difficolrà a visual iz~c le _srnmur~ ~ d:ia e i1 modo in cw i loro nodi sone colJegaci, così abbia mo incluso delle illusrr:moru che mostr:ll1ç> i collegamemi e la sequenza in cui essi sono ~reat:i. eesernpio d~'al~ero b~ari? è una stupenda pi~rra miliare per lo_scu~o d~i puncatòn e de.I.le ~rr~n~e ~che~ d~t1. ~qwo esempio crea un al~ero .bmano,' s1 pr~ccup.a dell ~~mmaz_ione ~1 d~pl1ca~ e mr.r-0duce l'attravcrsarnenco n comvo dell albero ID ordm e anacrpaco, 1.0 ordine e m ordine pOStjcipaco. Gli scudenri rirengono realmente esaustivo lo sturuo e Fimplenient~ii.one . di que5ro esempio e apprezzano in modo particolare il veder e che l'~crrav~rsamemo ID ordine dell' aJbero stampa i valori dei nudl nèll'ordine stabil ito. li tap1colo 11iclude un gruppo consistente di esercizi. Rilevance è la sezione specia le "Cosrruite Gli. eserci7.i ;iccompagnano lo studente nello sviluppo di un progril vosuo oompilacorç:". amma ~i con~ersiane <4Jl;i notazione infissa a quella polacca i1wersa e di un progr amma di valutazione di espressioni in norazione polacca inversa. Abbiamo qwndi modif icatq l'algoritmo di v~u~zio.ne di espressioni in notazione polacca inversa_ i~ m~do da poteI g~ner~re un codice lll linguaggio macchina. 11 compilatore immagazzinCi 11 s.ud~ ~no c~dic_e 1~ un fù~ (usand~ Le teenich.e del capitolo 11). Gli studenti ~ono qw.nd 1 il co~ce 1n ~ngua~o macch_ina prodotto dai loro compilatori suJ simulatore di sofcware cosrru1co negli esercm del Capi colo 71 Capit olo 13 - 11 preprocessore: offre una ruscussion e denagLla:a ~elle direa ive del pteprocçssore. TI e,ipicolo inqud e informazionj più comp iere sulla duert1va #inc lude che
XVIII I
PREFAZIONE
I induce l'inclusione d.i una copia di un file specificato in sosciruzione della direrriva, prima che il 6le sia compilarn, e sulla direttiva #defil"le che definisce deUe cosrant! simboliche e delle macro. Il capitolo spiega la c9mp1Ìazione condiziona~a per conscnd.re aJ progran1matore di concrollare l'esecU7.ione delle dirercive del preprocessore e la compilazione dcl codice del pr0gramma. Si parla dell'operacore # che converreil suo operando io unasrringa e dell'operatore ## che concarena due token. Sono presentate le cinque coscanri simboliche LLINE_. _FILE_. _DATE_, _TIME_ e_STDC_J. AJla fine è rracma la macro assert del fìle d.i incesrazione assert. h. Ac;sert è preziosa nel collaudo, la messa a puDto, la verif:ìca e la convalida del programma. Capitolo 14 - Argomenti avanzati: prescnca vari argomenti avanzaci che di solito non sono .affrontaci nei <:orsi introduttivi. La sezione 14.2 mosrra come redireiionare l'input di un programma in modo che provenga da un file, come redirezionare I'ourpuc i.o .modo che sia immagaz.z.inaco in un file, come redirezionare l'oucpuc di un programmain modo che vada a costitu ire l'iopm di un alrro programma (piping) e come accodare l'ourput di un programma ad un file già esistente. La sezione 14.3 discute di come sviluppa.re funi.ioni che usano elenchi va.ria.bili di ai:gomenri. La .sezione 14.4 tnostra in che modo gli irgomend della riga di comando possano essere passati alla funzione main e come urilizzali all'interno di w1 programma. La sezione 14.5 craaa della compilazione di programmi i cui componenti possono es5ere discribuici in vari file. la sc:z.ione 14.6 discute della registrazione delle funzioni con acexit io modo che possano essere eseguite al teanine dell'~eçuziooe di un programma e come terminare l'esecuzione di un programma con la funzione. exir. La se~i~ne 14.7 discute dci qualifìcaroci di tip0 consce vola:cile. La sezione 14..8 moma come speclfiçare il tipo di tU1a costante 11l1Illerica, usando dei suffissi per gli inreri e i numeri in virgola mobile. L;i sezione L4.9 crarca dei file binaci é dell'uso dei file remporaoei. La sezione 14.10 mostra come usare la libreria per Ja gestione dei segnali per inrercerrare degli eventi inamsi. La sezione 14.11 discute della creazione e dell'uso dei veccori dinamici con le funzioni calloc e realloc. Moire Appe:Cidit;i forniscono un -valldo materiak di riferimento. In parricolare, ndrAppen.dice A fomiam~ la ·sinrassi del Lin.gu.aggi0 C; nell'Appendice B un cle.oco commeJltai:o di turce le-funzioni della libreria standard dcl C; nell'Appendice Cuna cabeUa compleca della priorità e dell'associarività degli operacori; ndl'Appendice D l'insieme dei codici dei cararrcà ASCII e. nell'Appendice E, una discussione sui sistemi numerici binari, ottali, decimali ed esadecimali. CAppeod.ice J3 è scara escratta dal documento deU'ANSI standard con l'esplicito permesso scritto dell'American Narional Srandards Insrirure; la suddccra appendice fornisce un riferimenro-vfili4o e dertagliam per l'esercitazione del programmatore C. tAppendité E è una spiegazione compleca dei sistemi numerici, che include molti esercizi di auro-valutazione e le relarive risposte. Vi preghiamo di inviarci i vostri coilllilenti, suggerimenti, critiche e correzioni, al fì ne di migliorare ulteriormente questo libro. e indirizzo a cui scriverci è il segueme: deitel~deitel.com
Bene, pet ota ·è rutto. Vi rinnovi;imo il benvenuto nel mondo del C e dcllo sviluppo delle applicazioni clel futuro. Buona fortuna e buon lavoro! Harvcy M. Deitel - Paul
J. Dcirel
CAPITOLO
I
Nozioni sulla elaboraz ione elettron ica Obiettivi • Comprendere le nozioni elementruirelative ai computer. • Familiarizzare con i diversi tipi di linguaggi di programmazione. • Conoscere la sroria del.linguaggio di programmazione C. • Venire a conoscenza.della libreria standard delC. • ComprendereJ'ambienredisviluppo dei programmi C. •
•
1.1
Apprezzare le ragioni per le quali è appropriato apprendere il C in un primo corso di program.maz.ionc. Apprezzare le ragioni pe.r le guaii il C fornisce lehasi fondamentafj per i succ:essivi scudi sulla p.r
Introduzione
Benvenuti n.d mondo del C! Abbiamo lavorato dm·amente per creare quella che, speriamo sinceramente, sarà per voi una esperienza inform::rdva_ e divertente. Il e è un linguaggio difficile che nMmalmeme è insegnato soltanto ai pr9gram.matori esperà, perciò questo libro è unko ua quelli sul C:
•
È adacco a chi ha u11a conoscenza tecnica, ma ha poea o nessuna esperienza di programmazi0ne. • È adatto aiprogrammacorì esperti che desidera.no una rran:u.ione rigorosa e approfondita del linguaggio. Come può un libro piacere a entrambi i gruppi? La cisposca è che il libro cofucizza il raggiungimento della chiarezza del programma, actraverso le provare tecniche di "programmazione srrurruraca". QueUi che non sono ancora dei programmacori impareranno sin dal.l'inizio il modo "giusco". Abbiamo ce:ncaco d i scrivere in un modo chiaro e diretto. Il libro è abbondanremente illuscrato. Cosa p robabilmente anche più imponame, il libro presenta U!l enorme numero d.i programmi nm7..i:ònanci e mosrra gli output (risultaci) prodotci, quando quesci programmi sono esegui.ti su un computer.
e
l primi quattro capitoli introducono i principi della elaborazione elem·ooica, la programmazione dei computer e il linguaggio C. Le discussioni sono corredare da una incroduz.ione alla pm~rarnmazione dei c0mputer, usando fapproccio srruccurato. I prindpianà
I
~
2
CAPITOLO l
che hànno st;guitçi i no:m:i ç<;mj ci haum:> a_ssicumo eh.e il materiale di questi c:apitoli :fumjsç_e una sçilid;i b_a.se per l'approfo-i:+ç!imerrro del C svilupp.ato nei Capiçqll dal 5 al 14.. Di solito, l prog1:ammatòri esp~rci leggeratu10 vclòCenJf'.nçe i primi ·quattrc:i cmpicoli e scoprii::ann0 in seguiti'.> che il e è tnttCato nci Capitoli dàl 5 al l'4 fil rilo.d.èl r~goroso e~ a.!Je stesso rempò, inù:.réSsarrce. &si a·pprez.?..eranno in modb parri~.òl.3.r~ i cipir6li avanzati, con la 101:0 ttatr-.izio ne dercagliata dei . puntateri, delle ·striflghe; dei. fil.e e delle s.rruttDX:e di dati. .Molri pi:ogra.ril.rti:àtori èsperu ·ci h:an:uo riferito Il loro a.pp:rez.zaniemo i;»er la nqstra di:scu-&sione. sulla progra.tll.Iili4ione stturrurarn. Per quanto ave~cr-0·~.togratlJ.Ula.t;o sp~sò in un linguaggi@ strunuraro come il Pa.Scà.I, non erano ili gradg di sciivère il miglior mdice possibile (?èrché non avevano .mai conosciuto in modo formale la programmat.ione srrutturara. Ora, d9p9 a:vçrç .imparam il C da quesrq libro, hanno· la possibilka di mLgliofare il p~opriq stile d.l pr.ògr.ammazio_ ne. Per oli, che siate dei prinçjpianti e;> dei pr9grammaT<,ffi esperti, in qu~éo libro ci serio .niolre q:»se cl1e potran.IlQ inf9nu:arvi, diverciwi e sti:mçilarv:i. ,Molti hanno familia:rirà con le cose interflSsanti che i compurer sono in grado di fare. In q.Uesto· çors_Q, imparerete a: Goma.nda.rn i çompur.e:c P,erché !facciano quelle cose. È il so_frtP,41·e (Q'vveJ:Q~~a, le istrn,7. tOni eh~ vgl sétiv~re rei: qrdinare al C.Omp.uter dJ ~seguJ re delle ~eo.:i e ptend~re ddle deci$-ioni) ~be GoQtr{')IJa i ço;\U_p.l.[cer. (dettispess_p, hartl;ti.1,4r~) . e il C'è oggigiomo urro dei.:-lingua_ggi dJ f?Ie&faill.maz.iòn,e più pop9la.ci. Qu,es-i;o testo fo.rp.istte un.a i.iirioduzione alla _progàmtnazioùe dell'ANSI C, la .versione sfand.ard.iizata. nel 198.9 Ji,egll StatiUhici dall'lstituto N'azionale Americano per gli Standard (AN.SI). e-, nél re.Sto deLriion~~ claJJfO.rganizzazi_one [ncemazionale per gli St~dard (ISO) .
Emilino dei· computer sca crescendo in q_urud rutti i cam_pl delle arrivicà W.n;tilè. In un'.crn:,di. cosri cosfamememe in cre5Cita, quelli della elaborafilone élettionica·sono. dimìnuici verrlgin osamG11te, a ca~sa degli impress.fonanri sviluppi deUa cecnologia hardware e sqF.twa:rG. Qu~i c-Q:mp.u~ ·el:!ç, 5~0 25 anni fa, po-i:evll.!10 riemi;>ire grandi stanze e costavano ntiUoµl di dQllar4 Qggi pq~.On() ..essere pi;odottÌ su lamine qi silici<:.> (çhip) più plçç~le Q.i Un'unghia, eh~ Gpsrape°.fors'e.. pochi doll;ui Itonicamen~e, il siUci.o· è uno dei mare.ciali più ahB.ortdand ~uHà teri:-at è un i..ngtedi~~.nte dcl.la. s~bbi_a cò.rtH1ne. b :rec-nol9gia dçl ch.ie çj.i silicici ha -res0· l'dab0:razion'e demonica cosl econo.miGi. cli~. 1P rutto il Jttòndo, sorr9 iJl Liso cenci~aia di milioni di, com.pucer general ~purpòse (per stopi generjci), .a.itttando la ·gente negli affari, ndl'indusrria, nel goveino e nelie loro virn personali, che potrebbero facilmenre .ra_M9ppiars.:i io una ;manciac.a c4_ anni.
PuO'..il Q esse.te ..illiegnam in 1Jil pmno <::O.tS0 di programmaiionc~ ovve.r.àsia è adart;o al. pubblìGo; a cui si riv.olge questo libro? Noi c1.:ediamo di sl. Qwiléne arino fa. :?])oifuho accertato questa sfida, q_ua.ndo il lingµaggi0 affermaco nei primi corsi di informarica era il P,ascal. ~biamo· se.ritto· C Boli! To Pr_ogram~ k prima: ediziçne d i que.§to •esco, e 0eminaia çli up.iyçr.si~~ in ;tuq-q. iJ m.onc;lo lo haf.1.no LJtiliZ?.n $pno smre òsse~are 'cl:ifferenze: significmiv~ eccettO d1i.gli l!l'Ud~ti ~<;i.no m<:gli~ ~'ociyari, perché S'ilino rlìe .nei 10.ro èfusi di livello superiore e nelle proJJ.tie aa.rrie.re;. use.ranno. con maggior probabil i.e~ iJ C die non il Pascal. ·m i studenti Ghe appiendonò il C sannò anèhe ehe saranno·megHo preparaci ad apprendere velocemente-il C++.Il C+.+ è una sevrascruuura dçl. 'G, ci'VOlt<} ai prGgr.arn.Qlatqri che vogUono s~vc;re pr<;>grammi q_ri~rati agLi oggerri. "Oil"e~O· quaJ~QSci Jn piì.t sul C+t neU~ S.ezfon~ l.1 4, 1
!fn funomeno imeressame, che ~i $J:a: veritìc_ando .nel mçrcaco dei linguaggi di programmaz.iq_.ne, èt che molti dei fornitoci prineipali, piuttli)Sto che offrire .~~ p·rodorti s,e pa.raci,
òb ve-nd.òn:ò· semplicemente. un CYC++, eo.qibinate. Ciò d.à al)..'ufç:.nc(!, se lo desi.de(a, , la posiibill~à'&. ~mitn.rare a prqgta)1i1.n.;i.re in Ce di n:iigrare 15radualme.n~e al C++, quando .lo .ii teuà op.poi;:i:u.Qp, S~.J;e" 4!mque per intraprenderè un p.erçQrso· i.ntel'~S!lftre e, s~riamo~ ~munerac:ivo. proi;:eder~~. se :v.orrece;c::omuuicit'e tron noi, inviateci una email su Tritemer
"M:ai:l rifa:ti'ò cbe
>allhdi'rim'o d.eitel~(le.i.tel . com. Fà:remo rutro i l possibile per rispondèrv.i vd0cememe. Buona fO.l'run.a!
l.2
Che cosa è un computer?
tJ'.n (fPPJJu'tgr è un d.isp0,si~ivq in ,gradQ di ~egw.re. dei ca.leali e di p-repdere dcl)è decisiQn.i, logj;~.Q.~, jJ cuct0 a una veloeit~ superiote cl.i .milioni e a nch~ .nii.liai:-di d..i -voke a quella degli ~~ti umani. Oggi per ese:oipi:o, ril.olti persona! computer possono eseguire decine di :mili0'fi'.i ili ~rd d.izion:i per sec.ònd.6. Una persona che operi a una calcolarrice- da tav:olo ;p&tEebbe. av.er Disogho di deGenni 1 per COIDj>le-tare lo Stesso llWttero di ~q:>lj cil.e un p~onal computer può ·e.seguire in un secqnd.o. (Punto çli illlessione: ~ome potres.te sap~re 'S,'e.:G ,pers~maJ1a.sommato correrça,mente..i num·eci? Comè pocr~'t~.sapére se il çoropure'r ha s<:>ftllillirç/ ~Q.cr~tQliileme i nurner.Ln . [ superconputer pi~1 vdoci oggi possono é~èguire ceu~tta:U. di rnilia1:di di addiziori'i pèi' seCt'.fodo: aJJ'in<;:i.r<::a quanto i éalcoli che énrinaia di llllgliaia é:Ìi p~dòue -pottebbero eseguire in un anno! E nei làbòraror1 di ricer€a stanno già filn'iionanélo computer i n grado èl.i èsegufre migliaia·di miliardi di, iscruzioui per secondo.
:r
'CQJUpute.x ~labo.ran.o i dati serto il co.ilrrollo di i.risiemi tli ism.izion.i c.h.ia:mati pfefl!l!,.mtn.'iper'coiftpz;ter. Tali programmi guidano il cc>mpurer per mezzo di insiemi ordinaci dkai'i.on1. specific:;ati da persone. chiamare prof!t11hrhatiJ1i di computer.. I va.ci disposici:'ti che t:P.mp,_ongt>no. un sisc~tnà di cpmpurer (çém'e la rastiers., lo sdierJn~, i.~~. lameii;loria, e l'uniTà di da.b.e r_ azione)-sono chiamaci co-mpléssiyanience.hardware. 1 Ifté~i che p0.$Sono ~sete ~e-gu.i.ti su ll'.ll C.Om.puter s.6ne. ch.ia.n'lati >'oftware. Il costo n;ll'Jia.fdware è diminuite >T&riginosamén-te negli ukimi anni, al punto che il personal l>o.fu~ucer è diventato un oggerro di uso comune. Sforrunata.meme, i cosci di ~ilupp<;> del sòkw<,U;e.sono andati aurmmcando costan~em:e .mah ma.np che i pr~grarn.maroti hanno svil~gpat([l iip,pliçµi_qni sempr.e' più potenti e çomplesse, SltIIZ:1. peraltro. esser:~ capaci d i Qctea.ere un .II)..Ìglioramento çorrispo.nd!!nre .nella tecnok~gia di sviluppo del softwwé. In SJ,~t<:l libro, iinparererè m·etodi di Sviluppo cl,el sl)frw.are the ne ciduc;on0 sesr.anz,i·alme.nte i·'*1S:d e ac~lerano iJ processo di SYiluppo d:i applicazioni softwar:e porènà e di alta qualità. .Q._l!.lesti merodj ..i.nclodono -la priJgratnrtJ.azio.ne StrUftt.f,rata, la pro.grarn.m·azione top4!J.wnj n!f. r.affinamenfi suGcessivi; la progr:ammttzione modulzzre.
1.3' L'organizzazione del computer fu'dtpe,nden:cem.!5ntè dalle diffeteil.ri ·;appal'eiize foi~he, ogni rompueer può e.sser.e virtualm~i:e (;ònòepito .come s.ttddivi.so in sei unit.à logiche o seZioni. Quèsre sono: 1.
CFnità di irtp1J.t (ingresso t/i dati). Qu~ra è la sezi.Qne ~'àcev:enre" d~ ~ompu.cer. Es.~a òc:tiene in~r~oni (dari e.progi:a.mmi per il c0mputeJ) da yà.r.i t/ispositivi di i'!:ipu.te. mene .queste Jofomiai.i.on~ a dispqsi2iane delle altre unità, in modo che possano essere el.abérare. La
WlfOLO l
4
maggior pane delle infoanazion.i o~gigiomo è '.mmessa nei computer arrravcrso una tasriera simile a quella di una ma:ccbina per scnvere. 2. Unità di output (uscita di doti). Quesra è la sezione di "spc~io~e" d~I co.m~ute~..~~~ µtende l'informa2ione che è stara_el;i.borata dal computer e lauw1aa diversi dtspo~i~tn a:t Offtpiit. lll modo da render.la disponi.bile per r utilit.'ZO all'escemo del c9mpurer, Ogg1g1orò.o la m~gg!or parte delle informazi0ni è invi.ara all'escerno dei mmpu.rer amavcl'so la visualizzazione sullo schermo o la srampa su carta. 3. Unità di memoria. Questa è l"3. scz1one di "magazzino" coo aecesso rapido e ~apaci rà cdààvamenre bassa dd computer. Essa conserva Le informazion.i che sono state immesse arn'averso l'unità di inpur, in m<:>do che possano essere rese irnmediai:a.mente ~is~oni bili quando saranno necessarie. "Lunirà_di memoria consei:va ~nch~ l~ 1nf~r;n:iz1.oni che sono già srare elaborare, Eìnran tò che; possano ancora essere mvi~te :u dispos10v1 di ouc_pm dalla corrispondente unità. L'unità di memoria è spesso chiamata anche memorut o
memorùi prima.ria. 4. Unità aritmetica e /.Qgictt (ALU). Ques!"l è la sezione di "produzi~ne'.' d.el con~p ucer.. È
1
resp~nsabile dell'esecU'iione dei calcoli c~m~ I~ sori:n:e, le som3.Z.10nt, le molnp kaz10ni e le divisioni. Essa conciene i me.cdill1Sm1 di decisione cbe con~enrono al compucer, per esempio, di confrontare due demenci p relevaci dalla un.i~à cli memoria, per determinare se sono uguali oppure no. 5. Unità di elaborazione centrale (CPU). Questa è la se:Vone "amminisu:acivà' del compu~ tee. E il coordinatore del computer ed è responsabile della supe.rvis.ione ?er ~e ope~on~ delle altre sezioni. La CPU indig alla unità di input il momemo m cru Le 1nformauon1 dovnnno essere lerre nella uni(3 di ~emoria, indica alla ALU. il momento in cui le ia.formaziònl della memoria dovr:µi.n9 essere uriliz.zate per i cakòli, e indica alla UJ1irà diomput jJ momento in cill·dovrà inviare le informazioni dalla unità cl.i memoria a certi di.sposiòv:i di output. 6. Unim di memoria second(lria: Questa è la sezione di "magamino" a lungo termine e.con alu capacità de.I cqmpurer. l programmi e i dati, ~e in ~n certo ~on~e~iro o.on sono utiliztari dalle altre unirà, saranno normalmenre s1sceman su un d1sposiuvo d1 .memoria secondaria (come i dischi), finché non saranno nuovamem:e necessari; probabilmenre ore, ?iorni, mesj o anche anni più tardi.
1.4
l!elaborazione batch, la multiprogrammazione e il timesharing
I primi çompucer erano in grado di ese;guire sciltai;ico un Jo.b (processo) e un. task (lavoro) alla volta. Questo modo di operare dei computer è spesso chiamato tlaboraztone batch (e.labo~
mtdtiprogrammnzione. La mulciprogrammaz.ione richiede l'elaborazione "simultanea" dimolci processi sul computer: questo, in altre parole, condivid,_e le proprie risorse tra i vari processi che comperano per la sua actenzione.. Con i primi sistemi in multiprogrammazione perèii gli urèn,ri dovevano ancora sorroporu i processi su mazzi dì sched.e perforate e attendere ore o giorni per i risultati. Negli anni '60, 1110ki gruppi indusrriali e le u nivenfrm esplorarono il concèrro di tirne.shari1zg (co,tdiJJisione del tempo). JI rimesharing è un caso speciale di mulùprogrammazione per mezzo del quale gli urenti accedono al compurer arrraverso dispositivi di input/ourpur o
terminali. In un tipico sistema di compucer in rimesharing, pocrcbbero esserci dozzine o anche centinaia di ucenci che condividono conremp<;>raneamenre il computer. In realrà, il compurer non serve rnrci gli urenti in modo simulra:n~o. Esso esegue piurrosto una piccola p.o.rz.iooe del processo di un utente e in seguire prese-a il proprio servizio all'urence successlvo, Il compurer fa rutto ciò cos) velocemente che, in un secondo, è in grado di fornire moire volre il proprio SCJVÌZÌO a ogni u rente. In questo modo gli urenti s,•mb1·ano esséré serv.iti si111 uItaneam.enrn.
1.5
l!elaborazione personale, distribuita e client/server
Nel 1977, la Appie Computer rese popolare il fenomeno della elaborazione pmonale. Al principio, questa era il sogno di ogni hobbisra. l computer divennero abbastanza ecéinomiei perché la genre potesse comprarli per il proprio uso personale o per i propr1 affari. Nel 1981 , la TBM, il maggior fornico re di comp urer nel mondo, imrodusse il Persona! Compmer IBM. L'elaborazione personale, lerreralmenre nel giro di una -nçme, diventò legirtima negli affari, nell'indumia e nelle 01:gani:a.azioni governative. Questi computer ~ralio però delle unirà "indipèn.d.emi": la gente eseguiva il propri0 sulla propria maccltlna e quindi rraspo.n:ava avami e·diecro dei disch i, per condividere lt: ioformabioni. Per quanro i primi personal compmer non fossero abbastanza potenti da gestire molti urenti in timeshacing, quesre macchine potevano però essere collegate insieme in reri di compurer; a volte su linee telefoniche e a volte in reà locali all'imenio di una organizzazione. Ciè ha portaco al fenomeno della dnborazione distribuita, in cui il Garico di daborazione di una organ.iu.azione, invece di essere eseguito necessariamente in qualche insrallazione centrale di compurer, è distribuito attraverso le reci alle varie posrazioni in cui vjcne svolto effertivàmeme il lavoro. I personal compurer erano sufficientemente potenti da gesrire Le richieste di elaborazione di urenti individuali e le fondamentali atti_virà della comunicazione: passare avami e indietro le infonnazioni in forma c:leruonica. b~0to
Oggigiorno, i persona! compucer pii1 poremi lo sono tanto quanto le macchine da un milione di dollari di solo dieci anni fu. Le macchine desktop (da cavolo) più porenci_ (dette workstation) forniscono ai singoli ucenci delle capacità enorrn.i. I.;informazione è. facilmente condivisa artraversole rçr:i dicomputer, nelle quali alcunt.macchine, derrefile server (fornitori di servizi. per i file). offrono un magazzino comune di programmi e dati che può essere utilizzato da macchine client (clienti) d isrribuire in runa la rece; da cu i il rennine elaborazione cliem/server. Il e e il C++ sono divem:aci i limmaggi di programmazione scelti _pe,r scrivere il software dei siscem.i operacivi, delle reti c;mpmer e deUe applicazioni distribuire in ambiemi cliem/serv.er.
dl
CAPITOLO
6
1.6
1
I linguaggi maccbjna, assembly e di alto livello.
I programmatori scrivono le iscruzi0 niin vari linguaggi
2. Linguaggi assembly 3. Linguaggi di alro livello Ogni computer può comprendere direttamente s0 ltanco il proprio linguaggio macchina. Il linguaggio macchina è la "lingua naturale" di un particolare computer. Esso è stretta.mente correlaro con la p.rogertazione deUtli.ardware del computer. I Linguaggi macchina cons1stono generalmenre di sequenze di numeri (riducibili in defìniciva a successfoni di l e Ù) che ordin·ano ai compurer di eseguire, una per volta, le loro operazioni più elemen~ari. I L~nguaggi macchina dipe1~d-0no dalla ma:cchin4: in altre parole, un parrkolare linguaggio macchina può essere ucillzuuo solrantQ..su un tipo cli compm:er. l linguaggi macchina sono scomodi per gli esseri wnani, com.e si può vedert: dal seguente frammento di programma in linguaggio macchina, che aggiunge la paga degli st:raordina.ri a quella base e immagazzina il risuJraco nella paga lorda.
+1300042774 +1400593419 +1200274027
Man mano che i compurer sono diventaci più popolari, e divenuto evidente che la programmazione in linguaggio macchina era semplicememe troppo lenca e noiosa per Ja maggior pane dei programmatori. Invece di us.are le sequenze di numeri che i computer potevano capire di.rettameme, i programmatori cominciarono a usare delle abbreviazioni simili all' inglese, per rappresenrare le oper:az:ioni elementari del compurer. Tali abbreviazioni formarono le basi per> i linguaggi assembly. Furono sviluppaà dei programmi traduttorì, chiamaci assembler (assemblatori), per convenire in linguaggio macchina, alla velocità del computer, i programmi sericei in linguaggio assembly. Anche il seguente frammento di programma i.o !Jnguaggio assembly ~ggiunge la paga degli straordinari a quella base e immagazzina il risultato nella paga lorda, .ma in modo più chiaro del suo equivalente in linguaggio macchina:
LOAD ADD STORE
BASEPAY OVERPAY GROSSPAY
I:utilizzo dei computer aumenéò rapjdamentecon l'avvento de.i linguaggi assembly, ma questi richiedevano ancora molte iscruzròni per eseguire anche il più semplice dei compiri. Per accelerare il processo di pmgramm.a:zione, furono sviluppaci dei Linguaggi di 11/UJ Li'l!e!Jo in cui si poteva scrivere una singqla istruzione per eseguire un compico essenziale. I programmi cradurtori, che convertono in linguaggio macchina il codice scritto io quello di alto livello, sono cb.iamaò compilatori. l linguaggi di alro Livello consentono ai programmatori di scrivere delle istruzioni, che sembr:i.no quas.i simili all'inglese di ogni giorno e contengono le notazioni matematiche urilizzare comunememe. Un programma per la busca paga scrirto in un linguaggio di alto livello porrebbe conrenere una isrruzione come:
..
N QZt!ONl Sl!J[l.,/\ EIA130RJ\ZIONE BLETI'RONlCA
grossPay = basePay
+
7
overTirnePay
Ovviamente dal punto di vista dei programrnamci, i lingµaggi di alto livello sono molro più desiderabili, in confronco ai linguaggi macchina o a quelli assembly. li C e il C++ sono rra j più potenti e più diffusamente utilizzati lingua!W di alto livello.
1.7
La storia del
e
Il C si è evoluto da due precedenti linguaggi: il BCPL e il B. li BCPL fu sviluppato da
Martin Richards, nd 1967, come un linguaggio per sçrive.re il sofrware de.i sistemi operativi e dei compilatori. Kcn Thompson prese a modello il -SCPL, per moire cararce.cistiche àel suo Jinguaggio B, e usò B per creare le prime vérsieni del sistema operacivo UNlX nei Beli Laboracories, nel 1970, su un computer DEC PDP-7. 11 BCPL e il B erano linguaggi "non tipizzati": ogni unità di .informazione occupava una "word" (parola) nella memoria e, per esempio, l'onere di considerare un dato come un numero imero o come uno reale dtì!deva sulle spalle del programmarore. TI Linguaggio C fu 1.ma.evoluzione del B sviluppara da Dennis Ricchi.e, .nei Be.LI Laboratorics, -e tii implemenraro originariamente su un computer DEC PDP-11, nel 1972. li C ini'~al menre divenne famoso come il linguaggio in cui era ~t:ato sviluppato il sistema operacìvo l.il$llX. Oggi, sono scritti in Ce/o in C++ quasi rurri i principa!J sistemi operaòvi dell'ultima. generazione. Negli ultimi vent'anni, il C è divenrato disponibile sulla maggior parre dei compurer.11 C è indipendence dall'hardware. Con una progcrra.zione arrenca, è possibile scrive.re in dei programmi che siano portabili sulla maggfor parre de.i computer. " utilizza molti imporrami conceni del BCPL e del B, mentre aggiunge la cipizzazione dei dari e altre potenci caratteristiche.
e
c
Dagli ulrimi anni '70, il C si è evoluro io quello che oggi è chiamato "C tradizionale". La pubblicazione, nel l 978, del libro di Kernighan e Rirdiie,1/ linguaggio di programmazione C, ha aràraro moire artenzioni su questo linguaggio. Quesra pubblicazione è diventata, in cam,po informacico, uno dci libri di maggior successo di cucci i rempi.
La rapida espansione dd C sui diversi cipi di computer (detci, a voi ce, piattaforme hardware) ha prodotto molte varlanci. Queste erano simili, ma spesso incompatibili. Ciò rappresentava un problema serio per i programmarori, che avevano bisogno di sviluppare un codice
-che potesse girare su piarcaforme diverse. Divenne allora evideme che era necessaria una '!~fS.ione standard del C. Nel J983, per "fornire una de.fi.n.i.zione dd Linguaggjo che non
tli>sse ambigua, e die fosse indipendente dalle maçchine", si creò U com.itaro tecnico X3J 11 , àlle'Clif:'>eni:lenze del Com itato Nazionale Ame.tic(!.no pef gli Scan<:lard dei Compurer e l'Ela-
bofazfone della lnformazione (X3). Lo standard fu a.pprcivaro nel 1989. Il documento si chiama ANSI/ISO 9899: l 990. Copie di qtLesto documè.mb possono essere richieste al~ L'lstituco Nazionale Americano per gli Standard, il cui indirizzo è riporcam nella. Prefazione di quesro cesto. La seconda edizione del libro d i Kernighan e Ritchie, pubbUcaca nel 1988, :riflecre questa versione, chiamara ANSI C. usata ancora oggi in cucco il mondo (Ke88).
Obiettit10 porrabiLità I. I Dato che il C è un linguaggio indipendente dagli hardware ed è largammte diffuso. le applicazioni scritte in C possono essere ese~ite, ccn poche o nessuna modifica, .m una vasta gamrna di sistemi di computer differenti.
8
CAPl'l'OLO 1
N @ZIONI SULLA ELADOtMZ IONE cLEn"RòNtcA
~·=-\:] \: .'] ~ ·lf>;,911't+t. ~
t
1,;f ;i. ~'°lo )(',)
..~,; •,t·.
r>..}1
I
1.8
La libreria standard del
e
1 programmi scricti in e, come apprenderete nel Cai;>itolo 5, consisrooo di moduli o peni chiamati funzioni. Voi porrcce programmar~ tu.ree le funzioni di cui avrere bisogno per scrivere un programma c. ma la maggior: pane dei programmatori traggono vantaggio da una ricca collezione di funzioni già esisremi, chiamata libreria standard del C. Di conseguem.a, ci sono in realtà due asperri del "mondo" del e da jmparare. li primo è imparare il linguaggio C in sé, menrre il secondo è imparare a utilizzare Je funzioni dclla libreria standard del C. Nel corso di questo libro, parleremo di molte dj quelle funzioni. l.:Appenruce B (condensara e adartata a partire dallo stesso documenro dello srandard ANSI C) elenca runele funz.ioni disponibili nella libreria standard del C. il libro di Plauger (Pl 92) dovrebbe essere letto dai programmatori d1e abbiano bisogno di una profonda conoscenza delle funzioni incl.use nella libreria, di come implementarle e di come usarle per scrivere un codice porrabi1e.
e
ln questo corso, sarece intoraggiari a utilizzare un approcciò di costruzione a blocchi per creare i programmi. Evirate di invenrare nuov;.uneme la ruoca e urili1!t.ate i pezzi già esistenti: questa si chiama riusabilità.dal software. Quando programmerete in e, L!S~rete tipicanrcnce i seguenti blocchi:
• • •
Le funzioni della libreàa srandard Le fum.ioni create da voi stessi Le funzioni cbe sono state sviluppare da alrre persone e che vi sono state messe a dispo-
siz.ione Il vantaggio ru creare le vosrre funzioni è che saprete esarr.uTiente in che modo funzionino. Sarete io grado di esaminare i1 codice C. Lo svanraggio è dato dal dispendio di rempo richiesto dallo sforto per progernrre e sviluppare delle nuove funzioni. Usare le funzioni già esisccnci vi evirerà di invenrare nuovamente la ruota. Nel caso deUe funzioni dello srandard ANSt saprere che sono state scritte con molta cura e che i vosrri progra.mmj avranno un'alta probabilità di essere portabile, poiché stace miliZ7.ando delle funzioni chè sono virrlialmenre disponibili su mere le implemenr-azioni ANSI C.
Obiettivo efficienza 1.1' Utilizzare le fim.zioni della Libre_ria standard ANSI, invece di srri.vere le uortre corris-pondenti versioni~ potrà migliorare l'efficienza del progmmma, perché quelle funzioni sono state scri'tte con ~·ura per wria e,ser:uzione efficiente. Obiettivo portabilità 1.2 Utiliz.zare le funzioni de//4 libreria [tandard ANSI, invece di scrivere le vostre corrispondenti vmi()ni, porrà migL/oratt:c la portahilità del programma, perché quelle fimzioni sono state incluse in qu@ tutt<: le versioni del C.
1.9
Gli altri linguaggi di alto livello
Sono stati sviluppati ceocinaiaru linguaggi di alco livello, ma solcanto alcuni hanno orrenuro un largo consenso. 11 FORTRAN(FORmuh -ptANslacor, Traduttore di formula) fu sviluppato dalla IBM, rra il 1954 e il 1957, p~r essere ut:ili'l.Zaco nelle applicazioni scientifiche e
>\ t
r'
;k'·. .r~·.~ .i.'5 \,,/;>('........,
di ingegneria che richiedono complessi calcoli matematici. 11 FORTRAN è urili~"-~''A .?-»~~~~ ..1:a::.. . 11.1r.. QJ.U.=ameote ancora oggi.
Il COBOL (COmmon Business Orienced language, Linguaggio orienraro alle comuni attìvità commerciali) fu sviluppato nel 1959 da un gruppo di produrcori di computer e di urenti gove.maàvi e industriali. li COBOL è milizzam principalmente per le applicazioni commerciali che richiedono una precisa ed efficiemc manipolazione di granili quancirà di dati. Ancora oggi, più della merà di nmo i1 sofrware commerciale è programmato in COBOL. pjù di un_milione ili persone sono impiega.ce come programmacori COBOL.
lJ Pascal fu progettaro circa nelJo stesso periodo del C. Esso era desrinaro a un uso aecademico. Diremo qualcosa di più a proposiro del Pascal nclla prossima sei.ione.
1.1 O
La programmazione strutturata
JJw;ante gli anni '60, molti grandi progcrti dj sviluEpO di software inconrrarono delle serie dlffkelrà. Si er,:i tipicamente in rirardo risperro ai piani di sviluppo del softw3Ve5;5~ immaginato. I.:arcivicà di ricerca degli annj '6!) ebbe C(lme risultato lo sviluppo della prop:amm.11.Zionc Strtttt'Jlnltll: UJl apprOCCÌO rusciplinato alla scrirrura di programmi chiari, '.fililla correttezza dimostrabile e semplici da modi.6rue, Il Capitolo 3 e il Capitolo 4 presenteranno llOa panoramiet generale sw principi della. programmaz.ione scrurrurara. Il re:sm del cesco affronrerà lo sviluppo di programmi suurruraci in C. _ Vno de~ risultati più tàngibili prodocci da questa rit':erca fu lo sviluppo, da parte dcl .Professor N1cklaus Wtrrh nel 1971, del linguaggio ru programmazione Pascal. 11 Pascal, me prese il suo nome dal matemarico e 61osofo dd d.iciassecresimo secolo Blaise Pascal, fu p.rogectato per insegnare la programmazione srrua:uraca negli ambienti accademici e divenee rapidamcnce il linguaggio di inrroduz.ionc alla programmazione preferico nella maggior parre delle w1iversirà. Sforrunatamence, il linguaggio mancava di moire delle srrua:u.re oec::c;ssarie per reoderl.o utile nelle appHca.zioni commerciali, .indusrriali e governacive, perciò nen fu accenaco dilfusamence in quesci ambienri. La stòrià può ben ricordare che la sua selezione come base del unguaggio di programmaziruie Ada è stara la reale imporranza del ~cal.
:L.Ada fu sviluppato sorto iI panocinio del Diparrimenro della Djfesa, degli Sraci Unici '80. Per produrre gli imponenri siscemi t~frw~e di comando e di co~rrol~o del ~OD, ern.no s.rati a.~za.ci cemtinaia di ling~1aggi d,tvers1. Il DOD voleva un lUll.CO lmguaggw che potesse andare mcontto alle proprie nece.ss~t'à. ll Pascal fu scclc~ come. base m~ Ada, i1 linguaggio finale, risultò completamente diverso dal Pascal. Il l111guagg10 prese i1 suo nome da Lady Ada Lovdacc, figlia dcl poeta Eord Byron. A Lady Lovelace è genera.Imenee amibuito i1 merito. di avere seri reo, all'inizio del 1800, il primo programma per computer del mondo. Una imporrante caracceàscica dcli' Ada è il multitasking. questo consente ai progra.mmacori di specificare che molte arrività dovranno verificarsi io parallelo. Gli al cri linguaggi dj alto livello ucilizzaci diffusamente di cw abbiamo discusso (inclusi il Ce il C++), ~onsentono di scrivere programmi eh~ eseguono soltanto una activicà per volca. Resta da vedere ~e l 'Ada abbia raggiunco U suo obiecàvo: ovverosia, produrre un software affidabiJe e ridurre soscanz.ialmence i cosci di ~iluppo e manucenziooe dd sofcware. ~IJ>QD.)., durante gli anni '70 e alJ' inizio degli
CAPITOLO l
10
1.11 Le basi dell'ambiente C Tutti i sistemi C consisrono generalmeme di ue parti: l'ambience, il linguaggio e la Libreria scandard del C. La discussione seguente spieghç.rà il tipico ambiente di sviluppo C, mostrato nella Figura 1.1.
Fase 1:
Fase 2:
Fase 3:
Fase 4:
L...--·~}
'---Edi-tor----'
~ -·~} Preprocessore!Compìlatore
~
~
..
..,..
~
Disk
)}
0Gk)}
Llnker
nprogramma è scaco crearo con l'editor ed immagaz.inaco nell'hard disk
11 programma preprocessore esegue il codice li programma compilatore crea il codke oggetco e lo immagazioa nell'hard dlsk
Il linker collegà iJ codice oggerco con le librerie, crea a. out e lo memorizz.a sul disco
Memoria Primaria
Fase 5:
Loader
,.
Memoria Primaria
Fàse 6:
Figura I . I
CPU
Un tipico ambiente C.
N0ZIONT ~HL.LA f.'.IA~ORAZlONEELETIRONJCA
Jl
r programmi scritti in e passano tipicamente attraverso 6 fasi , prima di essere eseguiti (Figura 1.1). Queste sono: editrm:, p1·eelaborar.e, compi-fare,, linknre (cotlegnre), caricare ed -estJguire. In questo contcsco ci concentreremo su un tipico sistema C basaro su UNIX. Qualora non sciare utiliz1.ando un sistema UNIX, fue riferimento ai manuali del vostro sjsrema, o chiedete al vosrro insegnanre di eseguire queste attività nel vostro ambience. La prima fase consisre nella scrittura del codice (editing) in un file: quest'a si esegue con un programma chiamato editor. Il programmacore scriv~ un programma in C con I'edicor ~. se necessario, eseguirà delle correzioni. 11 programma sarà quindi i.m.magazzinaro in Wl dis_posiàvo di memoria secondaria, come un disco. Il nome del .file del programma C dovrà terminare con l'estensione . c. 11 vi e l'emacs sono due ediror largameme ucilizzaci sill sistemi UNIX. 1 pacchetti software de! C/C++, come il Borland C++ per i PC lBM e compadbili e il Symancec C++ per l'Apple Macinrosh, dispongono di ediror incorporati che sono agevolmence integrati nell'ambiente di programmazione. Supponiamo che il letw re sappia come editare un progranlina.
1n seguico, il programmacore immccrcrà iJ comando di compilazione dcl programma. ll nel codice in linguaggio macchina (detto anche €ompilatore tradurrà il programma f:
e
Il linker carica in memoria il programma
La qwirra fase è chiamaca linking (collegamenta). I programmi se.cirri in C conrcngono tipicamente dei ciferimenc.i a fu.nz..ioni definire alrr0ve, per esempio nelle librerie standard 0 in quelle di un gruppo di programmatori che lavorano su Wl particolàfe progetto. Di c~mseguenza, il codice oggerco prodotto dal. compilatore èoncerrà tip'icamenrc dei "buchi" fl.ovmi a queste parti mancami. Il link" collega il còdite oggecro con quello delle funzioni mancinci per produrre una immagine eseguibile (senza pezzi mancami). In un tipico sisccma basam su UNIX, iJ comando per compilare e collegare j pezzi di un programma è cc. Per ~~empio, per cempilare e collegare i pe-;;:.d di un programma: cliiamaco welcome . e scdverece
La CPU esegue un' iscruziorlc per volta immagazinando i nuovi dari oa:en.uci dall'esecuzione del programma
(f(;
welcome . e
al prompt di UNIX e premerete il tasto invio. Ne.I c~o il programma sia staro compilaco
e collegato corrcrramencc, sarà prodotto u.n file c:h.iamaro a . out. Quesro sarà l'immagine eseguibile dd nòstro programma weloome.c. La ~uinta fase è d1iamara ctJtù:amento. Prima eh.e possa essere eseguiro, un programnella memoria. Questa operazione 5arà~eseguiradal !.oader (caricatore) che prenderà l'immagine eseguibile. dal disco e la trasferirà ne.Ila memoria.
ma dovrà essere caricato
FinaJmenre, soLTo iJ controllo della swi CPU, il compmer eseguirà il programma, una istruzione per volta. Per caricare ed eseguire il programma in un sistema UNIX, scriveremo a. out al prompr di UN1X e premeremo il casco invio.
12
I
I
I
I I
I I
CAPITOLO 1
e
La maggior parte dei programmi scritti in ricevono e/o produco no dei dari. Certe funzioni scritte in prendono il propri<;> inp ut (i dari in ingresso) dalle stdin (il t;/.ispcti.#vo standardperI'input), che è assegnato normalmente alla cascic:.ra, ma lo stdin porrèbbe :tnche essere eonnesso a un alrro clispositivo. .Loutpltr {i dari io uscita) è inviato allo stdout (il dispositivo standard per /'outpuÌJ, che è normalmenre lo schermo del compurer, ma che potrebbé anch e e.ssere connesso a un altro dispositivo. Q uando affermiamo che w1 programma scampa un risuharo, normalmente, imencliamo affermare che quello è vis~zzaro sullo schermò. I dati possono essere inviati ad altri dispositivi, come i
e
1.12
NOZlON l SUUA ELABORAZIONE El.EJTRONICA
Noi abbiamo preferito Umica.re la nostra discll5sione all'ANSl C. Moire tt.u:attcrisciche incluse nel,l 'ANSI C non sono corn.paù bili con. le altre implementa'l.ioni d el C~ perciò porreste verifìarre chè alcuni dei programmi di questo testo non fun·rionan·o sw compilarod più darari.
e
Buona abitudine 1.2 leggete i manuali della vers;one det C che state usando. Consultate frequentemente qu.esti manu.dli per essere sicuri di conoscere la ru:c·a colfe.Uone di caratteristich-e dei e e Jj 11.sarle in modo con·etto.
Buona abitudine 1.3 Il vostro computer e il vostro compilawre sono dei buoni in.segnanti. Qua/ara non s111te siciui di come fanzioni una caratteristica dcl C, scrivete un programma di esempio con quella caratteristi.ca, compilatela ed eseguitelo e osservate quei/o che succede.
Note generali sul C e su questo libro
e
e
Il è uu lingt1aggio difficile. A volte, i p rogrammacori es~eni S"OUO org<>gliosi d i essere capaci di creare u cilizzi bizzarri, conrorri e c_omplicaci del Unguaggiò. Quesra è una cartiva abim.d ine di programmazione. Essa rende i programmi difficili da leggere, maggiormcme soggetti a comporramemi suani e più difficili da collaudare e correggere. Questo lihio è ade~ro ai programmatori principiami, p erciò ci sjamo sforzaci di scrivere prpgrammj chiari e ben srrurcurari. Uno dei nostri o biettivi principall, in q uesto libro, è q uello di P~.§~ui.re la chir.zrezza dei program m i, am a.ver.s o le comp rovare re.c;niche di programma:z.iònè s trumtrara e le molte correlate buone :abirudini di p rog4\Iiullazione.
Buona abitudine 1.1 Scrivete i vostri programmi C in u1za maniera semplice e diretta. Qu.emt 1·egola è tktta volte KIS ("keep·it simpLe '~ mamienilo semplice). Non 'forzate" il linguaggio, tef:J,tando d.elLe "stranezze''. 4
l'otrei;te ave.r sentiro dire che il C è un linguaggio portabile e che i programmi sccitti in
C possono essere eseguiti su molti computer differenti. La pqrtabiifrà è un obiettivo sfuggente; Il documento deUo standard ANSI (An90}annovera ben J 1 pagine di insidiosi probiemi rigtiardanti la pon:abilicà. Sono srari scritti libri interi sull'argomento della porrabilii:à nel (fa89) (Ra90).
e
Obiettivo por.tabilità 1.3 Per quanto sia possibile scrivere programmi portabili., ci sono molti problemi tra 'le tan-
te implemenrawmi de.I Ce i vari com_puter, che rendono laportabi/ì~ un obiettivo difficile
da raggiungere.. Scrivere semplicemente dei programmi in C non ne gara11ti.sce In portt1bi/ità. Abbiamo eseguiro una attenta vedfìca del docwnenco deUo srandard ANSI Ce ahbiamo çonfronraro con q ueij9 la nostra presentazione per complerez.za e accuratezza. Turravia 1 il C è un l i.nguaggio molto ricco e ci sono akWJe sortigliezze nel liàguaggio e cerci argomenti avanzati d Je non abbiamo u·artaco. Vi suggeriamo di leggere lo stesso docum.en te d eUo Standard ANSI o il manuale di riferimento di Kcrnighan e Ritchie (Kc88), D~ caso dovC§re aver b isogno di ulteriori dercagli recn.ici sull'ANSI C.
e
13
1.13
Il Concurrent C
Altre version.i del C sono State sviluppate per mezzo degli sforzi continui della ricerca nei Bel! Laboratories. Gehani (Ge89) ha svilupparo il Concurrenr C: un superinsieme del C che include delle primitive per specifiearc delle anivitl...multiple che porranno essere eseguite in parallelo. E n rro i prossimi dicci anni, con l'aumento dell't1cilizzo dei multiprocessori (ovverosia, dei romputer con pi.ù di u na CPU), i linguaggi come i.I Con~urtcn t C e le caratteristiche de.i sistemi operativi che supporcano il parallelismo ne.Ile applicai.ioni dell'utente, divenrecanno sempre più popolari. Per quanco riguarda questo testo, il Concurrent C è ancora principalmente un linguaggio di ricerca. I corsi e i libri ili testo sui sistemi operativi (De90) includono solirameme rratta.iioni corpose sulla programmazione concorrente.
1.14
La programmazione orientata agli oggetti e il
e+ +
Un alcro supecinsieme del C, oss,ia il C++, fu sviluppato da Srrousrrup (Sc86) nei BelJ Laboratories. Il C++ fornisce diverse cararceristiche che migliorano il linguaggio C. Ma, cosa più imporrante, fornisce delle primitive per fare una programmqzume orimtt1.to
agli oggetti. Gli o.ggetti sono essenz.ialmenre dei componenti sofrware riusabili che mo dellano glj d ementi del mondo reale. C'è u na rivoluzione in preparazione nella comnnicà del sefcware. Costruire il software velocemenre, corretcameme e io m0do economico cimane un obiettivo sfuggenre e questo in un perioqo in cui aumeman o vertiginosamente le richieste per un software nuovo e più porenre. Gli svilupparori di software stanno scoprendo che, utilinando un approccio modulare e orienram agli oggetti per la progenaz.iooe e l'implementazione, si porrebbe. fare in modo che i gruppi d i sviluppo siano dal Oa 100 volce p iù p!7Ciduttivi di qua nro fosse. possibile con le tecn iche di p rogrammazione convenzionali. Sono stari sviluppaci molti linguaggi di programmazione oriemari agli oggerri. Molti docenti sono convinri che la migH<'.lr suacegia educativa oggigiorno sia cli imparare a fondo il C e di studiare, io seguito, il C++.
L4
,,
CAPITOLO
1
N oz1.0NJi SULLA F.l.ABORAZIONE ,Ebc'JTRONICA
Esercizi di autovalutazione
Esercizi
1.1
J .3
Riempire gli spazi in ognuna delle segue.nei frasi; a) r:azienda che ha scacenaw il fenomeno della elaborazione personale nel mondo è sr.ira la b) li compuccr che h.1 legirtimaro l'elaoor-azione personale nel commercio e ncll'indumia è
staro il _____
e) l computer elaborano i dari sonoilcormoUo dj insiemi di imuzioni chiamati _ _ _ __ per computer. d) Le sci principaLi unità logiche del compurer sono - - - - - - - -- e----e) U ~ un caso speciale deU:i. multiprogrammazione in cui gli urend accedono al compurer ama verso dispositivi ch..iàtriaé ceoninaJi. f) Le rre classi di linguaggi discusse in quèsro capitolo sono _ _ _ __, ____ _ e
r programmi che Lr;tducono in lingu
Quc$tO libro prescnra .la versione del G
1.2
b) 1n un sisrema C, prima che incominci la fase .di rrad1J2ione, sarà eseguito auromacicamenre un programma _ _ __ _ c) l due i:ipi più comuru c:U direrrive del prèprocessore sono e _ _ __ _ d) TI programma / c;pmhiua l'output del compilarore con le varie funzioni di libreria, per produrre una immagine eséguihile: e) li programma crasferisq: l'i1lllilagine eseguibile dal disco alla memoria. f) Per caricare cd eseguire iJ programma c9mpila:ro più recenrcmeme su un sisrema·UNIX, digirace -
Risposte agli esercizi di autovalutazione 1.1 a) Appie. b) PersonaI Compurcr della JBM. c)' programmi. d) unità di i npur, unirà di oucpuL, unità di memoria, uoitll aritmeriea e logica (ALU); unità. di dabo.raztone centrale (CPU), unità di ~emoria secondaria. e) rimeshacing. f) linguaggi macchina, linguaggi assembly, linguaggi
15
Classificate ognuno dei seguenti elementi come hardware o software: a) CPU
b) c:ompilatorc e e) ALU
e
16
CAPLTOLO I
p,) Qu.a.le unità .logica dcl comp uter coordina le atrivid\ di nme le ahre unìcà logiche?
1.,7
Deren ninai:e se ognuna delle segue nti affermazioni sia vera o falsa. Spiegare le vòsrre risposce. a) I linguaggi macchina dpend onQ generalmen te dalla macchina. b)' ll dmdh aring consente realm enre a molci utenci di usare simul~eameme un computer. ç) Come gli alrri linguaggi di allo ljvello, il C è generalm.enre considerato indipendenrc dalla m.acchhia. 1.8 Discutete il significaro dj ognuno dei seguenti norrù in ambieme ONIX: ~) stdin b) stdou t e) stder r 1.9 Quale caratteristica cbfave è fornita cW Conc urren t C che non sia disponibile in ANSI C? 1. 10 Perché oggigiorno c'è cosl c:anca armu.ione conéemrarn sulla progr am=. ione orienrara agli oggecci, in generale, e sul m particolare?
e-
Let ture consigliate (An90) ANSI, Amerim11 Natioru1LSr.a1ulardfor_l1rfarmnt ~o11 Sysr.emr-Rrogrammi11g language C (ANS I .Dommcn r ANSJ //S() 9899: 1990), New York, NY: Arnecican Nacio nal Standards lnstitutc, 1990. Qucs~o è ll qocuruemò che de.finisce i'ANS I C. Il documen to è ilispouibile in vend.ira prc:~so l'Amc rican Narional Srandard.ç lns1 imce, 1430 Broadway, New York, New York I 0018. (De90) Dci rei, H. M. , Opmifing .S)rmns (Second Edltiqn), Reàdlng, MA: Addison-Weslcy Publlshing Company, 1990. È un manuale.: per JI midizionalc éérso dj informatica çUÌ sistemi operativi. J capitoli 4 e 5 presen tano una approfondita discussione sulla prégramma:r.iom: conco.mmcc. {Ge89) Gchani. N. , and W. D. Room c, The Conmrrmt C Programmmg 1..m1gu11ge, Summir, NJ: Silicon P.ress, L989. ~uesro è il libro
.ru _defin_iuonc del Conc~m:m C: u.n pro.grammacorr ili specificare un:a esecoz1one pàralldaSl1pcri~ieme d~l linguaggio ~· che cons~nre di attività multiple. f. anche mduso un compenwo del Concurrcm C++. Oa89) Jaeschke, R. Portabiiity ond the e Language. Jndian apol.i$. fN: Hayden Books. 1989. Questo 1ib.ro discute la sori.rmr:i in 4i progrruruni porwbili. Jacscbke ha pancdp:iro ai coniitaci ANSI e ISO per·gli srandard del C. (Ke88) r<.ernigh:m, B. W:, :md D. M!.Ricchie, Tht C Pmgmmmi11g l011g11age (Second Edicion), Englewood Cliffs, NJ: Pr.cncrce Hall, 19.88, Qucsco librò è un classico nd settore. Il libri'! è ampia mente ucilin.'lro, nei corsi di C e nei seminari pµ i Rrogrammatori di ruolo, e iriclude un eccellcnce manuale di i:iferifncnro. Riccrue è L'aucore de.I linguaggio C e uno dci progettisa dcl sistema operar ivo ONIX. Wl 92) .I'.lauger, P. ]., '!11e Srmul11rd C Libmry, Engle wood Cliffs, NJ: PrenticJui il quale ha convotlato. il COiJJj l3CO [$Q per l'evoluzione dcl C. (Ra90) Rabinowicz, H., aod C. Scha3p, Portab/.c C,..En gbvood Cliffs, N); Prencice Hall, l990. Quesro libro è stato svUùppaco per u.n corso sulla porrnb ilicà tenuto neglLAT&T Beil L!borawries. Rabinowirz..hvora presso il Laboratorio ili lncelligenz.a An:l6ciak della NlN.EX Corpor-Jcion, mentre Scbaap è un.Jirigent« dc.Ila Ddfi Consulting Corpo ration. (Ri78) Ritchie, D. M.; S. C. Jobnson; M. E. Lesk; and B. W. Ketnìghan, "UNL,'{Tune-Sha:riog Syscem: The C Programmlng Language", Th11.Btll Systn11 Tech11ical Joumal, Voi. 57, No. ~. Pan 2, July-Augusr 1978, pp. 199!-20.19. ai.
I
e
Questo è uno degli arri.coli classici di inrroduz.ione al linguaggio C.Apparve..in un num~ro spec;iale! deUa rivisr;i Bei~ Systm1 1iodmk11l foumiil dedicar.a al "Sistema dJ funcsharing jo UNIX".
Nozr oN1sulli \ Fl.ABORAZIO NE ELETrRGNIC A
17
(lli84;) Rir.chie. D. ~·I. . "The UNlX $ysccm: The Evolu ùon of the UN rx Time-Sh:uing Sys~m~. AT&T &Il Labor;nrpries 1ì11:hnicn,ljournn.J.°Vol. 63, No. 8. P.ort 2, Oc;tobcr 1984, pp. 1577-1593. Un articol o classico sul siscema operativo UNIX. Quest o anicoJo apparve in una edizione :;peciale della rivistn Bd./ .'>)•stem Tedmkttlfoltrnal complecame nre dedicata al "Sisrema UNIX". (Ro84) Roslc.r, L., "Thc UNIX Sysrcrn: Thc F.voluc .ion ofC- Past ;md Future", A116-T BellLnborniories Technical. jo1m10/, Voi. 63, No. 8, P:m 2. Ocrober 1984. pp. l 685-L699. t w 1 cccdlenn: artico lo, da far seguire ~dRi78) , per il !errore interes sato a cracèiare In scoria del C e le radici dello sforz0 per srandardizzare i'ANSI C. App3r vc in una edi:t.Jone speciale della rlv1sra B,l/ System 7echnical jonrnal dedicira al "Sistarna UN IX". (Sc84) Srrouscrup, B., "The UNlXSysU!fT1: Data.Ahsrrac tion in C,Ar &T BellLnb.o.mtorit:s Tcchnic11ljoumal, Voi. 63. No. S, Pan 2. Octoher l984. pp. 1701- 1732. t:arcicolo classico di introdLLiione al C++.Comparve in una edizioni; speciale ddl:t r.ivi.sra Bcl!Syswrn Tethnicoljoumol dcdk ara al "Sisrema UNlX ". ~St9J.) Srrousuup. B. The c.~+ Progmmming Lìmti11 1ge (Sccon d Edition), Reading, MA: Addison-Wesley Serics in Computer Science, l 991 . Qoesc olihro è'il riferimenro per la definii.ione del C++: un supecinsieme dd C, che apporca vari mi· glioramemi al e, specialmente le car:arrerisciche per l
CAPITO LO
2
Intro duzi one alla prog ramm azio ne in
e
Obietti vi • •
•
Esserdngr ado discrivere semplici programmj per computer in C. Essere in grado cli usare semplici istruzioni cli input e cli outpuL
•
Familiarizzare con.i tipi cli dato fundarnent:ali. Comprende re il funzionamem:o della memoria del computer.
•
Essere in grado cli usare gli operarori aritmetici.
•
Comprengere le regole cli pcioricà degli op.eracor.i ari:rm.etici.
•
Essere in grado cli saivere semplici istruzioni decisionali.
2.1
Introduzione 11 linguaggio e fac.ilira u.n a(>ptocci.O scrurturato e discipLlnat o alla
progenazio ne ru un pr ogramma per computer. In questo ca.pi.tolo introducia mo la programm aziqne in e presentiam o molci esempi che illusrrano varie importami cararrccistiche del linguaggio . Ogni esempio è .aualiz:1.aco aaencamem e, una isrru1.iooc per volca. Nd Capitolo 3 e od Capi cole 4, prescmiam o una inc:roduzione alla programmazione stnetturata in C. lo seguim, useremo l'approccio srrumirato in rutta la parre rirnanenre del libro.
e
)'
2.2
e
Un semplice programma C: visualizzare una riga di testo
u.rilizz.a alcune notazioni che possono apparire strane a eh.i non ha mai programm ato un computer. Comincere mo consideran do un semplice program.m.a C. ll .nosrro pcimo esempio visualizza una riga ru cesto. Il programm a e la schermata dell'ou rput risultante sono mosc:raci nella figura 2.1. Il
Per quanto questo programm a sia- semplice, iJlusrra mqlce cararrerisciche importa:a.ri del linguaggio C. Consideria mo ora nel dettaglio ogni riga del programma . La. ciga 1•
Un primo programma e */
incomincia coh /*e termina con ""/ per indicare che la riga è un commentc. l progra.mmacori inseriscono dei commenri per documentare i programmi e migliorare la leggibililà degU stess.i. [ coniménci non. p rovocano l'esernzion e di nessuna azione da pnrte del computer, quando il prof,rrn.mma viene eseguito. l commenti sono ignorati dal compilator e e
e
20
CAPITOLO 2
non inducono la generazione di alcun codice oggerro in linguaggio macchina. ncomme1no Un primo programma C descrive semplicemence gli scopi del programma. I commenri
aiunuio anche le alcre persone a leggere e comprendere iJ vostro programma, ma rroppi commenti potrebbero rendere diffiçile la lettura dello stesso. Un primo programma C */
/*
ma i n() {
l NTilOOtr.llON E ALU\ PROGRA.W.IAZIONE IN C
21
c::ararcere backslash (\)è den:o carattere di escope (fuga). fusq indica alla printf clie dovrà fare qualcosa fuori dell'ordinario. Nel momcnco in cui avrà i.nconcraro un backslash, l'istruzione printf guarderà il c:arnttere successivo e lo unirà con il backslash per foi;mare una se_qu.enztJ di escape. La sequenza di escape \ n significa iu:wline ·(nuova rig--~) e pròvoca il posia.ionamento de.I cursore nella pusizione iniziale della riga successiva dello schermo. Nella Figura 2.2, sono elencare alrre sequenze di escape tipiche. Lisrruzione printt ~una delle rance funzioni fornite dalla Libreria standard del C (ed dencate nella Appendke B). Sequenza
printf('Wel come to
C!\n ~) i
di escape
Descrizione
\n
Newline (nuova riga). Posiziona il cursore all'inizio della riga successiva. Tabulazione orizzontai~. Muove il cursore alla tabulazione successi·va.
}
(
)
Welcome to Cl
\t \r
Ritorno carrello. Posiziona il curS-Ore all'inillo dclla riga còrreme; non lo fa av3.Jl7..a.re a quella successiva.
Errore tipico 2.1
\a
AUarme. Fa suonare il cicali no dd sistema.
Dimtmicare di urmùzare un commento co11 "/.
\\
13ackslash. Visualizz.a un cararrere backslash in una isrrLI2ione printf. Apice singolo. Visual izza un carattere apice sin?olo in una istruz.ioue p-rintf.
Figura 2. 1
Un programma che visualizza del testo.
\'
Errore tipico 2.2
, ~
Jncominciare Ull COmmenJo (()Il Ì caratteri
''/O temlÌllllTW C01l /"'.
La riga
Figura 2.2 Alcune sequenze di escape tipiche_
Le ultim'e tre sequenze di escape nella Figw'a 2.2 pou.ebbero semhrare srrane. Dato che il backsl:ish ha un significato speciale per l'isrruzione primf, ovverosia essa lo ricono-
ma i n() è una parre presente io rutti i programmi C, Le parentesi dopo main indica.no che main è un blocco di costruzione del programma. éhiamaco fimzione. r programmi e com:eogono una o più funzioni., fina delle quali deve :essere main. Ogni p1ogramma C comincia eseguendo la funzione main. 1
~
Virgolette. Visualizza un cararre.re virgolen:e. in una istruzione printf.
Buona abitudine 2.1
l(2J
Ogni fitnzione do!lrehbe é'ssere preceduta da un cotnmento che ne descriva·g/Ì scopl. La parentesi graffa aperta, {, deve aprire il corpo di ogni funzione. Una corrispondente parmtesi graffe chiusa deve chiudere ogni funzione. Q uesra coppia di parenresi graffe e la porzione di programma racchio_sa in esse sono and1e cl.erre blocco. Il blocco è w1a importante unirà dei prog(ammi C. La riga
printf( "Welcome to C!\n'); ordina a1 computer di eseguire una azione. visualizzare sullo schermo la stringa di caratteri indicata era le virgolette. Una stringa è a voi ce detta stringa di c11.mtteri, messaggi-O o letterale. L'intera ciga, incluso printf, i suoi argomemi all'inrerno delle parencesi tonde e il prmto e·vitgoltt (.; ), .è derm istruzione. Ognuna di queste deve cermU:i.a.re coo un punto e virgola (detto anche. te.nninatore di istruzione). Nel mo~ento in cui sarà e.seguira, risrruzione printf precedente visualizzerà sullo sch~rmo il mes~o Welcome to e I Normalmente, i caraneri sono visualizzati nello sresso modo in ctù appaiono m le virgoierre della i ~'Ull2ÌOne printf. 0$~ervate che i ~cararlcri \n non sono srati vis1:1alira.ad sullo schermo. TI
sce come un carartere di e.scape, piurrosto che come un qualcosa da visu.a.liu.are, utilizzeremo un do ppio backslash (\\) per indicare che oe dovrà essere visu.alizzaro uno singolo. An.che scampare le virgolette presenca un problema per l'istruzione prinrf, p0iché essa normalmente presume. che queste ultime indichino i limià di una stringa e che le stesse non debbano essere effetrivamence visualizzate. Usando la sequen7.a di <:Satpe \", informeremo prinrf che dovrà stampare le virgolette. La parentesi graffà chiu;a, }, indica che è stata raggiunta
la fine
dcl m·ain .
j~ Errore tipico 2.3
~ hn.mettere in un programma il norne.detl:afunzi.one di output pr-intf
come·print.
Abbiamo affermato che l'istruzione printf spinge il computer a éseguire una azione. Nel momento in cui è in esecuzione un programma qualsiasi, il computer svolge una serie di azioni memre il programma prende delle decigoni. Alla fine di quesro capicolo, aatreremo delle. isauzion.i de<':isi0nali. N'el Capirnlo 3, spiegheremo ulceriotmence questo modello di azione/decisione della pr9grammazione.
È impo-rtanre osservare che le funzioni della libreria srandard, come printf e scanf, non faru10 parte del linguaggio di programmazione C. Di conseguenr.a, il çompilamre non potrà trovare, per esempio, un errore di batcinua in printf e scanf . Nd momenro in cui l'istruzione. printf sarà compilara, iJ compilaro.r:e fornirà semplicemente uno spazio, nel progr:tmma_ oggerto, per una "chiamata" a quella. funzione della libreria. U compilatore
22
!NIRODUZIONè Al.l.J\ Pl~UGRAMMAZION!! IN
non sa dove sir.rovino le funzioni ddla libreria a differem.a del linker che, quando sarà cseguico, individuerà le funzioni della libreria e inserirà od programma oggerco le ch.iamace appropriare a queste funzioni. A questo pumo il programma o&,aerro è "completo" e promo per essere eseguito. Il programma prodorro dal linker, infarr.i, è spesso chiamato eseguibile. Nel caso dovesse esserci un errore di digicazione nel nome della funzione, quesco sarà individuato dal linker, perché, per quel nome nel programma C, esso non sarà in grado di trovare una corri~ spoudenza era i nomi di rune le fumjoni noce delle librerie.
23
C
/* Visualizzare righe multiple con una singola printf */ main {) -{
printf('Welcome\nto\nCl\n'); }
Buona abitudine 2.2 L'ultimo carattere stampato da u114 fanzione che Megue qualsiasi visualizzazione dovrebbe essere un newline (\ n). Ciò assictmt che la fon.zione /,asci il cursore dello schermo nella posizione iniziale di una nuova rig4, Li> çun.ve,n.g;ioni di questo genere incoraggiano la riusabilità dci sofiware: un obkttivò forrdo.ment.ale negli ambienti di sviluppo.
l
Welcome to
[
e1
Figura 2.4
Visualizzare righe multiple con una singola printf.
Buona abitudine 2.3
2.3
Fate rientrare l'intero corp" di ogtd fu:n.2iivnt: qi un Livello (tre spfl.7-i), all'interno deile parem:esi gr1iffe che definiscono il corpo de(iafimzione. Cià enfatizza ltt strutturtt fimziotude del programma e aiuta tt renderlo più leggibile.
TI nostro prossimo programma milizza la funzione scant della libreria standard per leggere due interi digirat:i alla rascic:ra daJl'ureme, calcolare la somma ~ei due valori e visualizzare il risulrato U;Saodo la funzione printf . Il programma e I'oucpur d i esetnpiq son0 mostraci neUa Figura 2.5.
Buonn abitudine 2.4
/* Programma di addizione */ #include
5'-egliete una convenzione pçr la dimènsione del rientro che preferite e qwndi appiicateiA uniformemente. Potrebbè essere utilizzato il tasto di tabulazione per cretlre i rientri, ma tenete pres-ente che i punti di 4rrestv delle tabulazioni potrebbero variare. Rm:comttndiamo di usare delle tabulazioni da 114 di pollice (6,35mm) oppure di contare manualmente tre spazi per ogni livello di rientro.
main() {
La fum.ione printf può visualizzare Welcome to e I in molci modi differenci. Per esempio, il programma della Figura 2.3 produce lo stesso ourput dcl programma in Figura 2.1. Ciò accade perché ogni printf riprende la visualirtaz.ione dal punto io cui s.i era fermata quella della printf p'recedeme. La prima printf visuaHua Welcome seguito da un.o spazio, meoc:re la seconda printf inmmincia a scampare immediarameme dopo lo spazio. Usando il cru·artere newline come nella figura 2.4, uua sing0la funzione printf porrà visualizzare diverse ~ighe. Ognl volta che inconcrerà la sequenza di escape \n (newline), la funzione printf si posizionerà all'ini~io d~ll~ riga successiva.
Un altro semplice programma C: sommare due interi
i nt integer1, integer2, sum;
/ * dichiaraiJ.oni */
prifltf('Enter first integer\n ") ; scanf( "%d", &integer1); printf( "Enter second integer \n'); scanf("%d", &integer2); sum ; integer1 t integer2; printf("Sum is \d\n'', sum);
/" /* I* /*
return 0;
/* i ndica c he il prog r amma è t erminato con successo
EntFer f irst
inte~er
45
ma in()
Enter second integer 7.·2. suin is 117
printf("We lcome "); printf("to Cl\n");
Figura 2 .5
}
(
Wel oome to Cl
Figura 2.3
Visualizzare su una riga con iscruzioni printf distinte.
]
~1
}
/*. Visualizzare su una riga e
prompt */ l egge un intero */ pròmpt */ legge un intero */ 1~ a~seBnamento della somma 'I t• visualiz.z.a la somma •t
'
Un programma per la somma.
Il comrru:nro / * Programma di addizione * I dichiara lo scopo del programma. L'l riga #incl!Jde
è uoa direrriva per il preprocessore del C J..e righe che LnCOlflÌncianO COD /I SOUO eJabocace daJ preproéessore, prima che il programma sia compilaro. Questa specifica riga indica al preprocessore
G\PITOLO 2
24
dì indudcrenel programma il concenuco del file di intestazione per l'input/output rMndard (stdio. h). Quesro file di imes.roziQne conriene Le informazioni e le dichiarazioni u.sace dal compilarore durame la compilazione de.ile funzioni per l'input!ourpur srandard, come printf . Il 61e di inu:sraz.ione contiene anche infurmaz.ioni che aimano il compilatore a dererminaie se le chiama.re alle funzioni deità Hbrecia sian0 sc:ace scrirte correttam en~e. Nel Capitolo 5 spiegheremo più decragliatamenre i conrenuri dci filè dl inresw.ione.
Buonr1 abitudine 25 Per quanto I'inclu.sùme di <$tdio. h> sia op~onafe, esst1 dovrebbe essere effettuata in ogni programma e dhè utilizzi u.nn qfl._11'1p1q1-{e delle funzioni di inptf.t!output della libretia standard. Ciò aiuterà iJ' compilatore tt sempilfico.l'vl l'individuazione-degli e1:rori durante fafìr.se di compilazione del vostro progrrzm~ piuttoSùJ che durante quei/a di esecuzione (quando gli errori sono di solito più onerosi da correggere). Come abbiamo affermam in prncedem,a, ogni prowam.ma cominc_:ia la propria esecuzione con la fonzione main. la parenresi graffa aperca { marca l' inizio del co~p9 del main mentre la ç9rrispon dcnre parentesi graffa chiusa marca la fìnc d.i quesr'ulti mo. La riga i nt
inte~er1,
integer2 , sum;
è una dkhitt1112.ione . .Le voci integer1 . i nteger2 e sum sono i nomi delle 11ari.-dbili. Una immagazuv~bile è una locazione (posjzione) della memoria in cui un valore può essere che le specifica ione dichiaraz ,Questa na:ro perché possa essere utilizzato da un programma. variabili queste cbe significa Ciò int. variabili integer l, integer2 e sum sono di cipo conrcrranno dei va.lari interi, ovverosfa, dei numeri. inte.ri come 7, - 11, O, 31914 e simili. Tutce le variabili devono essere dichiarare con un nome e un tipo di dam, i.mmed.iatamence dopo la parentesi graffa aperta che inizia il corpo del ma in, prima d1c possano essere urilizzate in w1 programma. In C. ci sono altri tipi di dato oltre a int. In una dichiarazione possono essere dichiarate molte variabili dello stesso tipo. Avremmo poruco scriveré tre dichiarazioni, una per ogni varfabile, ma la fo rma ~ta prec::edentemence è pìù concisa. ~ Buona abìmdine 2.6
C
25
Buono abitudine 2.7 Scegliere nomi signifiC11.ri11i di variabile n.iute:rlr n rendere ilprogmmma auto esplicativo. ill altre paro/è. sara1mo 1tecellrzri meno commenti. Bi~ona
abiNtdine 2.8
ln prima lettera di un identificatore usato e
Buona abitudine 2.9 I nomi di vario~ile fonnati da più parok possono aiutare a rendere il programma più leggili.ile. Evitate di tombinm·e le di11er.se pctroLe r.ome in totalcom mi$Sion s. Sepnmtele piuttosto con carntteri di sottolineatum, come in total_ commiss ions o, se 11olt re legarle insieme, cominciate ogni parola dapo la prima con una Lettera maiuscol'l, COlnl! in totalCom missions . Le dichiarazioni devono essere sisremace dopo la paremesi graffa aperta di una fum.ione e prima di ogni ìstruiione esç!guibile. Per esempio, nel programma _della f.igura 2.5 , l'inserimento della dichiarazione dopo la prima printf avrebbe causato un errore di sin.cassi. Un errore di sint.'lssi è causato quando il compilat0re non è in grado di riconoscere una iStrll'"1.ione. Il cornpilarore normalmence emene un messaggio di errore per aiurare il programmamre a loeàlizzare e correggere l'istruzione errata. Gli errori di sincas$i sono violazioni delle regole del linguaggio. Essi sono anche chiamati errori di cqmpilazione, (} 1 -
errori a tempo di compilazione. Errore tipico 2.5 Sistemare le dichiarazioni di 11arit:zbile tra le istrt1Pioni eseguibili. Buona abitudine 2.10
1
~
Mettete uno spazio dapo ogni virgola(, ) per rendere il programma più leggibile. On nome di variabile in C è qualsiasi id.emi.fictltori valido. Un ide.uti:fìcacor~ è una serie di caratteri, comprendente lettere, numeri e caratteri di sòrtoli.Jiearura LJ, che non comincia çon un numero. Un idenPfìcacore può avere qualsiasi lungh1=zza, ma soltanto i primi 31 l dell'ANS IC. c;ua:tterid~0no CS$~{e riconosciuti dal ço.mpilaro re C, i.o accordo tou loscandar< in C, dlfferénci sono ninuscole 1 Il e e case sensitive, ovvero, le letrere Jna.iuscole e quelle perciò a 1 e A 1 sono idencificarori discinti. Errore tipico 2.4
Us.are una lettera maiusco/11 laddope ne dovrebbe essere utilizzata una est:fnpio, sr.riuent;/Q Màin in.v.eu·e di ma in).
INTRODUZIONE ALl.1\ PROGRAMMAZI ONE. IN
mimtsc~la
(per
Obiettivo portabilità 2.1 Wate identificatori di non più di 31 caratteri. Ciò aiuterà ad assicurare I.ti portabillttt epotrà evit{Jre alcuni subdoli errori di programmazione.
Separa.te le dk.hiarazi.oni e le i.stmzioni eseguibili dJ una fimzùmc crm una riga vuotn, per enfatizzare il ptmto in cui finiscono le dichiarazioni e i11cominciano I.e irtmzioni eseguibili.. L'isrruzione printf( "Enter fi rst integer \n " )i visualizza il letterale Enter f irst intèger sullo schermo e si po~ iziona all'inizio della riga successiva. Quesco messaggio è derro prompr perché chiede all'i:icence di e.$eguire una azione specifica. L'iscruzìone
scanf(" \d", &intege r1); urllizz.a scanf per ottenere un valore dall'ucenre. 1..a funzione scanf prende i dati in ingresso dallo srandat:d input che è di solito la rasriera. Questa scanf ba due aigomenci: '%d " e &int eger1 . li primo argom.enro, la st11ingadicm:1trollodeljòrmato, indica ,il tipo di dato che dovrà essere immesso dall'Uience. La rpecific.a di conversione \d indica che il dato dovrà
26
C1\:l'ffOLO
2
essere un incero (la lettera d sca per "inrero decimale"). Il %, in questo con.resto, è consideraro dalla funzione scanf (e come vedremo anche da printf) alla stessa srregua di un carattere di C!Scape {come \) e la cornbi.naz.ione %d è una sequenza di escape (come \ n). li secondo argomemo della scanf incomin'i'ia con una E commerciale ( &), detta in C opertttore di indirizzo, seguita dal nome della. variabile. La E com merciaie (o ampersand), quando è combi.nara con il nome deU~ variabile.., indica alla scanf la locazi~t(e di memoria in cui è irnmagazzinani. la variabile i nteger1 . Il cbmputer quindi immagazzinerà il valore della variabile integer1 in quella locaiioo.e, I:uso di ampersand (&) confonde spesso i programmarmi principianri o queUi che hanno già programmato in alrri linguaggi cbe non richiedono quesca nocazione. Per ora, ricordare solcanro di far precedere ogni variabile da un arnpersand in rurre le isrruzioni scanf . Alcune eccezioni a questa regola: saranno discusse nel Capicolo 6 e nel Capirolo 7. li reale significato dell'uso di ampersand diventerà chiaro dopo che avremo srudiato i puntatori nd Capitolo 7. Nel momento in cui il computer eseguirà la precedente scanf, arrenderà che l'urente abbia immess9 llI! valore per la variabile integer1 . LLLCente risponderà digirando un incero e premendo il tasto retum (a volte dea;o t(!sto enter o tasto di invio), per inviare il numero al computer. Quesco assegnerà allora U suddecro nwnero, o w;lore; alla variabile integer1 . Ogni sucèessìvo riferimcnm a integer1 nel programma userà Tale valore. Le funzioni printf e scanf facilitano l'inrerazione tra l'ucente e il compmer. Daro che quesca incerazione somiglia a un dialogo, è spesso chiamata elaborazione interattiva. Cistruzione
visualizza il m~o Enter second i ntegér sullo schermo e quindi posiiiona il cursore all'inizio della rig.i.~successiva. Anche questa' printf chiede all'uceme di eseguire una azione. I.:istnt.:z,iqne
L'istruzione printf( "Sum i s %d\n " , sum); usa la funzione printf per visualizzare suUo schermo il len:erale Sum is seguito dal valore numerico della variabile sum. Quesca printf ha due argemenci, ' Sum is l\id\n" e sum. IJ primo argomento è la ~rringa di conrrollo del formato. Quesca contiene alcuni caratreri JerreraH che dovranno essere visualizzati e la specifica di conversione l\sd indicante che sarà visualizzato un intero. U secondo ti.rg0 menco spedfìèa il valore da visualizzare. Osservare che la specifica di conversione per un incero è la stessa sia in printf, sja in scanf. Questo accade per la maggior parte dei cipi di daco in C.
I calcoli possoo.o anche essere eseguiti all'inreroo della istruzione print f . Avremmo potuto combinare le due precedenci istruzioni in
printf("Sum is %d \ n " 1 integer1
+
integer2);
I.:isrruzione
r eturn 0; resc:ici,1isce il valore 0 all'ambiente del sistema operadvò in cui il programma è stato eseguito. Questo indica al sistema operativo che il programma è stato eseguito con succ~sso. Consulcace i manuali del vostro specifico sistema operativo, per ottenere informazioni su come comunicare un parti9>lare ripa di falljmento del programma.
ottiene dall'urente un valore per. la variabile integer2. I.:istmzione di assegnamento I
+
Errore tipico 2. 7 Dimenticare una:0 entrambe /,e virgolette che circondano la stringa di contro//,o delfirmuttQ i"n una printf o in una scanf. Errore tipico 2. 8
scanf('%d", &lnteger2);
= integer1
27
La parentesi graflà chiusa. }, indica che è stata raggiunta la fine della funzione main.
printf( "Enter second integer\n ")i
sum
I NTRODUZIONE ALlA l'ROGRAMMAZlONElN C
integer2;
calcola la somma.delle variabili i nt egér1 e integer2 e assegna il risulcaro alla variabile sum, usando l'operatore di assegnamento= . .Listruzione è lea:a come "sum prende il valore di i nteger1 + integer2". La maggior pane dei calcoli sono eseguici ncUc istruzioni di assegnamento. I.:operamre = e quello+ sono chiamari '<1p.erat01i binari percbé ognuno di qu.esti ha due operandi. Nel caso, dell'operatore +, i due operandi sono i nteger1 e in1;eger2. Nd e::aso dell'operqtore =, i due oper3l1di sono sum e il valore deJJa espressione integer1 + integer2.
Buona abitudine 2.11
Dimenticare il % in una specifico di conversionr nello_ minga di controllo del formato di una printf o tli uno scanf. Errore tipico 2.9 Inserire untt sequenza. di escape come l n all'estemo della sttinga di controllo de.I.formato di una printf o di uha scanf. En·ore tipico 2.1 O Dimenticare di includere le espmsioni di cui dovranno mere visualizzati i valori, in una p rin tf contenente delu• specifiche di conversione. Errore tipico 2.11
Inserite degli spazi su entrambi i "1ti di un operatore binario. Questo mette in risalto /'operatore e rende più leggibile il programmo.
Non fornire, nella stringa di controllo del formato di una printf, una specifica di converrione, qualora sia neces;aria per visualizuire una espre;sione.
Errore tipico 2. 6 Ert·ore tipico 2.12 Il calco/,o egnamento.
Inserire, a/L'interno della stringa di controllo delformato, la virgola che dovrebbe separare la stessa dalla eiprcssione da visualizzare.
28
C1\J>!TOLO
2
Errore tipico 2.13 inteper1
Dimenticare, in una irtruzione scanf, di far precedere da un ampersand una variabile, quando quma dovrebbe, di fotto, esserepreceduia da un ampersand. Su molti sistemi, questo errore rilevaco nella.fase~ecuàvaè deuo "errore di scgmencaz.ione" o "violazione di accesso". Un simile errore occorre, quando il programma di w1 utente cenca cli accedere a una parte della memoria del computer per cui il p rogramma Stésso non ha clirirti cli accesso. La causa precisa di quesrn errore sarà spiegata nel Capitolo 7.
li
Errore tipico 2.14 Far precedere da un ampersrtnd. in una istn1zwne printf, uno vmù1hìle quando, di fotto, questa non dovrebbe essere pr.ecedttta d<.1. tm ampersand.
Nd Capitolo 7, srudieremo i pumamri e-vedremo dei ca.si ill cu:i VO(remo far precedere da w1 a,mpersand un nome di variabile, per visualizzare l'indirizzo della scessa. Per molti dei prossimi capitoli, rurtavia, le istruzioni printf non includeranno tale uso dell 'ampersa.nd.
2.4
29
lNIRODUZIONEALLA PROGRAMMAZIOl'JE IN C
integer2 Figura 2.7
8 8
le locazioni di memoria, dopo che entrambe le variabili sono state ricevute in input.
che esegue !'addii.ione, comporta anch'essa una scrimira disucmiva. Ciò accadrà quando la soÌ111Il3. ca1co1:u:a da integer1 + integer2 sarà siscem:ara nella locazione sum (dism1ggendo il -valore èhe poreva essere già contenuro io sum). Dopo che sum sarà stata calcolata, la memoria apparirà come nella Figura 2.8. Osservate che i valori di integer1 e integer2 appaiono ~menre com'erano prima di essere urilizzaci nel calcql<;> di sum. Questi valori sono ~tari rrriliz.za.ti, ma non dimurci, quando il computer ha esegu.irn il calcolo. Di <::o1l5egue117..a, quando un valore è lerro da una locazione di memoria, r:a.le processo è detto lettura non distrur.tiva.
Nozioni sulla memoria
i ntepe r1
45
i nteger2
72
sum
117
I nomi cli variabile come intege r1 , intege r2 e sum corrispondono in.realtà a locazioni (o posizioni) nella memoria del còmpurer. Ogni ~bilé ha un ffome, un tipo e un va/ore. Ncl programma per la somma della Figura-2.5, quando sarà eseguita l'iscruz.ione Fig ura 2.8
scanf( "%d", &integer1);
il valore digitato dall' utenre saràimmesso nclla._posizione dimemoria alla quale ilnome in t ege r1 è stato assegnato. Supponere che l'uccnte i.mmerra comev-alore per integer1 il numero 45. Jl çompurer sisremc:rà il 45 nella locazione integer1 , come mosrrato dalla Figura 2.6.
int~11er1 Figura 2.6
8
Una locazione di memoria che mostra i1nomee il valore di una variabile.
Ogniqualvolta un valore è si.~remaro in una posi1johe di memoria, esso si sostirujsce a1 valore comenuco in precedenza in quella locazione. Dam che quesca informazione precedenre sarà discruna, il processo di scrittu(-a in una l0cazi9ne di memoria è detto scrittura distmfitiva. Supponete che l'urente immerta il valore 72 quando l.'isrruzione scanf( ~%d " ,
&integer2);
è eseguica. Quesro valore sarà siStemato neUa locazione integer2 e la memoria apparirà come nella Figura 2.7. Osservare che quesre po!!izioni non saranno necessariameme adiacenti ill memoria.
Una volca che il programma avrà orrenuro i valori per integer1 e integer2, esso li sommerà e sistemerà il risulcaco nella vari.abile sum. I.:isuu.zione sum = integer1 + integer2;
Le locazioni di memoria dopo un calcolo.
2 .5 L 'aritmetica del C
e
e
la maggior parte dei programmi esegue dci calcoli. Gli operd.tn~ • , come in a * b. Ope razioni in C
Operator e a rit m e tico
Espressione a lgebrica
Espressione C
Addizione
+
h7
f
p -c
p . e b
* m
X
I y
Sorrraz.ione Molciplicazione
*
bm
Divisione
I
x/y o
MGdulo
%
+ 7
X
Fig ura 2.9
..
Gli operatori aritmetici del C.
y
r mod s
o x+y
r %s
30
CAPITOLO 2
GLi operatori aritmecici sono rurri operarori b.inari. Per esempio, l'espressione 3 + 7 c.onciene l'opeJatore binario + e gli operandi 3 e 7 .
La divisiom tra interi resciru:isce un risulcato incero. Per esempio, l'espressione 7 I 4 sar_à :valutata 1, menrre il valore di 17 I 5 sarà 3. lJ C fornisce l'operatore modulo, lii, che r~tiruisce il resto cli una divisione rra inceri. Questo è un operatore incero che porrà essere ut.i.Uzza.to soltancd ton operandi.-ìrueci. L:espressione x lii y resr:iruità il resco della divisione aa x e y. Di conseguenza, 7 lls 4 restitui.rà 3 , mencre 17 lls 5 produrrà 2 . Discuteremo melre interessami applicazioni dell'operarore .modulo.
lNTRODUZIONEAllA PROGRAMMAZ.IONEJN C
Le regole di priorità degli operat01i soné direrrive che consentono al e cl.i valutare le espressioni neU'orcline corretto. Nd momento in cui affermiamo che la valutazione procede da sinistra a desrra, ci sciamo riferendo all' associati.vìtà degli operatori. Vedremo che alcuni operatori associano da destra a sinistra. LaEigura 2.10 riassume le suddette regole di priorità degli operatori. Operatore/i Operazione/ i Ordine di valutazione (priorità) Parentesi
( )
Sono valucate per prime. Nel caso che le parenresi siano nidificare, saranno valutare per prime le espressioni nel la coppia più interna. Nel caso che ci siano più coppie di parencesi "allo stesso livello" (ovve~osia non nidificate), queste saranno valur.arç da sinistra a. destra. Sono valutare per seconde. Nel caso che ce ne siano moire, saranno vaJmare da sinisrra a destra.
Errore tipico 2.15 Un teritàtivo di divisione per zero è di solito indefinito in un computer e·generaimente causa un errbre fatale, vale a dire, uno di quelli che provqcano la terminazione immediata del programma, se!lZ'A che questo possa compktare con successo il proprio lavoro. Gli errori non fatali consrotoM ai programmi di continuarefino al wro compktamentb, producendo spesso però qei risultati non corretti, Le espressioni aritmetiche in C dovranno essere scritte su una riga per facilitare l'immissione dei programmi nel computer. Di conseguenza, espressioni come "a diviso b " dovranno essere scritte come a / b, così che rurri gli opcrarori e gli operancli appaiano su una stessa riga. La. noraz.iooe algebrica
*, I o
+
Molciplicari_ooe Divisione Modulo
9s
o.
Addizione Sottrazione
Sono vaJutate per ultime. Nel caso c::he ce ne siario molce, saranno valutate· da stnistra a desaa.
Figura 2.1 O Le priorità degli operatori aritmetici. Consideriamo ora diverse espressioni a.Ila luce deUè regole cli priorità degli operatori . Ogni esempi0 elenca una eSpressione algebrica e il suo equivalenre in C.
a b
non è generalmence accertabile dai compilatori, sebbene esistano alcuni pacchetti software sgecializzaci, che supportano una noraz.ione più naturale per le espressioni macemaciche c0mplesse. Le parentesi s,ono urilizzate oeile espressioni C in una maniera molto simile a quella ucil.izzata nelle espressioni algebriche. Per esempio, per molripli.Care a volre la quancicà b + e , scriveremo: a
31
*
(b
+
e)
;
Il e valuta l e espressioni a:rìaneciche in una sequenza precisa, dete.rm.ina1a dalle seguenti regole di priorità degli operatori, che sono generalmeme le scesse adottare in algebra:
l:esempio seguente cfilcola la media aritmetica di cinque termini: a+b+c+d+e
Algebra:
n1
C:
m = (a
s + b + e + d + e) I 5;
Le parentesi sono necessarie perché la divisione ha una priorità maggiore della addizione. Dovrà essere divisa per 5 l'intera quanric.à (a + b + e + d + e ). Nel caso le parentesi dovessero essere erroneamente omesse, ottérremmo a + b + e + d + e / 5 che sareb.be
valutata in modo scorretto come
e a+b+c+d+ -
5
l. Le espressioni o parti cli esse,
_per prime. Di conseguenza, le parentesi potranno essere utilizzate per forzare l'ordine di valutazione, in moda-che quesf.ultima si svolga nella sequenza deside,.ata dal programmatore. Le parentesi hanno il "massimo livello di priorità". N~ caso le parente.si siano nidificau saranno valurare per prime le espressioni della coppia più inrerna. 2. In seguico saranno valutare le operaz.ioni di molciplicaz.ione, clivisione e modulo. Nel caso che un'espressione contenga diverse operazioni di moltiplicaz.ione, clivisipne e modulo, la. va.lutazione procederà dasinistta a descra. La molripliCa!rione, la divisione e il modulo si crovano allo scesso livello di priorità. 3. In ultimo saranno valutare le operazioni di ad.di.i.ione e cli sottrazione. Nel caso che una espressione contenga diverse operazioni di ad.diz.ione e cli sottraz.iooe, la valutazione proce4erà da sWsa:a. a desua ..Ancbe l'addiz.ione e-14 sottra.ione.hànno lo stesso Iivello di priorità.
I.:esempio seguente è l'equaiione cli una linea retea: Algebra.:
y = rnx+b
C:
y = m* X+
bj
In quesro ~ non sono richieste delle parentesi. La moltiplicaz.ione sarà valutata per prima poiç:hé essa ha una priorità maggiore della addizione. !:esempio successivo contiene le operazioni di modulo (%), moltiplicaz.ione, divisione, addizione e soruazione: Algebra:
C: z
= p
2
= pr%q+w/x-y
* r lls q + w I x - y;
' CAPlTÒI:0.2
32
I nu)ne.r:i c~chia,ti sotto l':i.sr.ruzigne mdiean9 l;ordin:e ifl cui il C valuterà gli operarori. La mol4pl.k;1rione, il mo.dul0 e la diyi$.i'ofi!! saranno \7alutati per pnirni in ordine da·siuistra a tle.5tra (ov,v~òsìa a!\SOCÌl)..FIO da sinistra a deste~), po~t:hé.hantio una priorr~ .rnagg!o~~ della addjii_òllé é èfol[a so.ttrazione-. ln seguito sarruillo va!utàre fal!dizjone e ta sò~jçne. Anche queste ·savanno valmare da.sinisrra a desua.
Nò:n rurre le •es·pre~sioìii eòri· divers~ coppie di pare,nr<;sl ·eq11tengo!\.9 dçlle parentesi tridìfìc.a'te.
a
~
eesp r~sslone
(b •
e)
+ e
*
(d + e)
non eontiene patentesi nidificate. Diremo invece
che le parentesi sono "allo stesso· livello".
~ ql1~t~ s~ruazign i,. il ç valuterà per prime le espre.
da sin'i'sc:ra a deso:a, m<;>
Per sviluppare una miglior comprensionè delle regole di priorirà .d,egli opetamri, vediae:Qm.e il C valuta Wl polinomio di secondo gtado.
y:
a* X* X+ b
*X + ,Cj
CD@$®® J aumeci çerçbiati sorto l'isrru7-iene indlcano l'ordine in cill il C eseguirà le operazioni. Nqn ~iste n~sun opeFator.e adrmc;tic.9 in per 1'elevamenro a pòtènza, pereìò a.bbiamo tapprcsentiJ.to x2 tome X * X . • La libreria: st.andard del e include La funzione pow ("p$;lwér'", porehza) pe.r ~èguire 1'.ele.varnento a f>.0teiµ,a. A caus;i; .~ a!Guni .insidiosi pteolèmi correlati ai tipi di &cò .rithiesei da pow, rimandiamo la spiegazione derragiiara di pow fmo al Capitolo 4.
e
Sup,po.nete the-a = 2, b = 3, e = 7 e x il precedeme polinomi!) di s
= 5. La Figuni ·2.11 mosua come sar.à valUtaro
.JNrrRQlJU:llON l~ ALLA l'ROGR.
2.6
33
Prendere delle decisioni: gli operatori di uguaglianza e relazionali
Le isrruz.ioni ese~1ibili del. e e;:ompiono delle azioni (come dei calcoli o l'input e l'ourpm; dei d;rti), oppure prendono delle decisioni (vedremo eresrn malti esen'\pi di questo ripq). Jn· un programma; per e.?çrupiQ, pq~remm~ ptenqe:rç una decisione per d_c:;te·rmb:iawse il voto di .Ufia persona in un. esame è maggiore5siòol chiatnare per l'appumo atmdizioni. Nel cas.o in cui la: condizione sia sraua soddisfatta, oYVerosia nel caso in cui risulti vera, verrà ese:;guira i'istruzione pre~cr1te·all'ìmemo del eorpo della srnnrua i f. N el gaso in ç:ui la. ç;om;liziOD.~Jlon sia soddisfa rea. owerosia nel caso in cui cisùl ci falfil, ~ìsrruzio11.e prese);lr~ ;JJl' i qreot~ qel corpo nqn verrà e.seguita. Oopq il compler;µne_ µ.ro dcUa stmttui'~ ìf, i.ndipendemen)ente dal faqo che l'istnqjone del corpo sia cs~guiI;'!. o noi l'esèiuzjone procederà còn l'istruziòne succc:s.sicva alla srrmrura i f. Le c<:>ndiziqni nelle $trtttture 'Ì f sono formate usando gli vpè1·qJori di" ugr14glil!''n.Y4 e gli o-perawri n:ktzi.fin_ttli rip.s.s_unti n,clla F.igru:a2.12. Gli OJJe1'acori re4izìon~li h~fi.0 lo sc~so livello di priocicl.i: e ,assoti:mp da s.iriistr:a a dèStra. Gli òpératori d·i uguagliru:izà banno un. livello di pciorirà più basso degli 'Operatoci r.elazionali e associano da s.illisrm a destra. (Nora: in C, una éÒndìzi:bne può e-ssere .in realtà una espressiene che generi un valore. ugual« (fulso) o diverso (\tero) da ieEO. VedremG moke applicazioni dl eiò nd corso del libr9).
O peratori aJgebr ici di uguaglià.nia ò re lazi.o na li standa rd
Operatori di uguaglianza o Esempio di relaziona li in e condizio ne e
$4tà gentrato tjrt, -e:rron: di sintassi, se si s-epm·era?zno '"{{'1 degli spazi i tf.11.'e sirnbòii che· ~·omppngotfo pgi1uno .4.egli qperafjJ.ri --, I= , >= e <=.
Errore tipico 2.17
Figura ;2.11
Va!ut~ione 'dì
un polingmie di secondo grado.
SarlJ:gertf!ratç 1irz. envre di sintr;ts_si fl:' si ù:Jvertin;mw i.dite.simboli che com,pongarlQ ognurio degli operatori I=, >=e <=, rispettivamente in =I, =>e=<.
.
UPITOLO
34
2
35
l.Nrn.ODUZIONE Al.I.A PROGRAMMAZIONI:. IN C
~ Errorè· tipico 2.18
int n.uml , num2;
~
printf(.Enter two ìntegers, and I Will ~ell you \ n"); printt { "the relationships they satisfy: • ); / *legge due interi*/ scanf{"\d%d ' , &num1, &num2);
Confondere l'operatore di uguaglianza == con quello di assegnamento =.
Per evirare questa confusione, l'operatore di uguaglianza dovrebbe essere ferro 1mme "doppio uguale?1 mentre l'operarore di assegnamento dovrebbe essere letto come ''prende". Confondere questi operatori, come vedremo presce, non prnvocherà uecess.ariamente un errore di sintassi facilroenre riconoscibile, ma potrà causare degli errori logici molto subdoli.
~ Errore tipico 2. 19
~
ln.rerire un punto e virgo/,a subito dòpo La parentest destra della condizione, ùt una stmttura i f . I.:esempio
if
if (num1 I= num2) printf(" \ d is not equal to %d\n', num1, num2); if (n um1 < num2) prìntf(.%d is less than %d\n • , num 1 , num2);
i f (num1 > num2) pri n-tf( "%d is greater than %ò \n•, num 1 , num2); if (num1 <~ num2) printf ("\d is less than or equal to %d\n", num1 , num2) ; if ( nurn 1 >= num2) printf( 0 %d is greater than or equal tç num1, num2);
return 0;
\d\n~,
/1' i n.d ica che i l programma è terminato con successo • /
Buona abitudine 2 .12 Fare rientrare la/e istruzione/i nel corpo di una srruttura i f . Buona abitttdine 2. I3 ln.serire.yer I.a lef,gibilità, una riga vuota prima e dopo ogni n:rtttturll. di controllo ih un programm/J..
a fs
Buona abitudine 2.14
&nter t wo int elJers, and I will t ell ~eu
Non ti do1mbbe essere più di una istruzione per riga· ùi un programma.
the re l ationships tbey -satisfy: 22 1.2 ~ 1s not equal t~ 12
Errore tipico 2.20
Inserire delle virgol.e (qt1ando non sono richieste) tra le specifiche di convmione nella stringa di corztrolw del formato in una istruzione scanf. /* Usare le istruzioni if, gli operatori relazionali e quelli di ug uaglianza •t #include maìn() {
Ent er two i nte ger s, and ! will tell ye.u the relationships they s atlsf y : ·3 7 3 is not e~ua4. to 7, 3 l s less thén 7 les s tha o o r e qual t o 7
22 is greater than 12
22 is greater than or equal to 12 Enter two integers , ana I Will tell the relaflonslti~~ the~ s&tisTy : 7 7 7 i ·s equal to 1 7 is le~s tnan o r equal to 7 7 ~ greater than or equal to 7
yo~
Figura 2.13 Usare gli operatori d i uguagliànza e relai:ronali.
CAPITOL02
36
11 commento nella figura 2.13 è spczzaro su due righe. Nei programmi C, i carartcrj
di spazio bianco come le tabulazioni, i newlinc e gli spazi, sono normaJmeme ignoraci. Di conseguenza, le istrui.ioni e i commenti potranno essere spezzari su più righe. Non è in ogni caso corretto spezzare gli idencifìcamri.
LvrRODUZJONE Al.LA l~J~OG RAMMl\7.ION~. IN
e
37
stessi da parre dell'urente, l'esecuzione di calcol i è le ìscruz.ioni decisiotiali. Nd prossimo capitolo, ci baseremo su quesrc tecniche mentre incrodurremo la programmazione rtrurturata. Lo studente diventerà più familiare con la tecnica ru applicare dei rientri al codice. Srurueremo come specificare l'ordine in c ui le isuuzioni saranno eseguire: il cosiddcuo
fl1tsso di controllo.
Buona abitudine 2.15
Una istruzione lunga potrlt e»ere distribuita su molte righe. Nel caso che una istmzione possa essere spezzotll su. più righe, scegliete dei pumi di interruzione che abbiano un senso (per esempio dopo urw vir,,'(o.fa in un elenco separato da virgole}. Nel caso che una istrnzione sia stattl spezzata su due o più righe, fate rientrare tutte quelle successive alla prima. L;i. tabella nella Figura 2. ] 4 mostra le priorità degli operatori in""rodorci in guesco capitolo. Gli ppcracori sono mostrnti dall'alto in. basso, in 9rdine decrescente di priorità. Osservare che anche il segno ru uguale è un op.eraro,i:e·: 1ùrti questi opera.cori, a eccezione di quello d i assegnamento =, associano da si.illsu:a. a deStra. J...:operatore di assego,:uncnto (=) associa da desr.ra a si nisrra.
Parole chiave auto const double float int short struct unsigned
break continue else fo r long signed switch void
case default enum goto register sizeof t ypedef vola1;ile
char do extern if return stati e union While
Figu_r a 2.15 Le parole chiave riservate del C.
Brtona abitudine 2.16 Ogni volta che scrivete delle espressioni contenenti molti operatori, fate riferimento alla relativa tabella de/le priorità. Assiettratec11i che gli operatori nella espressione siano eseguiti nell'ordine appropriato. ·N el caso non siate sicuri di tm ordine di valutazione in una espressione complessa, usate le parentesi per forzare l'ordine, esattamente come avreste fatto nelle espressioni algebriche. Assicuratevi di osservare che alcuni operatori del C, carne guello di assegnamento ( =) ,11ssoci11.no da destr11 a sinistra, invece che da sinistra a destra. Operatori
Associatività
()
da sinistra a desua
• <;
da sinistra
<= > >=
da sinis.mt a desrra da ,sinistra: a destra. da. si.nisçr:a a. desrra
I -=
=
l. l
di ogni funzione. c) Ogni isrruzione t~na con un ----~ della libreria standard visuafu.za le infocm:n:ioni sullo schermo. d) La funzione che muove: il cursore nella e) La sequeo2a d'escape \ n rappresenra il cmmere posizione ini7.ia.lc: dc:Ua riga successiva sullo schermo. della librerìa standard è utilizzara per leggere i dati dalla f) La funzione: r:iscic:ra. è. usara in 1rnastringa di con1rolio del formato di g) L.'l specifica di conversione una funzione scanf, per indicare che sar.ì immesso un incero, menrrc in uoa stringa di controllo del formato cU una funzione printf, per indicare che sarà visua.lizzaco LLD incero. h) Ogniqualvolta un nuovo valore sarà sis.remato in ~1na loc.1zionc di memoria, esso si sosri1uiri\ a.I va.lore conrenuro in preccdenz.1 in quella lueazione. Qucsco processo è noto come
da desa:a a sinistra
Quando un valore nrà lotAo da una locizione di mcm
Figura 2.14 Prio rità e associatività degli operateri discussi finora.
Alcune delle parole che abbiamo usato nei ptogrà:mmi C di quesro capitolo, in particolare i nt , retu rn e i f , sono keyword (parole chiave) ovverosia parole riservare del linguaggio. Linsjeme completo delle parole chiave dd C è mostrato nella Figura 2. 15. Quesce hanno un signifìcaro speciale per iJ compilamre C, perciò il progcammarore dovr3 srare auenro a non ucili.zzarle come idencifìcaroci, per esempio, nei nomi di variabile. In questo libro, discuteremo di cucre le parole chiave.
ln quesro capirolo, abbiamo introdotto moire caraner:isciche imporcanci dcl linguaggio di programmazione C, inclusa la visualizzai.ione dci daù sullo schermo, l'immissione degli
Riempite gli sp:izi in ognun:i delle seguenri rigne. a) Ogni programma C incomincia la propria esècuzione con la funzione - - - - reanina il corpo inizia il corpo di ogni funzionemenrre la b) La
a destra
I %
+
Esercizi di autovalutazione
2 .2
Srabilire quali delle seguenti affermazioni sono vere e quali fulse. Nel caso siano fà.lse, spiegarenc:
il morivo. a) Quando sarà invocata la funzione printf, questa comincerà a visuali=re sempre dall'inizio d1 una nuova riga. b) I commenci inducono ù computer a vUualizzare sullo sc~ermo il cesro racchiuso era/ • e • / dw·anre l'esecuzione del programma. e) La sequenza di escape \ n, quando è usaca in una stringa di controllo dcl formaro di una funzione printf, mduce il cUISorc a posizionarsi all'inizio della riga successiva sullo schermo.
38
CAJ."JTOLO
2
d) Turce le variabiLi devono essere dichiarare prima di essere utilizzare. e) A curce le variabili dovrà esscre~segnaco un tipo, quando saranno dichiarate. f) 11 C considera identiche le variabili number e NuMbér. g) Le dichiarazioni possono a~parire in quals.iasi parre dd corpo di una funzione. h) Tutti gli argomenti successivi alla srringa di cencroUo dcl formaro in una funzione printf devono essere preceduti da un ampe.rsand ( &) • i) I:operacorc modulo (l\s) può esse.re urilizz.am solramo con degli operandi interi. j) Gli opera cori aricmetici • , / , \ , + e - hanno runi lo S(esso livdlo di priorità. k) Vero o falso: i seguenri nomi di variabili sonoidencici in curci i sistemi ANSJ C.
INTRODUZIONE /\Ll..J\ PROGRAMMAZ!ONE IN
2.3
2. 1
a) main. b) pare?tesi graffii aperu ( {) . e) parentesi graffa chiusa (}) . c) punto e virgola. d) printf. e) ncwlrne. f) scanf. g) \d. h) scrirrura disrrurciva. i) Jetrura non distruttiva. j) if.
2.2
a) Falso. La funzione princf incomincerà sempre a visualizzare laddove sarà staro siscem:no U cursore, e quesro potrà essere ovunque su una riga.dello schermo. b) fulso. 1 commenù non causano l'esecuzione di nessuna azione durante l'esecuzione del programma. Essi sono usaci per documeocare i programmi e migliorare la loro leggibilità. e) Vero. d) Vero. e) Vero. f) Falso. ue disàngue fra maiuscole e mlnusoolè, perciò queste variabili sonc> diverse. g) Falso. le dicbiarazioni dovrann·o apparÌie dopo la pa.rC.ntesi graffa aperta del corpo di una funzione e prima di ogni istruzione eseguibile. h) Falso. Gli argomenci in una funzione printf clinoJ ìl2 non dev.ono e$sere preceduti da un ampersand. Gli argomend successivi alla stringa p~ controllo del formaro di una funzione scanf dovranno essere preceduti d1 norma da llia ;.mpersand. Discureremo delle eccezioni nei Capi coll 6 e 7. i) Vero. j) Falso. Gli operacori " , I e \ hanno lo stesso livello di priorirà, menr:re gli operarori +e - sono a un livello di priorità più basso. k) Falso. Alcuni siscemi possono disringuere degli ide.nti:ficatori con plù di 3 J caratteri. I) Falso. Una istruzione printf con moire sequenze di escape \ n può visuaLiz.zare canee righe.
2.4
Vero o fulso: un programma C che visualizzi tre righe di output dovrà, concenerc ue istruzioni printf.
Scrivete una singola istmzione C per eseguite 9gmmo dei $eguenti compid: a) Dichiarate le variabili e, thisVariable, q'78354 e number di ci po int. b) Richiedete aU'ucence di immettere unlntero. Terminatell vosr.romessagglo di richiesra c-0n un due punri ( : ) seguito da uno spaziQ e lasciate il cursore posizionato dopo lo spa:iio. e) Leggere in input un .intero dalla tastiera e immagazzinare il valore immesso nella variabile intera a. d) Se La variabile number non è uguale a 7, vistµlizzare ' The variable number is not equa! to 1• . e) Visualizzare il messaggio "This is a e program. •su una riga. f) Visualizzare il messaggio "This is a e program. •su due righe, dove la prima termina eon e . g) Visualiwue il messaggio "ìhis is a C program . • con ogni parola su una riga separata. h) Visualizzare il messaggio "This is a e program . • con ogni parola separata da una tabulazione. Scrivere una iscruzione (o un commemo) 11et esèguire ognuno dei seguenti compiti: a) Indicate che un programrha cakolei:à il prodòrro cli rre inreri. b) Dichjame le variabili x, y, z e result di àpo int. c) Richiedece all'utente di immeu:ere ue-interi. d) Leggere in input cre iarerl dalla mciera..c immagazzinaceli nelle variabili x, y e z. e) Calcòlate il prodocro dei ae inceri ct>ntenuti nelle variabili x, y e z, e assegnare il risulcaro alla YariabiJe resul t . f) Visualizzare "The product is • seguitò d;il valore dèlla variahllc re sul t .
.2.3
int e, thisVariable, q76354, number; printf("Enter an integer: "); scanf ( .,\d", ·&a ); if (number I= 7) printf('The varia.ble number is not equa! t.o. 7. \n•); e) printt ( ' This is a C program. \n •) ; f) printf( ' This is a C\nprogram.\n ' ); ~ printf (' This \nis\ na \ nC \ nprogram.\n "); h) printf( "This\tis\ta\tC\tprogram . \n•);
2.4
a) b) e) d) e) f)
2.5
a) /."' Calcola i l prodotto di tre interi #inélude
2.5
Usando le iscruzioni che ave ce sericeo aell'Escrdzio 2 .4, ·scrivete un programma complem che calcoli il prodocro di ere inceri.
2.6
ldentifìcacc e correggere gli errori in ognuna delle seguenti istnttioni: a) Pl"'intt ( "The value is '!\id\ n•, &number ); b) scanf ( "\d\d •, &number1 , number2 l; d)
i f (C < 7);
printf("C is less than 7\n•); d) i.f (e => 7) printf( ·e is equa! to or less than 7\n");
I* Calcola i l prodotto di tre interi ~ 1 i nt x, y, z, result; printf ( ''Enter t hree integers: ") j f soanf ( "%d%d%d" , &x, &y, &z) ; tesult = x * y • z; printf("The product is %d\n", result) ;
ma.in() {
int x, y, z, result; printf('Enter three integers: '); scanf( '\d%d\d', &x, &y, &z); result = x • y • z;
*/
CAPrro1.o 2
40
rNTRODUZIONE f\IlJ\ PROGRAMMAZIONE IN e
d) Una espressione aricmecica in C valida, cbe non comicne parenresi, sarà valurata da sinistra a cl~stra. e) Quelli che scgitono sono e.uni nomi di vari:tbilc noh validi1 ~g, 87, 67h2, h22, 2h.
prlntf( "ìhe prodl.lct is \d\n•, result); return 0;
2.6
Errore: &number. Correi.ione: eliminare il carattere &. Più mrdi nel tesco discuteremo deUe eccezioni a quesca regola. b) Errore; number2 non ha un ampcrsand. Corre-tione: number2 deve essere &number2. Più avanti nel libro diseiueremo delle eccezioni a quesm regola. c) Errore: il pumo e yirgola dopo la parcncesi dcsrra della condizione dcll'iscruzione i t .
a)
Correzione: ri muovere il punro e virgola dopo la parentesi destra. Nota: il risultato di questo er.rorc sarà che l' istruzione pr±ntf sarà esegrril'l) ind.ipc!lldentcrnemc dal fatro che la condizione della istruzione 1 f sia>'cra o no. Il punrcl e virgola dopo la parentesi destra sarà consideraco alla scessa stregua di una isa:uzione vuoca: una isrru1.ione che non fa n.ience. d) Errore: l'operatore relazionale=>:, dovrà essere cambiaro in>=.
2.11
2 .12 Che cosa sarà visualizzare (se lo sarà), quando ognuna delle seguenti.istruzioni C-verrà esegui ca? Nel caso in cui non venga visualiu-A1co nien.ce, rispandete "niente". Assum~~ che x ~ 2 e y " 3. a) printt('\d '', x); b} prìntf( ' \d", x + x); e) pr.i,rrtf ( •qc= .. ) ; q) pritJtf ( «X=%d11 1 X) j e) printf(u%d =%d .. , x + y, y + x); Z =X + y; g) scairf( «%d%d», &x, &y) ; h) /W printf(«X + Y = %cJ», X+ y); T/ i) prirrtf( «\O»);
fdencifìcarc e correggere gli errori in ognuna delle seguc.-nri istmzioni (Nora: pouebbe esserci 2.7 più cli un errore per iscru7.ione):
f) g)
scanf("d", value); printf( "ìhe product of %d and %d is '.\ld''\ n, x, y); firstNumbe r + secondNumber = sumOfNumbers i f (number => largest) laq:_iest = number; "I Program to de:termine :the largest of three intégers / • Scanf(.%d" , aninteger) ; printf( "Remainder of l\sd divided by %d is\n", x, y, x % y);
Ji)
if
i)
printf(\d is equal to %d\n'', x, y); print ( "The sum is l\sd \n, • x + y) ; Pri ntf('The vaiue you entered is : %d\n, &value);
b) e) d)
e)
j) 2.8
2.9
(X:
y);
Riempite gli spai.i in ognun:i'deile seguenci dghe: sono uciliz.zari per documç.ntare un programma e migliorarne la leggibilità. a) l per visu;tlizzarele informazioni sullo schérmo è _ _ _ __ utilizz
2.1 O S"Ci.bilfre quale delle seguenti alfo:mazi
e)'1 I.: i ~i.one printf( "a
= 5;. ~ ) i è un lipic;o esempio di istruzione di assegnamento.
Riempite gli spa1j bianchi in ognuna delle segucnci righe: a) Quali operazioni aricnmiche hanno lo sccsso livello di priorit11 della molùplica1.ionc? b) Quando le parentesi sono nidificate, quale gruppo di paremesl sarà valutalo per primo in . una espressione arirmeci~ e) Una l9c:uione della memoria di un computer che può conrcnere valori diffcrenci, in vari momenti della esecuzione di wi programma. è rrna - -- - -
Esercizi ~)
41
n
2. 13
Quale delle seguenri istrniioni C, se ce n'è una, contiene delle variabili coinvolte in Ltna lemmi
d.isrrutciv:'I?
a) scanf("%d\d%d%d%d•, &b, &e , &d, &e , &f); b) p = i + J + k + 7; ·e) printf(''De structJ.ve read·in "); d) printT("a = 5');
2. 14 Oarn l'equazione y = per qu·esca equazione?
a.~
+ 7, quale delle seguemi isrruzion i C, se-ce n'è una. è quella c:orrerta
a) y = a • X * l( • X + 7; b) y = a~ X .. X • (X + 7) j c) y = (a " x) ./,. X (x + 7); d) y = (a • x) .. X • X + 7; e) y = a " (X * X,. X) +7; f) y=a .. x• (X • )( + 7);
.
2. l 5 lnJicate l'ordine cl.i valutazione degli operarori, in ognuna delle segucmi isau7jonj C, e mostme.il valore di x dopo che.ogni iscruzioue sarà stara cscguica. ~
2.16 Scrivete un progrnmma che chieda all'urente dj immerrere due nur,ned, ottenga i n.unwri dru.l'ureme e visualizzi la loro somma. prodorw, differenza, quozienre e niòduJo. 2.17 Scrivere un programma che vi.sualizi.i i numeri da I a 4 sulla stessa_riga. Scri~ce il programma utilizzando i seguenti mctòdi:
42
CA.PrroLO 2
lNTROD UZlONE ALLA PROGRA'MMAZfONE l:N
a) Usando una jscrui.ione pri ntf .senza specifiche dj conversione. b) tJsando una isuuzione printf con quaccro specifiche di conversione. c) Usand_o quarr;ro istruzioni printf.
A p p p
J
JJ J J J JJJJJJJ
tdJUhi) D O
rniJQt three differen t integers : 13 27 14 SLln is 64
D D D I> mllO
A'Vèrage iw i.e Product .i8 4914
Slllallest :ts 13 'Laf&est fs:Zl
2.20 Sc.civete un programma cne legga il raggio di un cerchio e visualizzi il diametro, la circonferenza e l'area dello stesso. Usare il valore rostame 3,14159 per pi. Eseguite ognuno di questi calcoli all'interno della/e isrruzione/i printf e usare la specifica di conversione%f. (Nora: in quesco ca_picolo abbiamo a:atcato solranto oosronti e variabili ince,re. Nel Capitolo 3 discuteremo i numeri in virgola mobile, ovverosia quei valori che possono.cootcneye dei decimali.). 2.21 Scrivete un programma che visualìtti una scacola, un qvale, una freccia e un diamance come i segucnri
*
• ,,* •
* ,.* *
•
•,. .,
il'
llfllt
2.22
il'i•·-·
• ..
• •
*
•
•
...
~
* •
• ~
!/t
·*
......,.. ...
"'
I
*
• *
2.27 Visualizzate il disegno di una scacchkra utilizzando ono istruzion i pri ntf e quindis c:unpare lo stesso disegno, con il m'inor nu.merq possibile d'isrruz.ioni pri ntf.
**• * • •
.. .. ,.,., .
• • ••
•
1*
•
"* • • • • • • •
"* * ... ...
Che cosa visualiz.zecl il codice seguente? prlntf( 01 \n**\n•~ · \n• •~ \n* ••••\n•);
2.23 Scrivere un progt-amma che legga cinqué inceri e quindi determin i e visualizzi quclli che, all'interno dd gruppo, sono il maggiore eiJ minore. Usare soltanto le tecniche di programmai.ione che ave.te appreso in quesco èllpirolo. 2.24 Scrivere un programma che legga un incero e dececmilli e visualizz i ~e sia pan o dispan. (SuJ;gerimChto: usare l'opèrarore modulo. Un numero pari è un multiplo cli J:l ue. Ogni multiplo di due dà un resto u~ale a zero, quando è dlviso per 2.) 2 .25 Visualizzate le vo~.tre iniziali i1ummparef10 in direzione del fo n~o dellapagirui. Costruire ogni lene.ca in srampacello ucilizzandolo StC:SS'El caran:ere che essa rapprcsenra, come segue:
2.26 Scrivece un programma che legga due interi e determilli e visualizz i se il primo sia un multiplo del secondo. (S,uggccimenco: usace l'operato re modulo.).
•
•
*"'*
p p
Pi'
2.19 Scrivete un programma C che prenda in in pur dalla casòera tre diversi inceri e qujndi visualizzi la somma, la media, il prqdorro, il minore e il maggioi:e dj quesci numeri. Usare soltanto la form:i a selezione singola della isl'.CUzione if che-avete appreso in quesco capitolo . Lo schermo di dialogo dovrà apparire come il seg_ucnce:
••••il'••··
43
PPPPPPPPP
2.18 Scrivete un programma che chieda all'ucenre di imròem:ll due imeri, orcenga i numeri e visualizz i quello maggiore seguito daUe parole • is larger. •. Nd caso che j numeri siam> uguali, s~anipate il messagg io •rhese numbers are equal. •. Usare soltanco la forma a selezione: sing,ola della istruzione if che avere appreso in questo capitalo.
:
C
··~;~ • Il*
2.28
Discinguerc era i termini errore fatale ed errore non farale. Perché pouesce preferire di incorrere
ja un errore fatale, invece che in uno non facale?
2.29 Diamo ora una sbirciataJn avanti. f n quesco capirolo avere appreso degli imeri e del tipo int. Il può rapprese ntare ancheJe lertere maiuscole, quelle minuscc:>le e una considerevole varierà di simboli speciali. IJ usa incemamcnre degli interi di un hyre per rapprese ntare ogni singolo caracrere. Linsieme dci caratteri usati da un c_ompur~r e la <;c:>([ispondence rapprese acazjone incera per quei carartcd èJ'insieme dei caratteri di quel computer. Porrete visualiziare l'intero equivalente ddla lettern maiuscola A, per esempio, eseguendo l'immionc:
e
e
printf( •9gj•, 'A') ;
Scrivete un progrnmma ch.e -visualirn gli inceri equivalenti ad alcww lettere ml!iusco le, minuscole, numeri_e simboli spe'c.iali. Decerminare, come nlinimo. l'imero equivaleme_ di: A B C a b e 0 1 2 S " + I é del cararrere spai.io.
2.30 Scrivete un programma che prenda in in pur un numero di cinque cifre, lo spCZ1.etti nelle sue Singole cifre e le visualizzi ognuna separata dall'slrra da m: spazi. Per esempio , se l'utcme digira.sse 42339, il program ma dovrebbe; visualizzare 4
2
3
3
9
)
44
CAPITOLO
2
2.31 Usando solranto le tecniche che avere appreso in quesro c:apirolo. ~crivere un progr:imma che calcoli i quadraci e i cubi dci numeri da Oa IOe uc$ni le Eabul_azioni pervisual.iu:u:e 1::1 seguente rabclla ru valori:
nunero
quadrato
G!tlo
0 1
0
0 1
2
4
8
3
21
5 6
9 16 25 :Il
7
~
8 9
64 81 100
4
10
6'I 125
CAPITOLO
J
Lo sviluppo di programmi strutturati
"216
3113 bl2
Obiettivi
~
•
Comprendere le tecniche fondamentali per la risoluzione de.i pcoblemi.
100;0
Essere Ì11 grado di sviluppare algoritmi, utilizzando il processo rqp-dowo per raffinrunenci successivi.
ESsere io grado di ufiHzzare le stmmue d.i selezione ife i f I else, per selerioun.re le azioni.
•
Essere in grado di utilizzare la smurura di iterazione while, per eseguire ripetuta.mente delle i.struzioni, io un programma.
Comprendere i cicli concrollati da un contatore, o da un valore sentinelJa. Comprendere la programmazione scrum.a.rat.a. Essere in grado di ucilin.are gli opera roridi incremenco, di decremento e di
•
assegnamento.
/
3. 1
Introduzione
Prima d i secivere un programma che risolva un particolare problema, è essenziale avere una piena comprensione di qucsr'uhimo e un approccio pianificata con cura per risolverlo. I p rossimi due cap.iroli rrarrcranno delle rccniche che facilirano lo sviluppo di programmi si;rurturaà per computer. Nella Sezione 4.11, presence.remo un sotn.mario della program.JDazione srrutturara, che merrerà insjeme le tecnjche sviluppate in .quesro e ne.I Capirolo 4.
3.2
Gli algoritmi
La risoluzione di ogni problema di elaborazione c0mporta. l'esecuziorre, in un ordine spcuna serie di azioni. Una procedura che risolva un wablema in termini di
cific:o, di
l. azioni che devono essere eseguire e
2. l'ordine in cui rali azioni devono essere eseguire è derra algoritmo . .eesempio seguente dimoscra che è impoçra.nre specificare correrr.amenre l'ordine in cui le azioni devono essere esegillre.
Considerate l'algoritmo "al7.ari e briUa" adorrato da un giovane dirigeme per alzarsi dal lerco e andare a lavorare:
46
C APITOLO
3
Alzarsi. dal letto. Togliersi il pigjama. Fare una doccia. Vestirsi. Fàre colazione. Prendere l'auto per recarsi al lavoro. Questa procedura p.ona al lavoro il dirigente, ben preparato ~er prender~ delle decisioni critiche. Suppc,mete, ttmavia, che quegli stessi passi siano eseguit i· in un ordme Leggermente diverso: Alzarsi da! letto. Togliersiil pigiama. Vestirsi. Pare una doccia. Fare colai.ione. Prendere l'auro per recarsi al lavoro. In quesro caso, il nomo giovane dirigent~ gi~gerebbc ,al la~or~ con;ipl~tam~tc .inzuppato. 1n un programma per computer, la specificaz..Jonç deU erdlne m cude isr_ruz10111 ~evo no essere eseguite è chiamata controllo del programma. In questo e nd prosstmo cap1tolo, esam:ineéemo con.cura le poss·ibilità offerte dal per il controllo del programma.
e
3.3
Lo pseudocodice
Uno_pseudocodice è un linguaggio artificiale e inform ale, che aiuta i programmac?ri a sviluppare gli algorirmi, Lo pseuciocodice che presenciamo i.o. ~uesto contes~o è parucoLai:mente utile per 19 sviluppo di algocito~ che sai:n~o c.on.veru~ .m .pro~ ~mt .e si;rua:uraa. U~o pseuliiocodlce è un linguaggio si.mile ali'ttal.1ana dt rutti 1 gior~; e pranco e maneggevole, scbbç:ne non sia realmente un vero linguaggio di pro~ramrna:z.iorte. furcal rà, i pr-0grammi scritti ~ pscudocodice non possono essere esegui.ci sui comput~r. Essi, piucrosto, aiutano il prograaimacore a "riflettere" sul pr~gra mma, ~rima c.h~- provi _a scriverlo in un linguaggio di prngrammazione, éOme il C. Fornire mo mol_a ese~~·· rn questo capit):>lo, per mostrare come uno pseudòcodlce possa essere efficac emente urilizzaro flello sviluppo di programmi C Strutturati. Uno p.seudocodlce è composto semplicemence da cararteri •. p·erci~ ~ programm~tori pottanDO immercere in un compu ter i programmi in pseudocodice~ uri!iz:an~o contorcevo~ menre un edlcO'r di cesto. U computer pòtrà v.isualiz:iare o scampa re, a nch1e5ta, una cop!a aggiornata di un programma in pseudocodice. Questo, se prepa.r< tto c?n c~ra, po~ facilmente essere convertito in un corrispondente programma C. I.a moln casi, ruc.co CLÒ .sarà ottenu to ~osàruendo semplicemente le istruzioni in pseudoçodice con quelle equNalenn nd linguaggiò C. Uno pseudocodice consiste unicamente di istruzioni~ azione: oy.ve.co sia,. qµelle che sa: ranno eseguite, quando il programma sarà s~o ~rrv::rn~ ~~ psewiocodice al e e .sara srac9 eseguito in C. Le dichiaraziorµ non sono JStruz1on1 esegrnb1l1. Queste sonq messaggi per il compilarore. Per esempio, la dichiarazione i.nt i i
LOS\filUl'[IU 111 PROGRAMMI ~TRUTT1JRJ\Tf
47
indica. semplicemente il tipo di daw della variabile i, al. compilarore, e induce quesr'uJciml> aJ:iservarc uno sp~io in memoria per la suddet ta variabile. Quesca dichiarazione, dunque. non provocherà l'esecuzione di nessuna azione (come un iopuL, u-n ourpm, o LI.Il calcolo), quando il programma sarà eseguito. Alcuni programmatori scelgon o di elencare ogni variabile e di menzionare brevemente gl i scopi di ognuoa di quesre, all'iui~ io di un programma in pseudococUce. D'alrroode, uno pscudocodice è un aiuto inform ale allo sviluppo dei progr.untni.
3.4
Le strutture di controllo
Normalmente, le isuuzioni prescnri iu un programma sono eseguir e, un:a dopo l'alua, nclf'ordine in cui sono srare scrirte. Parleremo perciò di esecuzùme sequenzùl/e. Varie istruzioni del C. delle quali discur.eremo presto, consentono al progr:a.mmaro re di specificare che la successiva istrll7ione da eseguire possa essere diversa da quella ·efforrivameme susseguence nella sequenza. Quesro cipo di indicaz.ione è det{a tmrftrimento del controllo. Duram e gli anni '60, divenne evidcnce che l'urili27.o indiscriminat o dei trasferimenri di con crollo éraJa cau.sa prima di una gran quanàcà di difficoltà sperim entate nei gruppi_ per 10 sviluppo del sofrwa.re. Cindice deJl'accusafu puntato sulla ~truzio ne goto, d1e consen àva al programmatore dl specificare w1 rr;isferirneoco di comrollo verso una di lln v.astissimo raggio di possibili destinazioni all'interno di un programma. La nozione della cosiddetta programrnaz10ne strutturato divenne quasi un sinonjmo di ''elimi111 zzione dei goto". La ricerca di Hohm e J:u:opini (13ohm, C., and G. Jacopini, "Plow Diagrams. Turiog Machines, and Languages witb Only Two Formarion Ru.les," Commu nioatioru of the.ACM, Voi. 9, No. 5, May J 9Q6, pp. 336-371.) ha dimosrrato che i programmi possono essere scritti sem.a usa.re nemmeno una is.truzione goto. La ~fida dell 'epoca, pçr i prògrammamri, divenne qudla di cambiare il proprio stile in una "programmazione senza goto". Ma fu solo nel pieno dt;!gli anni '70 che Ltna gran quanti~à di progr:ai:nmacori comincio a prendere ser.iafueme io considerazione la programmazione srrunucata. l risulraci sono stad davvero imp(essi.onaoti, dato che i gi:_uppi di svifoppo (}ttenneco: tempi di produzione ridotti, punrualirà più frequente nd consegnare i sistemi, e una maggior freque. rua di compleramenri dei progetti software m.·j termini previsti dal budget. La d1i::1ve di questi ~Ltçtessi è sempJkememe il l'atto che, con lé tecniche scnmurare, i programmi prodot ti sono più ch:iari, facili da mettere a punco e modificare e, innanzi turro, con maggiori probab ilità di esse.re esenti da errorJ. U lavoro di B0hm e Jacopini ha climoscrato che cutti i programmi posson o essere sccirri in termin i di tre sole strutture di comrolfu: la stn1ttu rn di sequenza, la sm1ttu rtt di selezione, e la struttura di iterazione. La struttu ra di sequenza è implicita i.11 C. Sempr e che non gli si ordini diversameme, il computer esegue automaticamente le isrruzio ni dd C, una dop() l'altra, nell'o.rdin.e in cui sono sr-aresccitte. Il segmento illdiagramrna·difluss o (flowclmrt}' nella l?lgura 3.1 illusrra la srrumu:a di sequeni;i dd C.
Oo diàgr:unma di flusso è una rappresentazione grafica di uo algoria no o di una porzione cli guesco. I diagrammi di flusso sono disegnaò usando cerri simbol i con signilì~à speciali, come i re.mmgoli, i rombi, gli ovali t i cerchierli; quesri simbol i sono connessi tra loro da frecce chiamare linee di flusso. 1
I
~1
48
CAPITOLO 3
LOSV14UP.PO DI PROGRAMMI S'IRUlTURATI due differenci :12i0ni. La struttura swicth è detta sti'Uttµra se)eziona un·a tra v.a.cie d.i.ffeten-à µÌqoi.
di felezione?(~'l:lltip/a,
perché
li C forni.sce tre ripidi strutture di iterazione: il wh_ile (Sezione ~.7), iJ d(> / Whi le e il for (emrambi d:is_cussi nel Capit9l9 4).
aggiun_gl Il voto al totale totai = total + grade; 6ountèr ~ eountèr 1' '1 ;
aggiungi I al contatore
Figura ~. l
49
Il di~ramma di flus~o ~ella struttura di sequenza del C.
Allo stesso modo dello pseuCl0codice; seblkne qaes:ro sia piefecito da molti programmatori, i diagr.ammi di flusso sono uùli per sviluppare e rappresentare gli algoritmi. I diag_rammi di 'flusso n10scrano con chiarezza il modo in <::ui operano le sb:urrure ài conrrol~ 1111; in q~m resro li useremo sqlo per tale ·scQpo. Cònsiderare il ségmenro di diagramma di flusso per la structuca s€que.nzi.alé mos·rrato nella figur-a 3.1. Usì~mo il sfmbokJ .rattangp/.o, chiamato anche simbolo di aifo11e, per indicare o,gni ·ripo di artiv.ità che iotjuda uo.cralcolo o una ~peraz.ione di inpur/ourpm. Le linee di fl.µsso preseot:LneUa 1igll.CiJ. imijcano liordb;le in ~ui le aziçmi de:>v,i;anno esse[e esegµhe: in ptimo. ltu).go, g·rade pp:v:rà essere :J.ggiunro .oa tot al, ç: quindi 1 ~ovrà ess~rè; spmm.ato -a çou'nt~r. 11 <::i ~#rte di ave.r-è, in Q.na s.truttt.iia di ~e.quer;iza, P!nte azioill •q.qai;1.te ne V:ogli)mo. Come-vedremo p.!i.~(o, porranno e:ssère inserite niolre isrruzio.niiMequ~zaladHove
e
nè ·pèìssa ciseré~sìs'tèniata una.
NeJ dis~w.r;rre un..P.iagraj:nnf~ çli Auss~ cbèrapp.r~enri un alg!:'> riimo co1r_ipi~o, il primo a essete ucili:iz;uo sarìt il simbolo ovate cont.enenre la ~parola "Iriizi0";. melitl'e un srmb~IO ovai~, ~oncenenré.1a parola "Fine!' ,·saià l'ultimo simb.olo urilizzatb.. Nd dlsegnate sol.o una porzione ai un algoritmo, come nella Figura 3 .1, i sjmboli ovali saranno omessi, in favore ddfiuiJizzo di s·imbolicerchietto decti anche simbolidi connessione.
T1 simb0lò più imporrame dej ·diigramm,i .di flusso è forse il simbofp romb'Q, derro anche si.rilbo.lo di dè.cìsiinze, .indieanre che dovr,à èSSère.eseguica ima séelta..Disea.tèrèillo .dcl s.iri:.th.òlo romb0 nella prossima sezione.
TI Cfomi.Sté rre tipi di srrutnire di seléz.ion~. La stn.i'ttura ·d i selezione. i f (Seri9rie 3 .5}; nel Gàso 'Ghè una "data. condizione sia ver-a, eseguirà (selezionerà)' una· eerta a.Ziorie, m.èntre la ignòrera, nd c::aso che la còndizione sia falsa. La strutrura dj sel.ezione i f /.elsè (Sé:Zione 3.6) e5eguir.à una certa az.ione1 nel caso <::he ·u~
nel
:r_e' as,sun,r(! .da p.na ·~.ra, esprè.s:sJene.
La struttur"- i f è detra struttura·di selezione singola, perché seleziona o ignora una singola azio!le. La $trumir-a i f I else ·è 4etta str/t'tttl.rq di selezione i/.çppia, p.erch'é-s~eziona una di
Qu.ésto·ètutto.11 Chasolramo sem:srrurrure di conrroilo: la sequenza., ue tipi di.st;Iezion.e e altretranci di iterazione. Ogni programma C è fomUJ.to dalla c9mbinaz_ione di 9gnuo11 délle Sildderie srrua:rae- di controllo; uriliz1.are .in q,ua:.nrità. approp·ciaJ:e .al pcçigramma che lmplementa l'algoritmo. Vedremo che ogni strurtw'.a di conrtoll0, ç.Ome quella sequenziale della Figura :3..1, ba due sin1b0li cetcbiectq, uaò nel punto di enrr_ara. e Val.rro in quell0 di uscita-. Queste-mtUtlff·e ef/i i;ontr'o{ln can 1"Jl ingre{fQ. l t+'M uscita singoli sempll:fiduio la cosrmzione dd progt-Mnrni. L:·stro:ttute di cont:ròllo possòn:o essere arraétace Funa all'altra, colleg<111do il punfo di uscita di urta di.esse con"'qué.1.16.di entrara della successiva. Tutro çi9 è.moltt> simile. al modo in éui i l:5amb.ini lnnesrano i mattoncini delle costruzioni, p~ciò cltiamianio quesro modo di operare ttacatastttmento dellestruttu.re di çomrollo. L:npareremQ che c:'è solcamo 'Ul1 altro modo in cui l~ ~trurrure di coni:rqllo porranno essere ~~te: QVV'ecos:ia, un. merodçi c_h.ia.maro nidificazjqne .delle sttùtturé- di tgtrttoll.o. Di q:mseguenza., qualsiasi prégntmma Cl di q.ti'po.rremm0_à.y.er bisogno, potrà itsser.e ·cosuuito ucilii,zando solamente serre cipj di srrurruie ·di çontrbilo, .c::ombinate in due soli modi.
3.5
La struttura di selezione lf
Bna suutturn. di sdezit
Se il 11oto déllo studente è maggiore o uguale a 60 ViiualiZ2!1l '"Promosso" . ,deremi;na: se l;i.. condizione "vero dello srudente è m.àggiore o uguale a 60'" è vera o fal~a. Nd c;aso in cùi la c0ndizi-0rìè sia. vé.ra, sarà visuali'zzato ''Promosso" ed "eseguita"; l'tstruzione succeS-Siva, nell'online. indicato dallo pseudoeodice (riqirdace che_q.uesto non è un vero linguaggio di pi:ogp.mmazione). Nel. qiso in c;ui la condizione ~ia fab~, la vis·ual.izzàzione· sarà ignorat:a: e ~arà. eseguita ristruzio'qqutces~iva, nell'ordine i ndka'to c:lallo l'~udo-cod.i.ce. Osservat.e che h seeonda riga di questa struttul1!; di sdezione è cien.a;ara. Tale rienrro è opziònale, ma è a:j.rameiit~ ritccomandaro, poithé àiuta a dare cisako alla scrunura intcia.seqi dei programmi. Applicheremo con mol~ cura lé cò.nvenzioni dei r.ientri in rutto il libfQ. Il compilato-re C ignora i caratteri di spazio bianco, come gli spazi, le cabula,zion.i e l~ newliri.e utilizzate per i rientri e la spaziacura verricale.
Buona -abitudine 3.1
/!pp#care le conven.zi0.ni dei rierltii, in modo '~ 60) p~inif(~Promossa,n");
C,w1TOLO
50
3
Osservare che il codice C corrisponde sa:eria:rileuce allo pscu
~
B11on11 abitudine 3.2
Lo pseudocodice è spaso utilizmto per "riflett.ere" S1t 1111 progranm1a, durante la fasi' tli pr<>gettazione dello stesso. Il programma in pseudocodice sarà successivamente convertito in C.
Il diagramma di flusso della Figura 3.2 illusrra la struttura di sele~ione singola if. Queste contiene quello che è forse il simbolo più imporrante dei diagrammi di flusso: il si;nbo!o rombo, detto anche simbolb di ilccisfone, il quale indica d 1e dovrà essere effccruara una scelta. Il simbolo di decisione conriene una espressione, per esempio una condi:dollc, che può essere vera o falsa. li simbolo di decisione ha due li nee di flusso che emergono da.ilo stesso. Una indica la direzione da seguire quar:ido l'e.spressione all'interno del simbolo è vera; l'altra indica la dirC?.ione da segu ir~ quando l'espressione è fa lsa. Nel Capitolo 2, abbi.amo appreso che le dedsioni possono essere prese secondo delle condi11joni, che conrengòno operatori rela'lJionali o di uguaglianza. In realtlt, una $Celta porrà essere compiura bas;1Jldosi su qualsiasi esp~essione: se essa è vahu:ara zero, sarà cratcaca come falsa, memce ~e il suo valore è diverso da zero, sarà considerata vera. Osservate che anche if è una srrurmra con un ingresso e una uscica singoli. Apprenderemo presto che:: anche i diagrammi di Elusso per le rimanenti strurrure di concrollo contengono (a parre i cerch ierri e le lince di 1:1usso) solca.mo dei simboli rerraogolo, per indicare le azioni da eseguire, e dei simboli rombo, per indicare le decisioni da prendere. Questo è il modello cli programmazione basato su azioni e decisioni che abbiamo evidcnziaco.
lo SVlLUEPO 0 1l'ROGRANL.'vfl STRUTIURATI
51
3.6 La struttura di selezione lf/ Else La sa:urrura · di l'selezione · . .i f esegue l'aziolle indicata solo quando la cond··l.Zl·0 ne è vera,. ·111 caso conr_rano,. azione e ignorara. 1:-3 s~rrura di.s~lezione i f / else consence al programm~rore ~1 specificare che, nel c~o m cw la condizione sia vera, dovrà essere eseguira una a:1on~. diffe~enre. da quella che St dovrà eseguire qualora la condizione sia falsa. Per esempio, I 1Struz10ne rn pseudocodice Se il voto dello studente è maggiore o ugual.e a 60 Visualizza "Promosso" altrimenti Visualizzo "Boccù1.to ·• vìsu.alima Promosso m:moiort- o uguale a 60 , m e nere vrsu · al'12za B · iJ dse la vocazione dc:llo srudenceè ·-=· o~ci:;t(1 Se . ~o~? eU? scudcnte è_inferiore a 60. la entrambi i casi, dopo la visualizzazione, sara . esegµica 1'.stmz1one succzess1va nella sequenza dello pseudocodice. Osservare cbe ançhe il corpo dell altrimenti è rienrraro.
~ Buon~ abitudine 3.3 Fate rientrare entrambe le istruzioni del corpo di una stmtmra ì f / else. Qualunqu~ conv.ei:z~one di rientri abbiace scdt0 dovrà ~scr~ applicara coll cu-ra nei vostri
progra~". i?.. d1fh~ile leggere un programma che non obbedisca in modo uniforme alle convenzioni di spaz1arura.
Buona abitudine 3.4 Nel c~o ~ovess~ro ess~rci diversi Livelli d1 rientri, per ognutUJ di essi impiegare /o stesso qwzn.twwvo di spazio.
stampa " Promosso"
La precedeme srrurrura selaltrimenri in pseudocodice può_ essere scritta in e come 1-f (grade >= 60) . printf ("Promosso\n"); e1se pr i ntf("Bocciato\n");
falso Figura 3.2
vero
Il diagramma di flusso della struttura di selezione singola del C.
Possiamo immaginare sette concenirori, ognuno dei quali contiene solo uno tra i serre tipi di suutture di conrrollo. Tali srrurrure sono vuoce. Non è scritto nicncc nei renangoli e altrettanto nei rombi. Il compito del progra.rfu:fiarore è qu.U1di quello di assemblare un programma, con rance srrutrure di concrollo di ogni cipo quante ne richiede: l'algoriuuo. combinandole in due possibili modi (ovverosia impilandole o nidi6candole) e complecandole, in un secondo momenro, con le azioni e le decisioni appro_pàare all'algoritmo. Discuteremo in seguico le varierà dei modi in cui possono essp-e scrirre le azioni e le decisioni.
stampa "Bocciato"
Figura 3.3
stampa "Promosso''
Il diagramma di flusso della struttura di selezione doppia i f / else del c.
52
CAPITOLO
3
li diagramma della Figura 3.3 illustra esarramerue il flusso di controllo per la srrutrura i f I else. Ancora una volra, osserva:ce che, a pane i cerchietti e le frecce, gli unici simboli presenri nel diagramma di flusso sono i reaangoli (per le azioni) e il rombo (per la decision e). Conrinuiamo a evidenziare iJ modello di elaborazione basaco su a'l.ioni e decisioni. Immaginare nuovamente un conreniw re cap-ienre, òempico con tante srructure vuoce di selezione doppia quante ne possono servire per cosuuire qualsiasi programma C. li lavoro deJ programmacoJ'c, ripetiamo, è quello di assemblare le suddertc srrurrure di selezione, accarasrandole e nidificandole, con qualsiasi alrra ~rrura di controllo possa essere richiesta dalJ'algoàcmo, e complerando i rettangoli e-i rombi -vuoti, con le az.ioni e le decisioni appropriare per l'algorirmo che si sra implemenrando.
1J C fornisce l'operatore condizionale ( 7:) che è strcuamente correlato con la smmura if I else. Quello condizionale è l'unico operatore ternario del C: in alrre parole, accetta ere operandi. Gli operandi , insieme all 'op_eracose condiziona le, fo rmano una espressione condiziomdc. Il primo operando è l,lÌI~ cpndiiione, il sccpndo operando è il valore che assumerà l' incera espressione co11dizionale, qU:.alora l;t condizione sia vera, menrre il ceno operando è il valore che assLLmerà l' imera espressione condizionale, qualora la condizione sia falsa. Per esempio, l'istruzione printf prin tf{" %s\ n ", grade >= 60?
·P~omosso·
: ' Bocciato •);
conde.ne un'espressione condizionale che rescimirà la scànga letterale ' Promosso" , qualora la condizione grade >= 60 risulti vera, mentre restlcuiràJasainga lecrerale ' Bocciato •, qualora l:i. condizione risulci Falsa. Lasrcinga diconaollo del formato per la pr'intf contiene la specifica di conversione !\ss per visualizzare una scringa dj caracreri. .Oi conseguenza, J'iscruzione printf precedence eseguirà essenz.ialmence la scessa operazione ddl'isrruzione i f I else precedente.
r valori
in una espressione condizionale possono anche essere delle azioni da eseguire. Per esempio, l'espressione condizionale grade >: 60 ? printf ( '' Promosso\n') : printf ( "Bocciato\n•); si leggerà, "Se grade è maggiore o' uguale a 60 allora printf ( • Promosso\n •), alrrimenci printf ( •Bocciato\ n •) ". Anche quesra ~prn.~sionc condizionale è comparabile con la struttura i f I else precedente. Vediemo che .gli operarori condizionali potranno essere ucilizzaci in alcw1c situazioni dove non potranno essere ucilizzace Je ismizioni i f I else.
Le stmtture i f I else nidifièate sono in grado dì ~e.rificare diversj casi, se :;i slscc.mano dclle if I else a.ll'incern0 di akre mmmrè dello scesso àpe. Per ésempio, la seguenrè ìscru7.lone in pseudocodice., visualizzerà A per vorazioni di esame maggiori o uguali il 90, B pe.r v9d maggiori o uguali a 80, C per voti maggiori o uguaD a 70, O per vocazioni maggiori o uguali a 80, F per nttte le al tre votazioni. · Se il voto dello studente è maggiore o ugi,1ale a f)O Visualizza ';4" altrimenti
Se il voto dello studente è maggiore o uguale 11 80 Visualizza "B" altrimenti Se il voto de//q studente è maggiore o ugtlllk a 70 Visualizza "C" -
Lo SVlLUl'PQ DI PROCl~AMMl STRLDTURA"rl
53
altrimenti Se il voto dello studente è maggiore o uguale a 60
Visualizza "D" altrimenti
Visunlizu1 "F" Questo pseudocodicc può essere scritto in
e come
i f (grade >= 90)
printf ( "A\n");
el-se ìf (grade >= 80) printf (''B\n "); else if (~ rad e >= 70) printf ( "C\n '');
else i f (grade
>= 60) printf( "D\n");
else printf("F\n");
(çual~ra la var~abile grade ~ia m~iorc o uguale a 90, saranno vere le prime quamo condizioni,
ma. sarà ~1ta solcane~ I 1srruz1one printf s ~ccess.iva al p~o conrrollo. Dopo che quella prin.tf sara stara ~gwca, la parte else dell 1srrt1Z1onc i f /else "più escerna" sarà saltata. Molri programmacon C preferiscono scrivere la precedenre srrurrura i f come
1
H (grade >= 90) printf("A\n"); el se i f (grade >= 80 ) printf ( • B\ n • ) ; eise i f (grade >= 70) printf(''C\n"); else i f (grade >~ 60) prìntf( 1' D\ n'' ); else printf( "F\n '' );
Per il compilacore fu come , ·è, •COncepiro cl.ifft.c
e,
encrambe. le fo arre lenc1- • .1.. Tl I . · sono e(nriv·• L" 1.1 urna rma e pm . sa perc~é evita un rientro del codlce troppo profondo vt:rso jJ margine descro. Un mie nenrro lascta spesso poco spazio suite righe, c:Ostringéndo alla frammentai.ione delJe scesse e facendo diminuire la leggibilità del programma.
~:t~~rnu:a d.i selezione i'. si asperca un~ sola istruzione nd proprio corpo. Per includere pm nel corpo ~ire ({ e }) il gruppo di . . .1struzJoru U . . di. w1. i f , racchiudete rra pa:renresi 5•cu11 1stru~on 1 .. n gruppo d11Strt121on1 concenmo all'io remo di una coppia di pareutesi graffe è una utrttz1one wmposta.
~ _l~ng.~e~w._1e._r_in_d._e_l_so~ifiw· _a_re~3~.~'~~~~~~~~~~~~~~~~~~~ Una iJt;uzione composta può essere imerira in qualsiasi ptzrte del programma in cui pcssn esure sistemata ima istruzione singola.
-
I
n
CAJ>ITOLo
54
3
l.:esempi o successivo include una istruzion e compost a nella par~e else c:ji una .strumua i f I else. i f (g1'ade >:o 60)
ln quesro caso, qualora b votazione fosse inferiore a 60, il programm a èseguirebbe entrambe le isrruzioni printf presemi ad corpo di else e visualiz.zerebbe
Bocc.iato . Devi r ipetere questo corso. Osservate le parentesi graffe che circondano le due isrruzioni della clausola else. Quesre · parentesi graffo sono i11Jpbrtanri. Senza di esse, l'istruzion e printf(" Devi ripete r e questo corso.\n "); se la sarebbe esterna: al ramo else dell'istruz ione i f e verrebbe éseguira. senza conside_rare votazione sia ono inferiore a 60. ~
co dovranno cissere sistemate all 'inizio di q_lLest'uhi mo, prima d1 ogni isrruzione d i azione. Discutere mo dell'uso dei blocchi nel Capimlo 5. Eino a qud mome.nrn, il lerrore dovrà evirare l'utilizzo dei blocchi (eccezion futca per il main, nattiralm cme).
La struttura di iterazi one while
3. 7
Una m·uttttra di iterazione consence al p rò.gmmm~to re di specificare che una a1.ione ehe
dice dovrà essereriperut.a finché alcune condiziortl àmarrann o vere. Lisrruz.inne in pseudoco
Finché ci sono ancora atticoii nelw, mia lista della pesa Cpmpra ilprossimo articolo e c1111C1:[/Dlo dalla mia Lista e 1 descrive l icerazioae che si verifica durante una passeggiata per gli acquisri. La condizion vern, saJ"à Se falsa. o vera essere potrà "ci sono ancora articoli nella mia lisca della spesa" allora sarà eseguita J'az.ione "Compra il prossimo .arcicolo e cancellalo dalla mia lista". Le Questa azione sarà esegi1ita riperucamence fìncaato che la condizion e rimarrà vera. scessll.. della. corpo il ono istruzioni comenure nella strurrura di i.ceraz.ione finché costimìsc Quesco porrà essere fon:naco da una isrruzione singola oppure da una composta. Infine, la condizion e divencerà falsa (quando l'ultimo articolo della lista sarà sc:no acquisraro e cancellato dalla scessa). A quesro punto, il cido potrà rerminare e sarà eseguìca la prima istruzione dello pseudocodice successiva alla srrurrura di iterazione.
Erro.rf! tipico 3. i
Errore tipico 3.3
~ JJimentican: una o mtrttmbe leparente.si gmffe che delimitano una istruzione composta. 'U.fl errore di sin cassi è incercerrato dal compilarore. Un erro.re logico ha il ~uo ·effetto predurante l'esecuzione. Un errore logico furale conduce al fallimenco e alla terminazione e continuar di a programm al corrsenre fatale non matura di un programm a. Un errore logie-o errati. risultati J'eseclrz.io ne ma anche di pr0durrc
Non fornire, nel corpo di :ma strutturtt whil e, una f1.?.?one che faccia eventualmente dùJemare falsa la condizione del while. Notmalmente, 1.ma tafe:st:ruttur.a di iteraz·ione non avrà mai fine: un errore chiamato ''ciclb infinito". 0
En·ore tipico 3.4
Scrivere la parola chiave while con ima Wmaiuscola come in While (ricordate che il C è un linguaggio .che distingui! le maiusct)fe i/4/le minuscole). Tutte le parole chia.ve riservate del e come whi le, i f cd else contengono soltanto l.ettere mimacol.e.
Errore tipico 3.2 inserire un punto e virgol.a, d,Qpo la condizione di ttna strtm1'ra i f , cb11d1m·ebbe a un errore logico nelle strutture di reiezione singola i f, mentre provocherebbe un errore di sintassi nelle struttttre di selezione doppia i f I else. Buonti abitudine 3.5
Alc11.nip1·ogra1rtmatoriprej-èl'ist·ono digirare lo ptmntesi graJ!à ini.zi{l/e e quel/a finale tii u.na istmzione composta, prima di digitare le singole istruzioni 11il'hnemo delle parentesi grafjè. Ciò ai11ra a wit1tre di omet:tere u.na o entrambe le parentesi graffi. ingegneria del software 3.2 Proprio come una istruzione composta potr4 çssere imerha. laddovc potrebbe es.rere sistemata una istruzione singol.a, sarà anche possibile non averne j>er nulla, in altre parole, avei-e i'istrrezione vuota. l'i.rtmzione uuONl è rappresm.til.ta. dall'ins.erimento di un punto ~ virgola (;)laddove nonna/mente ci sal'ebbe stn.ta uria istrt1zian,e. In quesca sezione abbiamo imrodouo la nozione di isrruzione composta. Una istruziodi ne composra ,pmrà anche conreaere
55
L O SVILUPPO Dl PROGRAf\·L"11 STRtrrrtJR ATI
Consideriamo ora, come esempio di una while reale, un segmento di programma progecraro per trovare la prima potenza di due maggiore di 1000. Supponere che la variabile irrrera product sia stata inizializzata con 2. Nel momento in cui la seguente strumrra di iterazione while aYJ'à terminato la propria esecuzione, product conterrà. la rispo~u desidera.ca:
produc t
= 2;
wh ile· (product <= 1000 ) product = 2 * product;
rl
scrurrura di diagramm~ della Figura 3.4 illustra precisamenre il flusso di conrrollo per la
a iterazione while, Ancora una volca., osse1vare d1e, a parre i cerGhiecri e le frecce, il diagramm rc. conceniro un di flusso contiene soltanto un rettangolo e un rombo. Immagin ate, ancora, alue capiente pieno di smmure while vuoée che potrann0 essere accatastare e nidificate coo di controllo di usso fl strutture di conuollo, per furmare una implèmencazione strutturata per il e azioni te appropria un algoriuno. l reaangoli e i rombi vuoti saranno quindi completati con Je emergente flusso di decisioni. ll diagramma di :flusso mostra chiaramence t'iteraz.ioae. La linea
f 56
CAPffOLO
Lo SVlWPPO DI PROGRAMMI S'rRLTTTURATl
3
dal rerrangolo torna indietro alla decisione, che sarà verifìcaca ogni volra all'imerno del ciclo, finché la stessa non divcmerà evenrualmeme falsa. A quesrn pumo, la srrurrura while avrà complecaco il suo cornpico e iJ concroUo passerà all'istruzione successiva del programma. Al momento dell'ingresso nella :.truttura while; il va.lore di product era 2. La variabile product sarà. molciplicaca riperuramerue per 2, assumendo nel umpo i valori 4, 8, 16, 32, 64. 128, 256, S 12 e 1024. Nel momento io cui product avrà assunto il valore 1024, la condizione nella srrumu-a while , product <= 1000, sarà divenrara falsa. Ciò provocherà il termine dd ciclo e il valore finale di product sarà 1024, 'Cesecuzione dcl programma continuerà con la prossima isrruzione dopo il while.
immagav.inare i torali nom1alinente devono essere azzerate, prima di poter essere utilizzate in ua p~g~; alrr~menti la somma includerebbe il valore imm3t>oazzinaro in precedenza nella J~o.ne_ di mi:morra del totale. Secondo il loro utilizzo, le variabili.contatore sono normaJmenTI'.. i_n~illnare c?n. zero o.~~ ~pr~enrer:mo degli esen;pi che momano ognuno di questi ~). Una vanahrle non inrzial.izzara conaene un valòre 'i.mmondiZia": l'ultimo dato imm.agaz21naro nella Jocazione di memoàa riservara per quella variabile.
Errore tipico 3.5 Nel cnso irJ cui un contatore o un coral.e non sia stata imz:iali:izato, probabilmente i ri.sultad dei vostro programma non stmtnno corrett_i. Quest() è un esempio di errore logico. lnizializz11re il totale a zero Inizializzare il contatore dei 11oti 11.
produet = 2 ·• product
Figura 3.4
3.8
Per mosrrare come sono sviluppati gli algoritmi, risolveremo diverse variami di un problema per il calcolo della media di una das.5e. cOns.idcrarc la scguemc enunciazione del problema:
Una classe di dieci studenti sos'far1e· un esame, Avete a disposizù;ne le vqrazicni. (degli interi ne/J'interval/Q dn O11 100) per questo esame. Deténninate la media della classe in questo esame.
La media della classe sarà uguale alla somma dclJe votazioni divisa per il numero degli studenti. Calgoricmo per risolvere questo problema su un ~ompurer dovrà prendere in input ognuna delle votazioni, eseguire ll calcolo dei vori immesso. I.e variabili usare per
w10
Finché il contiltfn·e resta rhinore o uguale d. dieci Pn!ndi;re drttl'inpttt il prossimo voto Aggiungere il voto aL totale Aggiungere tmo al contatore Impostare il vawre della media al totale diviso dieci . Vi.su.aliz.zare la media
Il diagramma di flusso della struttura di iterazione while.
Formulazione degli algoritmi: studio di un caso (iterazione controllata da un contatore)
57
Figura 3.5 L'.algoritmo in pseudocodice che utilizza una iterazione controllata da un contatore, per risolvere il problema del calcolo della media di una classe. /* Programma per il calcolo della media di una classe còn una iterazione controllata da un contatore •1
#include mai11() {
int counter, grade, total, average;
I* fase di i nizializ.zaziohe */ total = 0; counter = 1;
/.* fas·e d:i elaborazione * / while (oount er <= 10) { printf( Enter grade: '' ); scanf( '%d", &grade); total = total + grade; counter = counter + 1; 11
/* fase di chiusura * / average = total / 10; prirrtf( "Class average is %d\n•, average);
(Cb11tinu11)
CAPITOLO
return 0;
3
/* indica ohe i l programma è terminato con successo */
}
Enter Enter Enter Enter Enter Enter Enter Enter Ent_er Er,ter Class Figura 3.6
ff]
grade: 98 grade: 76 grade: 71 grade: 87 grade: 83 grade: 90 gt'ade: 57 grade: 79 grade; 82 grade: 94 aver,age is 81 Programma C ed esecuzione di esempio per il problema del calcolo della media di una classe, con una iterazione cori~rollata da un contatore.
Buonn. nbirudine 3. 6 Inizializzate i contatori e i totali.
Osservate che il calcolo deUa media ud prngramma ha prodotto un risulcaro intero. ln realtà, la somma delle vot.azioni in quesm esempio è 817 che diviso per dieci dovrebbe produrre 81,7, in alrre parole, un numero con una virgola decimale. Vedremo come rrattare questi numeri (decri in virgola mobile) nella prossima sezione.
3.9
Fonnulazione degli algoritmi con processo top-down per raffinamenti successivi: studio di un caso 2 (iterazione controllata da un valore sentinella)
Generalizziamo il problema dd calcolo della media di una classe. Considerate il seguente problema:
Svilitppate ttfl p1'ogramma per iL ca.kof() dtlkt medià di una cl4S$e, che elaborerà un nun'll'1'0 arbitrario di votazioni ogni volta che il programma sarà eseguito. Nd primo esempio di calcolo della m~dia di una classe, il nume.ro delle vocazioni (1 O) era nòco in anticipo. fo que$tò esempio,. non è. sw,~ ~ca alcuna inclicazione su quante vocazioni saranno immesse. JI progl'amma dovrà clabmarn un numero arbir~ario di v.ocazioni. ln quale modo iJ programma pocrà determinare cfliando terminare l'immissione deUe votazioni? fn quale modo potrà sapere quando calcolare e visualizzare la media della classe? Una maniera per risolvere quesro problema è ru usare un valore speciale, detto val.ore senti.nella (o anche vakJre di segnd.la.7ion.e, valore durnmy (fitti.zio) o 11alore flag (bandiera)), per indicare la "fine della immissione dei dati". I.:utenre immerrerà le vocazioni finché rurte quelle legittime saranno state immesse. I:utente irnmetcerà quindi il valore sentinella, per indicare che l'ultima valutazione sarà stata imm~a. Le iterazioni controllate da un valore sentine.Ila sono spesso deru: iterazioni indefinite perché, prima che inizi I'esecuz.ione del ciclo, il numero delle iterazioni non è noto,
Lu SVILUPPO nr PROGRAMMI ~TIHJl" f'lJMTI
59
Cb iar:imenre, iJ valore senciaelJa dovrà essere sédrn in modo che non possa essere confuso con un valore. di input accerrabile. Daro
~ Errore tfpico 3. 6
~
Scegliere un vawre sentine/La che sia anche i-m vahre Legittimo per i timi.
Affionteremo ora il problema del calcolo della media di una. dasse, con una tecnica <':.biamara, top down (datl'a/t(J in basso) per rajfìnamenti successivi: una recnica essenziale per Lo svi luppo di programmi ben strucrurari. Cominciamo con una rappresentazione in pseudocodlcc del top:
Determinare .Id rnt•dia della classe per l'esame Il rop è un.a ~in.gola isnuzione. clic specifica rutte le .funzioni del programma. Per come è definito, il rop è in effetri w1a rappresencazione complero. di un prògramma. Sfortunaramente, il top speci.ficaiaramenre una quanrirà sufficieme di dei:tagli da cui ricavare un programma C.
Per quesco morivo ora diamo il via al processo di raffina.mc.neo. Dividiamo il rop in una serie di piccole aràvirà e le elenchiamo nell'ordine in cui dovranno essere eseguite. Ciò produrrà il seguenre primo reffinommto. Jniziaii2.Z11re le variabili Prendere in input, sommare e conftzre le votazioni deU'esnme Co/col.ore e uimalizzore I.o media della classe In quesro caso è scara usata solramo la srrurtura di s~quenza: iofu.rci, i passi elencari dovranno essere eseguici in ordine, uno dopo l'akro.
f1['1
~
Ingegneria del softWarr: 3.3 Ogni rnffinmnento, così corno lo stesso top, è una varia solo i! livello di dettaglio.
erumci~ione completa de/L'ttlgoritmo,·
Per procèderc verso il livello succe.~sivo di raffi.uamenco, ovvero$ia il secondo, ci impegneremo nella specifìc
porrà esse.re raffinata come segue:
lnizializzare il totak a zero Inizializzare il contntore n :uro
'
CAPITOLO 3
60
Osservate che occorrerà i.nizialiizare solo il rorale e il contatore. Le variabili per la media e le vaJutazioni (àsperrivamence, per la media calcolaca e l'input deU'uteme) non dovranno essere necessariamente inizializzate, perché i loro valori saranno sostituiti dal processo di scrittura distruttiva, di cui abbiamo discusso ud Capitolo 2. L'isrruzione in pseudocodice
Prendere ln inp1(t, sommare e contar.e /,è uo(a.zion.i dell'esarrie richiede una strumua di irei:azione (ovver<;>~ia un ciclo) che prenda in input consecurivamenre ogni vah.1tazione. Dato che non sappiamo in anticipo quante valurazioni dovranno essere daborare, uril.izzeremo una iterazione contròllaca da un valoresenrindla. l.'.utente digiterà una per volta le-valutazioni legictime. Una volt;i_che l'ultima valutazione legittima sarà sr.aca digitata, l'uteritelnimerrerà il valore sentinella.. Per ognuna delle valucaz.ioni immesse, il programma controllerà l'evenruale immissione dehalòreseminella e terminerà il èiclo quando l'avrà inconrrato. Il raffinamento della precedence iscruzione in pseudocòdice s:rrà quindi
Prendere in inpu.i fa prima valutazione Finché l'u'tente non. ha ancora.irttmesso il valèe.. sentinella Aggiimgere questa valutrn:;ione al total.e cor.rente Aggiungere uno al contatore di valutazioni Prendere in· input /,a prossima valutazione {o forre il valore sentinella) Osservare che, nello pseudocodice, non utilizziamo parentesi graffe intorno all'insieme di istruzioni che formano il corpo della srrucmra finché. Facciamo rienrrare semplicemente queste istruzioni sono il finché, per mosrrare che appartengono rucce a finché. Di nuovo, lo pseudocodice è solr.anto un aiuco informale allo sviluppo del programma. I:isttuuone in pseudocodice
Calcokm·e vi.su(J../izzilre I.a medJa della classè potrà essere raffinata come segue:
Se it contatore mm è uguale a uro fmpostare I.a media con ili totale diviso per il comatore Visualizzare la media altrimenti VisU11,/Jzza.re "Non sono state immesse valutazioni" Osservare che~ questo caso siamo scaci artemi a verificare la possibili~ di una divisione per zero: un errore fatale che, se non fosse stato individuato, avrebbe causato il fallimento del programl}ia (detto spesso bombing o orashing). Il secondo raffinamento compleco è mostrato nella Figura 3.7.
~ Errore tipico 3.7
~
Un tentativo di·divisione per zero genererà un errore forai.e.
Inizializzare il totak d zero /nizittli.7.zare ii.contatore a zero Prender.e i'll input la prima vaiutaziohe Finché i'utente··'hon ha ancora immesso il valore sentinella
61
Lo SYILUl'PO DI PROGl~MI STRUTfURATI Aggiungere questa valutazione al rotale corrente Aggiungere uno al c_qn>atore di valutazioni Prendere in input '4 prossimfl valutazione (o forse il valore sentineliti) Se il contatore non ~ uguale a zero Impostare la niedid con il totale divi.so per il contatore Visualizzare la medù1. altrimenti Visualizzare "Non sono Itate immesse valutazioni" Figura 3.7
Lalgoritmo in pseudocodice che utilizza una iterazione controllata da un valore sentinella, per risolvere Il problema del calcolo della media di una classe.
Buona abitudine 3.7
Quando esegrtite 1ma divisione per una espressùme chèpot1 ebbt: asmmere tm vqfore uguale r1 uro. tontrollate.esplicitamente quella evetiimza e gestitela in modo '1.J>pròprù:tt(J nel vast1·Q programma, per esempio, stampand.o un messaggio. inuet:e di lasciare che urt lfn'Ore fatale 1
ne intenwnpa l'esecuzione. Nella Figura 3.5 e nella Figura 3.7, per una maggiore leggibilicà, abbiamo incluso aJJ'imerno dello pseudocodice alcune righe complecamenre vuoce. In realrà, le righevuoce separano questi programmi nelle loro varie fasi.
Ingegneria del software 3.4
Mo/Ji programrnipossono essere s11ddivid logicaf!tentè in ttefas;,· imafase di iniziaji~itme, che inizializza k var.iabili de/.pro!!amma; unafosi: di elàborazione, che prewJe in input i valori dei dati e imposta conseguentemente Le ·variabili del programma; uria fase di chiusura, che calcola e visualizza i risultati finali. l!aJgoriano in pseudocodice della Figura 3.7 risolve il problema più generale del calcolo della media di una classe. Quesro algoritmo è sraco sviluppato dopo d ue soli livelli di raffinameoco. A volte saranno necessari più livelli di raffinamenco.
Ingegneria del seftware 3.5
li programmatore termina ii processo top down per raffinttmenti successivi;. quando L'algor.itmo in pseudocodice specificato è sujficù:ntcmmte dettagliato perché it progràmmatote possa essere in grado di convertirlo in C. Normalmente, a quel p:U.nto, l'implementazione-~! programma sarà lineare.
e
Nella Figura 3.8 s6.nò mosrrati il programma Ce l'esecuzione di e.sempio. Nonostaoce vengano i..mmesse solcanrn delle valutazioni intere, il calcolo della media produrrà probabilmence un numero decimale con una virgola decimale. Il cipo di dato int non può cappresencare un tale numero. Il programma introduce perciò iJ ripo di daro float per gescire i numeri con Ulla virgola decimale (detti numeri in virgola mobile) e un operatore speciale, décto operruore cast (operatori di Gomersione), per g~srire il çal~ colo della media. Queste c.ararterisriche saranno spieg!li:e in dettaglio dopo la presentazione del programma.
CAI'tTOLO
3
r• Programma per il calcolo della media di una classe con Una iterazione controliata da un valore sentinella •/ #include ma in () {
/* il ~uovo tipo di dato * I
float av(:?rage; int counter, grade, total; /* fase d i inizializza zione *I total = 0; cotJnter "' 0;
chius~ra */
if (counter I= 0 ) { av.erage = (float) total I counter; printf("Cla ,s average is %.2f' 1 average); else printf ('No grades were entered\n•) ;
1·· indica ohe il programma è termi nato oon successo • '/
}
Enter. EnteP Entér Enter Enter
Enrter Enter Enter En~er
Class
FiguraJ.8
grade, ~1 t;o end : graéfe, ~ 1 tO end: grade, -1 to enà : grade, - 1 to end: grade, • 1 to -end: gr:-ade 1 • 1 t@ eh'd : grad.e, -1 to efld : grade, ·1 to end: grade, · 1 to en
Osservare l'istruzione composta nel ciclo while della Figura 3.8. Ancora una volra, le parentesi_ graffe sono necessarie perché cu[[e e quattro le istru1.ioni sia.no eseguire all'inrerno del ciclo. Senza le parentesi graffe, le tre istruzioni nd co rpo· dcl ciclo .ricadrebbero aJ l'escerno dclla iterazione, indhlcendo il compun:r a inrerp'l'etare erroneament e il codice nel modo seguente: while ( grade I= - 1) total = total + grade; oounter = counter + 1; printf( "Enter grade, -1 to end: " ); scanf( "%d " , &grade); lutazione.
while (grade != ·1) { total = total -t grade; co.unter = cqunter + 1 ; printf( "Enter grade, -1 to end: "); scanf( "%d " , &grade);
return 0·;
63
Ciò provocherebb e un ciclo i.rifinito, qualora l'urenrt non immettesse -I come prima va-
/* fase di elaborazion e • t printf ("Enter grade, - 1 to end: "); scanf('!%d", &grade);
/* fase di
LOSVTLUP"PO I)[ PROG l~\fMI STRU"ITTIRJ\11
75
94 97 88 70
64 83 89 -1
li programma e e l'esecuzione di esempio per il problema del calco~o della media d! una classe, con una iteraiione c?ntroll~ta da un valore sentinella.
~
Emma abitudine 3.8
lk2J
In un ciclo controllato da nn valore Sifntinelln, ilptoin.pt pr.r la richie.;ta di lmmissione dei dati dovdt rico1•dare esplicitamente rrll'1m11te qual è il valore senti11elln..
Le medie non saranno sempre dei valori inceri. pesso, una media sarà un valore 7,2 o - 93,5 che comengo no una parte Frazion~ria. Questi valori sonQ indicati come numeri in virgola mobile e sono rappresenraù dal Lipo di daro float. la variabile average è dichiara ca con il ripo f loat cos) che possa <:
come
average
~
(f loat) total I counter;
iod ude l'operacore di conversione ( float) ·che creerà una copia témporanea in virgola mobile dcl suo operand o total. L'utilizzo di un openrore di conversione in questo modo è derto conversione esplicita. Il valore immagazzin ato in total è ancora un incero. I.I calcolo, a questo pum:o, consisterà d i un valore in virgola mobile (la versione float temporanea di total) d.Ivi.so per un valore incero immagazzina to in counter. Il però sa solo valutare espressioni in cui i tipi di dato degli argomenri compilaJ.'ore assicurarsi che gli operandi siano dello scesso ripo, il compilacore Per sono id.en.àci. se lez iona ci una operazione derta promozione (o anche quelli su eseguirà Per esempio, in una_espres~ione c0ntenenre i ripi di dato int e impiici't'o). co1111ersione speci fì<>a che dov ranno essere esegui re delle copie degli operandi ANSl standard lo f loa t . essere promosse al cipo float . Nel noscro esempio, una dovranno quesce int e che la copia di counter e che questa sarà stata promossa al eseguira v<>lca che sarà stata e iJ risultato della divisione in vi rgola mo):>i lc sarà calcolo il tipo fl~at , sarà eseguico ANSI fornisce un insieme di regole per I.a promostandard Lo assegna:ro ad average. Il Capimlo 5 prescmerà una discussione di curà i operandi. di àpi zione dei differenti cli promozione. ordine rela.ùvo del e tipi cli dato stand
e
CAPITOLO
64
3
Sono disponibili operatori di conversione per ogni ripo di daco. I.:operar9re di conversione è composta inserendo delle parentesi tonde iruorno al nome del tipo di dato. roperarore di conversione è un operatore unario, ovverosia un operarore che accerra solo un operando. Nel Capicolo 2 abbiamo studiato gli operaroà aritmecici binari. Il C supporta anche delle versioni unarie degli operatoci più(+) e men0 (-),perciò il programmatore pouà scrivere espressioni come - 7 o +5. Gli operato.ri di conversione associwò da destra a sinistra e hanno la m:ssa priorità degli altri operatori unari, come il + e il - unari. Tale priorità è a un livello più aJro di quella degli opctat.ori moltiplicativi.*, I e 9ts e a un livello più basso di quella delle parentesi.
li programma nell~ Figura 3.8 urilirz.a per la printf la specifica di conversione lii. 2f per visualiz.zare il valore di ave rage. La f specifica che sarà visualizzato un valore in virgola mobile. li . 2 è la precisione con cui il valore sarà visualizzato. Quesca stabilisce che il valore sarà visualizzato con due cifre a desrra della virgola .dci decimali. Nel caso fosse stara u.riliz.zat:t la specifica di conve.(sione 5\sf, ovverosia senza indicare la precisione, sarebbe stata urilizzara quella d;. defareltdi Qcifre, proprio come se fm'Se stam mitizzata la specifica di éonvers.ione %. 6f. Nel momenro in cui saranno visualizzari dei valori in virgola mobile éort una dara precisione, il va10fe visualiz;zato sarà arrotondato al numero i.nd.icaco di posizioni decimali. Il valore nella memoria resterà jnalteraco. Una volra che le seguenci istruzioni saranno state eseguire, sara.nnQ visualizzati i valori 3,45 e 3,4. / • visualizza 3,45 •/ printf {"%. 2f\n", 3.446); /* visualizza 3,4 */ printf("\. 1f\n", 3.446);
Lo SVl.LUPPO DI PROGRAMM1 srn.1.!ITURAn
65
solamente una quanril:à prefissata cii spazio; è quindi evidente che il valore in virgola mobile immagazzinato porrà essere solranro una approssimazione:.
3.1 O Formulazione degli algoritmi con processo top-down per raffinamentj successivi: studio di un caso 3 (strutture di controllo nidificate) Lavoriamo ora su un altro problema compleco. Utilizzando ancora una volta lo pseud.ocodice e il processo cop down per raffioamc.mi successivi, formuleremo un algoriono e scriveremo un corrispondente programma C. Abbiamo visco che le stm:rrure di controllo possono essere accatastate l'una sull'altra (in sequenza), proprio come i bambini accatastano i marroncini delle cosrruzioni. ln qucsro srudio di un caso, vedremo l'unico alrro modo strutturato anraverso il quale le strutture di ço.mrollo porranno essere connesse in C: ovverosia amaverso la nidificllZione di una struttura di conrrollo Jn un'altra. Considerate la segueme..enunciazione del problema:
Una università offre un corso chepreptzra gli studeizti per l'efrtrne della Licenza di staJ:oper agenti. immobiliari. Lo scorro ànno, mo/Ji degli studenti che hanno completato questo corso haµ:no superato l'esame per ottenere fa licenz,a. Naturalmerrte, l'università vorrebbe sapere quale sia staro L'esito dei propri studenti al termine dell'esame. Vi è stato chierto di scrivere un progi-amma che sommi i risultati. Vi è sta'fll anche ronsegnata una li.sto. tfi 1Ostudenti. A fianco a ogni nome è stato scritto un L, se lo studente ha supmuo l'esame, e un 2, se lo studente è stato respinto.
Errore tipico 3. 8
Il vostro programma dovrà analizzare i risultati dell'esame come segue:
È e.n-ato usare 1.a precisione in una specifica di cònversione nef/,a stringa per il controllo delfamu1to diu:na istmzione scanf. Le prècisioni possono essere 11ti!izzate soL{O.nto n~lle specifiche di conversione di printf.
Buona 4b,_it;14imr 3.3
L Prendere in in pur ogni risulraro della prova (ovverosia un 1 o un 2). Visualizza.te i.I mes~ sàggio "Enter resulc'' (im:mer;rere il risultato) sullo sthcrmè ogni volta c::he il prògramma richiede un alrro risulcitò della prova. 2. Comare le occorrenze per ogni àpo di risultato deUa p rova. 3. Visualizzate un riassumo dei risuJcaci, che fodichi il numero degli srudenci che han.no superato la prova e quello degli scudenci che sono stari respinti. 4. Nel ca.so più di 8 stude11ti abbiano superato l'esame, visualizzate il messaggio "Ra.ise miiion" (aumentare le ta.s;e}. Dopo a~er .letto atrentamen_ce J'enunci:tzione del problema, sviluppiamo le seguenti oss.ervaz1on1:
N
1.
Errore tipico 3.9 Utilizzare i numeri in virgola mobile, presumendo che siano rappresel'Ittlti in un modo
preciso, potrìi condurre a risultati incorretti. l numeri in virgolll mobile sono rappresenrati da{fa moggigr parte dei comp1tter solo in moda approssimato.
I numeri in,virg~la mobile banno numero~ applicazioni, nonostante n0n siano sempre "precisi al 100%" . .Per esempio, quanq<;> pa.diamo di ui1a "normale" temperacura corporea di 98,6 gradi..Fahrenheit (37 gradi Celsius), non abbiamo bisogno di essere precisi fino a un gran numero di cifre. Nel momento in..filli vediamo la temperatura di un termometro e leggiamo 9'8,6, questa porrebbe essere in r.ealrà 98,5999473210643. La questione è che leggere sernplicememe quel numero come 98,6 andrà bene per la maggior pa.r:tè delle applicazioni. In se~iro diremo qualcosa in più a proposito di questo problema. Un altro JI!odo per mezzo del quale potrebbero essere prodotti dei numeri in virgola mobile è artra.ve~sp l~ dlvisioni. Quando dhrid.iamo 1O per 3, li risulmto è 3,33.3J333 ... çon la sequenza dci ~ che si r.ipere all'infmito. Per comenere un mie valo.re, il co-i'hplltè-c alloca
n programma dovrà elaborare 10.risulcati per la prova. Saià quindi uti lizzato lUl ciclo
controllaco da un conrarore. 2. Ogni risultato della prova sarà un nun1ero: un 1oun.2. Ogni voka che leggerà un_risulcaro della prova, il programma dovrà determinare se qud numerò sarà scaco un l o an.2. Nel nosrro algoàano ci limireremo a controllare il numero 1. Qualora il nwnero non sia un 1, supporremo che si tracci di un 2. (Un esercizio alla fine del capitolo considererà le conscgueo.zc di questa supposizione). 3. Saranno urilizzaci due concacori: uno per comare il numero degli studenti che hanno superato l'esame e l'altro per contare il numero di qu~ che sono stari respinti. 4. Una volta che il programma avrà elaborato i risultaci, esso dovrà decidere se avranno superato l'esame più di 8 scudenti.
66
CAJ'ITQLO
3
Pro.cediamo con LI processo top down per raffin·amenci success ivi. Cominciamo con
una rapprc!Senrazionc in pseudocodice dd rop:
Amrlizwre i rimlt11ti de/L'tsame e decidere se debbrmo essere numen tnte le tasse scolastiche Ancora w ia voi ca, è. imporrante mettere in risalto che il top è una rappres<:Ilmzione completa del programm~. ma che probabilmenrc saranno necessari div~rsi raffinamemi, prima çbe Lo pseud0codice possa evolvere natm almeme in un ptqgra mroa C. li nòscro primo raffinamenro sarà· Inizializzare le varJ'abili Prenden: in input 10 vnlutt1Zioni della prova e contare le promoz,ioni e IF bocci11t11.re Visualizzare un sommario dei i·isultati de/l'es11me e deddt·te se le ttWe scolartiche debbano essere aummtate Anche a questo punto, sebbene abbiamo una rappresenrazione romplera dell'incero programma, sa.rà necessario wl successivo raffina.memo. Ci impegn eremo ora a specifica.te le variabili. Saranno necessari dei concarori per regiscrare le promo zioni e le boroarnre, un c::ontaro.r.e sarà ucilizzaro per conrrollare l'elabotazi0ne del ciclo e sarà occ~aria una variabile per immagazzinare l'input dell'urente. I:isrruzione in pseudocodice lf1izirtli:z,zrire I.e variabili porrà e.">sere 1affi114ra come segue:
[nizialiZzo:re le promozioni a zero Iniziali.zuire le bqcciature n zero lni.zia/i22,llre gli mulenti ti uno Òsservace che sono stati ini2ializ7.ari solranco i contatori.e i corali. L:isrrm ione in pseudocodice Prendere in input 1() valutazioni dell.1 prova e ctmtare Le promozioni e le boci:iaturè richiederà un ciclo che prenderà in_ input conse.curivamente i risulrari di ognuno degli esami. In quesro caso, si conosce in anricipo ché ci saranno precisa meme dieci cisulraci di esame, perciò ~ appropriato u.riliuafe un ciclo rnmrollaro da un C()lltatore. Una str1;1rrura di selezione doppia all'i.memo dcl <".ido, owerosia nidific~ nel corpo della .irerazione, determinerà se ogni risultato di esame sarà sraro una promoz io)1e o una boccia:rura e increm~oceràdi oorueguenza i contatori appmpciati. Il raffinamento della precedeme istruzione in pseudocodice sarà quindi
Finché ii conta,tore degli studenti è inferiore o uguale a dieci Prem/.ere in input il prossimo ri$1,ftato. d'esanu: Se lo ·uudente è stato pr(Jmo.rsq Aggiungere uno ai promossi altrimenti Aggiunger~ uno aj bocciati
Lo SVILUPPO DI PROGRAMMI STlll.JTf'IJRATI
67
Vìsualizzare un sommario déi Timitari deLL'esnme e decidere se le t.a..rse sco/11.Jtiche debbano essere aumenrote porrà essere raffinata come segue:
Visualizzare il numero delle promozioni Vìsu4ljy.zare_ il mnnero delle bocciature Se più di otto studenti sono stati promossi Vrsualizzare il mesu1ggfo ''Raise mition" (aimibztare le tm·se) Nella Figura 3.9 appare il secondo raffinamento complero. Osserval'e che le righe vuote sono usate anche per e.vjderiziare .la srrucrur a dd finché e migliorare la leggibil ira del programma.
lniziali.zzi1re le promozioni a zero lw~ia!izznre le bocciature a zero fnizialiuare gli studenri n uno Finché iL contatore degli smdenti è inferiore o ugU11./e a dieci Prer.idere in input il prossimo risultato di mzme Se /.Q studente. è stato promosso Aggiungere uno ai promossi 1dtrimenri Aggiungere uno tli bocciati
Aggiungere uno ai contatore degli studenti Visualizzare l.I numero deile promozioni Vima.Lizzare il numero delle boccint:ure Se più di otto J'titde.nti sono stati promossi Visualizzare il mmaggi.o ''Rahe tuition" (aumentai-e Le tasse) Figura 3.9
Lo pseudocodice pe r il proble ma dei ri~ultati dell'esame .
Ora questo pseudocodice è sufficientemente raffinato per (:$Sere convertito in C. Nella Figura 3.10, sono .mostr~ ti il progra mma C e due esempi cU esecuzione. Osservace che abbiamo approfittato dj una caratcerisrica del che cqnsenre di incorp orare le inizializzazioni nelle cUchi:arazioni Una siffatta inizializzazione sarà eseglùta d urarite la compilazione.
e
Obiettivo efficienza 3.1 Inizializza.re le va.rU!bili contestualmente. al/4 Loro dichiar~ione riduce il tempo. di esecuzione di un prognimma. l'!J.geg;neria del software 3.6
Aggitmgere uno al contatore degli studenti Osserv·ate l'utilizzo delle cighe bianche, per evidenziare la strumu a di controllo se!nltrimenti e migliorarela leggibilirà del _programma. I:isrruzione in p~eudo codice
L'esperienza ha dimostrato che, S1{ un computer, la parte pi1~ difficilè della risoluzione di un problem4 è lo sviluppo deil'algoritmo per la sua soluziane. Norma lmente, una volta che sia rtato specifica.to un algoritmo corrett-0, il processo di p.roduz.ione di un p rogramma funzionante sarà lineare.
lYlolti progrdmmatorlscrivoiw; progr"tJ.rf?mi serzi;il rrl!,d uti.ii~tr_rnmo St'/'lmtent(J ~i ~11i lzppo come lo pseudocodiee. (ùedono che ~l loi·o. ~biettivo ~r~n_ctJ,d/.è sr'n qt1e~o d1 rrsoL11ére il prohl-ema ~u im corn.pt~te1; e che s.m.vere. lo pseudoc(}t/u;e serpa so/o a nttt:rt/d.re la prod~t.:§ione dei risult:_ati ji11'f1./,j,
dove opt1,atore. sia un.o degli ope',ra:tori binar.i +, - , *, / o % (ò a.Itri cli cui discuteremo nel
/ * chiusuf a con sucsesso }
Enit~f'! re'S~l,t (!1=f>YalS-'S,2:-taii) : rie su u (l =e-ts~ , 2:otail )': 2 Ent~H' r~!J.l::t (· 1=-~sis , 2=-kll).: 2 Erl~~r t'e.~W.1 (1=pa:s---s, 2=fai1): i Erfter res:i.11~ (1=p'8'ssJa=faai) :
fili~e t'
6fi'1!~1' r~U-J;t (1:'1)a;&si;i 2=fl&il.) I 1
~1
'Capr_roJo 10). po_trà essere scritta J1.eHa focma ililrìabi/e. opi!ttttortt~?SptéSsioiJi; Di conseguenza l'a.sse_gnamenro e += 3 aggiungera 3 a c. L;:i 'Fi'gura 3.11 mostra gU operawr1 a r iun ç;~ici di assegnamento, alcµne ·espressioni di èseinpio che li urilinano e Je rela:.cive spiegazfoni. Operatore di assegnamento Assume~ç:
int e = 3,
Espressione
di esem,pio
Spieg~.ione
Assegna
=
12j
= e
+ 7
4
d = d
4
1 a d
e * == 5 t /= 3
e = e
5
2~
'/=
f = f I 3
\=
g %= 9
g
d = 5, e = 4, f
2
+=
e += 7
·-
d
·( f.=-pa~, 2=fta~l) : 2
*=
~ Ente.r r,ts~lt ;{1=p~_$,2=1"@.-jl): 1
.Pl;$-l;J4'0 6 Fa.11:~1' 4
Figura 3.1 O Il programma C e lè. esecuzioni di esempio pér il problema del risultati ·dell'es;;imé.
·Eòperaw[e +~aggiunge il valere ddl'e$pressiooe alla destra ddl'0pera~9re alla var1abile alla sua sin.isrra, Ìlnmagazzinf.Ilclq il ris.ultato in quesr'itlcim.a. Ogni istruzion.e deLlà forma
print:f .("Pass.ed %d\n'1 , prl ntf( "Fàile9 %,ç i\n",
Ra Ì.1:5"eJ
Il C fornisce divers.i oper~tQri di ass~gnaincnto· pç:cr a~brèviare ç~pio, L'isn:uzione e e + 3;
+ 1;
= failures· + 1;
= student +
1
P,à-SS.eCl 9 P&fle,d 1'
irit passès
/* !llabera 1 0 studeni;j,.; ciclo controLlatd da un c.oh'tatore *I ivhil~ (student <= 10) { printf (•Enter result ( 1==pas·s 1 2=fail) : " ) ; scanf("%d", &result); ìf .(r!Jsult = 1) /* if/else nidificato nel wlìile "/
r'.è.sUlt (1<="~8:S·S,~"ll;l;;f:ail) :
-=
6, g
e
= g
Fi_g ura 3. 11 Gli operatori aritmetici di assegnamento.
*
'
9
10 a e
ae
2 a· 'f 3
a g
70
CAPITOLO
Lo SVILIJPPO 01 PROGRAMMl SrRlflTURAII
3
JJ. programma visualizzerà il valore di ·e prima e dopo l'utilizzo deJl'pperatore ++. I.;pperatore di decremento ( - ) funziona in modo simile.
Obiettivo efficienza 3.2 Una i.sfTIJ.ZÌone che utilizzi tm operatore di assegnamento (come in e += 3) sarà compilata più velocemente del siw equivalmte nelltt forma estesa (e = e + 3),_perché la e della prima espressione tarà valutaia soltanto una volta, mentre quella della seconda es-pressione sarà 1;alu.tt1.ta due volte.
Obiettivo efficienza 3.3
/ * Preincrementa re e postincrement are */ #include I
111ain ()
~
{
int e;
Molti t/ei sur,gerimenti che menzùmiaino in questo libro producono dei miglioramenti irrisori, perciò l'utente po'trebbe mere tentato di ignorarli. In realtà, sarà proprio L'effetto cumula.tivo di httd questi miglioramenti di pm·t~ioni ahe consentirà unti eseéuzione significativammtepiù rapida del programma. Un incremento ri'fevante dell'efficienza sarà rfalizzato, inoltre, quando 1111migliornmento1tpparen:temmte in-iforìo sarà stato inserito in rm ciclo che potrà essere riper:uto un gran numero di volte.
3. 12
I,
71
o = 5; pri ntf( "%d\n", e) i printt( "%d\ n", e++); printt( "%d \·n\n'1 , e) i e = 5; printf( "%d\n", e) i pr intf ~"% d\n",
Gli operatori di increment o e di decremen to
Il e forn isce anche l'operatore di incremento ++ unario e l'opera:tore di decremento - unario che la Figura 3. 12 riassume. Qualora una variabile e debba ess.ere iocremenraca di I, pou:à e~sere utilizzato l'operatore di incremenro ++invece dell'espressione e = e + 1 o e += 1. Quando gli op.eratori di increm·emo o di decremento sono sis[emati prima di una variabile, si dicono risperrivamente o-peratori di preincremento o di predecremento. Quando gli operatoci di incremcruo o di decremento sono sistemati dopo una variabile, si dicono risperrivamente operatori di postincremenro o di postdecremento. Il preincremento (o il pc.edecremento) di una variabile provocherà in primo luogo l'incremento (o il decremento) di una unirà della variabile e, in §~guito, i1 nuovo valore della va:riabl le sarà utilizzato nell'espressione in cuì
Spiegazione
++
++a
lncremenca a di 1 e quindi ucilizza il nuovo valo re di a nell'espressione in cui essa occorre.
++
a++
Utilizza il valore wrre.me di a nell'espressione in cui essa occorre e quii;id.i incrementa a di 1.
-b
Decremenra b di 1 e quindi ucili:zrla il nuovo valore di b nell'espressione in cui essa occorre.
b-
Uciliz.za il valore correme di b nelfespressione in cui es~a occorre e quin:di decreuienta b d i 1.
t +c);
!* prein oreme nto • /
printf{ "\d\n", e);
return 0;
t • chiusura con successo * /
5 5 6
fi Figura 3. 13 Mostrare la differenza tra il preincremento e ìl postincremenco. ~
~
Buo.na 11bit1tdln.e 3.10 Gli opemtol'i ima1i devono essere sistemati direttamente n ridosso dPi loro operandi, senza l'int1'omi.ssione di spazi.
Le rre istruzion i di assegoamenro della f igura 3 .10 passes = passes + 1;
1, 1
Figura 3. 12 Gli operatori di incremento e di decremento.
Il programma della Figura 3.13 mostra la differenm era la versione di preincremenro e quella di posti:nG!émento dell'operatore ++. Il postinc:remcnto della variabile e prqvocherà il suo incremenco, d0po che la stessa sarà st:ara u~ nella istruzione print f . Jl preincrememo della variabile e provocherà il suo incremento, prima che sia utili:z.zaca nella..ist:ruz:ione printf.
I* p.ostin cremente * /
11
fa i lurés = failures + 1 j st udent = student + 1i
porranno ~sere scritte in modo più conciso utilizzando gli operatori di assegnamenro, çome in passes += ·1 ; failures += 1 i stud ent += 1; o con gli operacori di preincremenco, come in
1:
++passes;
li
++fail ur,es i ++student;
UJ1LT01.0
71
3
Lo SVILUPPO ()I PROGRAMMI STRUrrURATI
73
o con gli operatori di postincremenro, come in
Esercizi di autovalutazione
passes++; failures++; student++;
3.1
È imporcance notare in questo caso che, quando sì incrernencerà o si ~ecre~encerà una
variabile in una istruzione isolata, la forma di preincremenco e quella di posnncrememo avranno lo stesso effetto. Il preincrememo e il poscincremenm avranno effetti differenti (e, iIL modo simile, anche il predecremcnro e il poscdecrçmenco), solo quando una variabile
b) I.:indicazione dell'ordine: di c:.secuzione delle istruuoni da parce dd compmer è detta e)
è urilizzara per l;S\!guire una azione, qualora una d) La. struttura dJ selc-iionc condizione sia vera, e un'altra azione qualora qui:lla qmcfu.ionc sia fulsa. e) Molte istru1.ioni raggruppare all'inrerno d.Lp:arem~i graffe ({ e }) form:ino un - - - - specifica che una isrruzione o un loro gruppo () La struuura di iterazione dovrà cssel'c eseguico riperuramente, finch~ w1a cerca condr1.ione re.scerà vera. g) I.:ite.ra.zionc dj un insieme tli iscrut.ioni per un numero specifìcaro cli volte è derra iterazione
Come operando di un operatore di incremento o di decremento, porrà essere ucili,zato sQlo un semplice nome di vaciabiJe.
Errore tipico 3.1 O
Tent11re di tttilizzan: L'operatore di incremento o di decmilento iri una espressione di11ent1 da un semplice nome di 1.11ttùtbile, iwaltreparole, scrivere ++ ( K + 1) è un errore di sintassi.
h) Quando non è noto in anticipo il nu mero di volte che un insieme cli i$truiioni sarà per terminare l'Iterazione. riperuto, potrà essere udli1,wro un v.:ilorc
Buona abitudine. 3.11 .ltJ staruia>dANSJ generalmente non specifica l'ordine in cui s'(lranno valutati gli opertmd~ di un opemwre (anche se mi Capitolo 4 vedremo delk eccezioni a questa 11orma, per al.cum operatori). Di consegumza, ii programmatore dovrà evitare di utiur.zare delle istruzioni, con operatori di incremento o di decremen_to, nelle quali una particolare variabile, che sia stata incrementata o decreméiltara_, compaia pii't volte.
3.2
-=. •:::,
ra 3.14 associano da siniscra a destra. Operatori
Assocjatività
Tipo
( )
da sinis.rra a destra
parentesj
da descsa ·a sinistra
unaci
da sinistra a des-rra
molci plicatlvi
*
%
(tipo)
da sin istra
+ <
<=
>
>=
l=
?: +=
--
·=
/:::
%=
a destra
addirivi
da sinisrra a destra
relazionali
da sinistra a destra
di uguaglianza
da de5tra a sinistra
condizionale
da desrra a sin:isrra
di assegnamento
Figura 3.14 Priorità degli operatori incontrati sinora nel libro.
Scrìv.ete quanro dilTcrcnri istrui.ioni in
e cbeaggiung.auo 1 alla variabile incera X.
Scrivecc un:i singola isrruzionc in C per eseguire ognuna delle artivicà scguenri: a) Asscgrme la somma clix e cli y a z e incrementare il valo·rc di x di 1 dopo il calcolo. b) Molripli01re la variabile product per 2, utilizzando l'opcracorc *=. c) Moltiplica.re la variabile product per 2, utilizzando gli operacori =e *. d) Controllare se il valore della variabile count è maggiore cli rn. Nel caso lo fosse, visualizzate "Count is greater t han 10 •. e) D ecrementare la variabile x di I e quindi sottraerela dalla variabile tot al. f) Aggiungere la variabile x alla variabile total e quindi decrememacc x di I. g) Calcolare il resto della divisione cli q per dìvisor e assegnale il risulcaro a q. Scrivere quesra iscruzione in due modi diversi. h) Visuali1,zacc il valore 123. 4567 con 2 cifre di precisione. Quale valore sarà visualiiz.aro? i) Visualizza ce il valore: in virgola mobile 3. 14159 con tre cifre a desua del punro decimale. Quale v;ilore sarà visualfaiato?
La tabella in Figura 3.14 mosrra la priorità e l'associatività degli operatori incrodo~ sino a q uesto punto. Gli operatori sono mosmui dall'alto in basso in ordine decrescente di priorlcà. La seconda colonna descrive l'associacività dçgli operatori a ogni livello di priorità. Osservace che l'operatore condizionale (?:) , quelJj unari di incremento ( ++), decremenro ( - ) , adciiz.ione ( +) , socrrazione ( - ) e di conversione, noncbé gli operatori di /=e %= associano da desua a sinisua. La tena colonna assegnamento=, +=, assegna un nome ai vari gruppi di operatori. Turci gli akri operatori presenti nella Figu-
+·
Turri i programmi possono essere seri rei in termini di rre srrmrure cli conrrollo: ----~
-----e-----
apparirà in una espressione più grande.
+t
Rispon
a)
3.4
Scrivete una isrruiìoae C per eseguire ognuna ddle seguemi acrivicà. a) Dichiarare le variabili sum ex di lipo int. b) laizializzacc la variabile x con 1. e). lnizializzacc la variabile sum con 0. d) Aggiungere la variabile x a sum e as~egnace U risultato a quesr'ulrirna. e). Visualim.atc "The sum is: " seguico dal valore della variabile sum.
Combinale le iscruzioni che a.vete sc;;ritto ncll'Eserci1,io 3.4 in un programma che calcoli la somma degli inleri da l a 10. UciJizzare la srrumtra while per iterare lé isa·uzioni cli calcolo e di incremento. li ciclo dovrà rcrrrunare quando il valore di X divèmerà uguale a l L
3.5
Decenninare i valori w ogni variabile dopo l'es~onç del calcolo. Supponere che tutte le variabili abbiano jl valore 5, quando ogni istruzione cominf;e.rà la propria esecuzione. a) product •= x++; b) result = ++x + x;
3.6
74 3.7
CA!"ll'Ol.O 3
Scrivere una singola istruzione C che a) Prenda in inpul la variabile inrcra x con scanf. b) Pren.da in inpur la variabile inrer:i y con scanf. c) Inizializzi la variabile inrera i con 1 . d) Inir.ializzi-la variabile incera power con 1. e) Molriplit bilayariabile powe r per x e assegHi il risuJcato a power. f) Lncre11len.ti la. variabile y di 1. g) Concrolli y per verificare se sia inferiore o uguale a x. h) Visualici la variabile intera power con printf.
Lo SVLLUPP() DI PROCRJ\MMI STRUITURl\Tl c) SUl\I = 0j d) sum += x; osum = slJJll + x;
e) printf ( ' The sum is: %d\n' , sum);
3,5
t · ca1oola la somma degli interi da 1 a 10 · I #include main() {
int sum, x; X =i j sum =0; wtlile (X <= 10) { sum += x ; ++x;
Scrivete un programma e che ucil.ini le ismriioni ddl'Ese.-ci2.io 3.7 per calcola.re X elevata alla poumza y. li programma dovra conce nere una ruucrura di controllo cli iccraiione while.
3.8
3.9
ldcmifìc:ue e correggere gli erro ri in ognuna delle segut:nti istruzioni:
a) while (e
<= 5) {
product
++e;
•= e;
prJ.ntf( "The sumis: %d \ n', sunl); }
b) scianf( "%.4f", &value); e) if (gender = il printf ( "WOman\n') ;
3.6
3.10
3.7
D ice cosa a:on va nella segucnccsrrurru.rn di icerazione while:
while (z >= 0) sum += z;
Risposte agli esercizi di autovalutazione a) i\lgotl.rmQ. b) ®ntrollo di programma. e) Sequenza, selezione, iccraiione. d) i f I e.lse. e) Istruzione compesra. f) while. g) comrollata da un contatore. h) Scnrinclla.
c) product =prod!lct " 2; printt·("Count is greater t nan 10. \11• )..;
while (i<=
e) total -= -x; f) total += i;<- ; g) q 9s= divisor; q = q % divisor;
power ++i;
•=
y) {
x;
printf(''od', power);
return 0;
b) printf( ' %.2f", 123.4567);
}
è visualiizaro 123, 46.
a). 1,nt surn, x~ b) X= J;
=, i
pOl'1er
g)
d) if (oount > 10)
3.4
l.
power •= x; y++; i.f (y <• x)
z = x++ + y;
printf['%. 3f\n" , 3.14159); h isuali:z:z:ato 3, 142.
scanf( •\d•, &xl; scanf( ' ll'D • , &y);
a) b) c) d) e:) f)
b) product ..=2 ;
i)
=25, x = 6;
=12, x =6;
3.9
n) Errore: manca la p arcnrcsi graffa cli chiusura per il corpo della while. Correzione: aggiungern la parentesi graffa di ch iusura dopo l'is:rruzione ++e; . b) e rrore: è srata uri.lizzara la precisione nella specifica di conversione dl una scanf. Corrc~ion e: rimuovete il . 4 dalla spccirica di conv~r.siomt.
75
76
W
ITOLO
3
LO SVILUPPO DI l)ROGRA.MM I,STRU'ITUl'tATI
77
int x = 1 , total = 0, y;
c) Errore: il punto e virgola dopo la parte else della smurura i f /else produrrà un errore logico: la seconda printf sarà eseguita sempre. Correzione: rimuovete il punto e virgola dopo I'el se.
while (x <= 10) { y :o X • x; prir1tf( ,.%d\n~,
"valore deJl3 variabile z non sam mai modìficaro all'imemo dellasrrurrura while. È staro quindi crearo un ciclo infinito. Per evitare il ciclo infìniro, z dovrà essere decrementata in modo da assumere, ad un certo momcnco, il valore 0 .
3. 1o
y);
tot al +:o Yi
++x;
printf("Total i s \d\n•, total); re.turn 0;
Esercizi Jdencifìoce e correggete gli errori in ognuna delleseguenà imuz.ioni (Nota: porrà esserci più di un errore in ognuno dei pez2i di codice): a) if (age >= 65); printf("Age is greater than or e~ual to 65\n"); else
3.1 1
3.14
Scrivere una singola istruzione in pseudocodice che eseg_ua ggnuna delle seguenti azioni: a) Visualizzate il messaggio •Enter two numbers •. b) &segnate a p la somma delle va.ri:ibili x, y e z. e) La seguente condizione dovrà essere concrolhtra in un.a sm.mura di sd enone if I el se: il valore corrente della vari:ibile mè maggiore del doppio di qudlo:comenmo nella varjabile v? d~ Octenece dalla rasciera dci valori pe~ le v;u:iabili.s, r e t.
~.14
Formuface un algorirmo in pseudocodice Ber ognuna delle seguen:ci anivim: a) Otcenete due numeri dalla rasciera, calcolarene la somma e visualizzare il risultaro. b) Ocrenere due nwueri dalla casticra e quilldi dcceaninarc e visuali.zzate il maggiore dei
pr.1,ntf('Age 1s less than 65\ n');
b) int x = 1, total; While (X <= 10) { total += x; ;+x;
e) While (x <"' 100) total += x;
++x;
d) while ( y
> 0) { pr.iiltf( ''t!d\n•, y);
-Hy; }
3.11
Riempire gli spazi in ognuna delle &asi seguenri: a) la soluzione di ogni problema richiede !'~cm.ione di una serie di azioni in un _ _ _ __ specifico. b) Un sinonimo di procedura, è _ _ __ c) Una variabile che accumula la somma di diversi nume~i è u n - - - - d) 11 processo in cui si impostano certe variabili cqn dci valori specifici all'ini1jo di un programma è detto - - - - e) Un valore speciale uriliu.aco per indicare Ja ufuie della immissione dei daci" è dccro valore
- -- - - o - -- - è una rappreseucazione grafic;i di un algorim\o. f) Un g) la un dla.gramma di Bussb, fordi.ne in cui dovranno essere eseguici i passi sarà indlcatc:i dai simboli di _ _ __ di ogni algodtmo. ~ la h) li simbolo di teaninai,ione iodica l' i) li simbolo rctta11golo corcisp9nde ai cakoli, eh~nor:tnalmcnte saranno eseguiti dalle istruzioni _ _ _ __, e alle operazioni dj inpuc/ourpuc! cb:e normalmente saranno eseguite dalle de.Ila libreria standard. e chiamate alle funzioni ì) J.:demenco scrirro all'interno cll un simbolo ~ decisione è dcrto _ _ _ __
3.13
Che cosa visualizzerà il seguente programma? #include main() {
due, se c'è. c) Orrcnece una serie di numeri posirivi dalla casc.iera e qui11di decerminare e visualizzate la loro somma. Supponete che l'uceme immecca il valore sentinella -1 per indicare la "fine dcU'immissione dei dari". 3.16 Scabilfre quali delle seguenti affermazioni sono vere e quali sono fulse. Qualora una alfermazion~ sia falsa, spiegacene iJ morivo. a) I.:esperienza ha dimoscrato che la parte più difficile ~lla risoluzione di un problema, su un compuccr, è la produzione di UD progtamma C funzionante. b) Un valore sentinella dovrà essere tale che non possa essçre confuso con un valore legiràmo per i dari. e) Le linee di flusso indicano le azioni da eseguire. d) 1.e condb.ioni scrirte all'iucemo dci simboli di decisionç çonn;I)gono sempre degli operacori arinnecici (ovverosia+, ·, • , I e %). e) Nd processo cop down per raffinamenti successivi, ogni rnffinamenro è una rappresencazione compleca dell'algoricmo.
Per gli Esercizi daJ 3.17 al 3.21 , eseguite ognuno di~uèSti i;iassi: l. Leggere ·l 'enu o cia~ione dcl problema. 2. Foun ulate l'algoritmo usando I.o pseudoéodi'ce e il proces.so rop down per ràffìn ttmenti s.u.ccessivi. 3. Sèrivctc un programma C. 4. Collaudàre, mmote a punto ed eseguire il programma C. 3.17 A.causa dell'alto prezzo della benzina, gliautomobilisciso_i;iointeressati alnumero di chilomerrj percorsi dalle proprie aucomobili. Un aucomobilìsca.bamanccnutQ traccia di diversi pieni di beniina, !egisc:rando i chilornecà percorsi e i liLri uùliu.ari per ogni pieno. Sviluppare un programma che prenda ininput i d1ilometri percorsi e i lirri utilizzati per ogni pieno. Il programma dovrà calcolare e visualir.zare i chilometri per litro orrenuti da ogni pieno. Dopa aver elaboraco rurce le informazioni in input, il programma dovrà calcolare e visualizzare anche i chilomecri per liuo ottenuti complessivamente da rurri i pieni.
e
CAr1ro1 0 3
78
Lo sVJLu r1c>0 or PROCRAM.Ml STRmTuRJrn
Enter the gallons 1,1sed ( ~ tltci entl) : 12. a Enter the miles driven: 28T The miles / -@!on tor tnis··tank was 22.421875
Enter·saies in dollars (·1 to end): §00,0.00 -
Sa1afy is: $650. 00
Ent-er r~es in dellal's (-1 to end). : t"234-. 56 Salary fs: $311 . 11
Enter the gallons used ( · 1 t0o end) : 10. s ~tef:th.e tfiil~s Qll'±ven: z~ The miies I g_1Ìlloh fo.r th'is.:ttank Was 19.'4q1747S
enter S'ahlt in .dì:ll.14l'~H SiiliJr~ is: $298. 00
Enter tlle g_illons used ( -1 tQ end): 5 Enter tfle Aiiles driven: 1~ Tlle miles I !lalion tor this tank was 24. ·000000 Enter the :gatlons used ( -l to eni.t) : •1
3.18 Sviluppate un programma C, che detemuni se il clience di un grande magazzino abbia superato il limice di.a;edico sul suo com o. Per ogru cUtnre saranno disponibili i scguemi dati: I . U numero di como 2. Il saldo all'inizio del mese 3. Il cotale di rnrri gli articoli che il clicme ha messo in como. durame il mc:Se corrente, 4. li totale di curri i credici applicati al corno di questo dieme. durance il mese corrente. 5. li Limire di credico concesso Il prqgram rna dovrà prendere in input meri quesù daù , cnkol:1re il nuovo saldo (= saldo iniziale + ardc::oli messi In cciilro-ctediri) e dereaninare se il nuovo saldo super.i il Limi ce di ereditò del dicnic. Per quei dicnri d ie avranno su peraro ilJ1m ire di credito, il programma dovrà vjsualizz.'lre ilJoro numero di. com o, il limire cU credito, il nuovo saldo e iJ messaggio "Credit limir exceeded". Enter abeo1,1nt
3.20
l:interesse semplice ~u un mutuo è calcolato dalla fo rmula rate
t
days I 365
'alter dean prino1pal ( •1 'l:o ènd) : 1:000 .00 Ent-er ~terest ratè: .0Q375 Enter 'term of the lOC!ll in days: 224 The i.nterest charge i& ssi .400
Enter 1-11$1 pr:i.noa.pal ( •1 te end) :
10000...00
Entar ~ere&t riat-é: :• En(-er term Of ttie loan in days: 1460 The inte,,est charge iS S3600.00
Enter J.oan principal ( · 1 to end) : · 1
i
Enter total cba1•ges: 274,73
~
Enter loan principal ( ·1 to end) : 1000 •.0'0 Enter ioterest raté: .1 fntep unn of the roarr in days: 385 The mterest oharge is $100.00
Enter tòta1.,~r'ècli.ts': 500'.00· Enter credi.t lì.mit: 5500.-~
Enter account number ( -1 ilo end): 300 Eniter beginhing balance: 500 .00
= principal
precedente.
Enter bei~o:fOg bahlni:e: s394 .18 Ei:iter tota[ oharges: 1:000 00
Enter aceeunt number ( ·1 to'.;end): 200 -enter beginning balance: ~000.00 Entertotàl oharges: 12:3.45 Enter total credits: 321.00 Enter gr~ér,$! lìmit: 15~.~
1~8. 89
La formula precedente presume che rate sia il ra.~o di interesse annuale e quindi include la divisione per 365 (giorni). Sviluppare un progmmma C che prenda in inµur principal (e!picale), rate (r:isso) e days (giorni) per dJversi mmui e visullJiz1.i l'in:reresse semplice per ogni muruo, acllizzando la foa:irnb
Sviluppare Ull programma e che
da, per le prime 40 ore lavorare da ogni impiegam, paga il "salru:io òrario di base", .men:rre per rurte le ore lavorare in aggiunra alle 40. elargisce "una volra e mezza il salario di òase". Vi sono scarifumiri: una.lista degli impiegaci dell'azienda, il numero di ore lavorare.da ogni impiegarò nell'ultima settimana e il salario orario di base di. ogni impiegaco. Il vosno programma rker ($00.00): 10.00
Enter-tota! credits: 100.00 Enter crflàit l:i,lnit: 800.~
salàcy is S390. 00
Enter a'<:l~ur:ft,nqmber ( ·1 -te el'!d): ·1
Efite'n ff~J:JPLY rate.,n f ~he wor.l
Una grande industria chimica rerribuisce i :propri vcn
Enter
~- of
tiours worklk'.d H
~o
erio):
4~"
3.19
EnteP:it of hours worked ( ·1 to end): 41 EJtter h.o urly rate Of'' the 1110r1
Enfor, 4f of tiours Wt>rkeèl ( • 1 to end) : · 1
I
CAPITOLO
80
3
int oount = 1;
Scrivete un ·prog:mmma Cche dimosrri la differenza cr:i il pcedecrcmenco e il posl
3. 2~
while ~count <= 10) l pr intf( "%s\n', count % 2 1· . ........ ,
3.23 Scrivere un programma ç che utilizzì un ciclo_, per visualizza~e i numeri da I a IO alìa.nco a fianco sulla ster: l argest: il nwncro pili grnnde rrovaro sino a questo p.uoto. 3.25
.Sccivecc un programma ç d1c urilizù un ciclo per visualiz7.are la seguente cabclla di valori: N
10-N
100'N
1
10
100
2
m
~
~
31?
300
40
400
SI)
500 600 700 800 900 1000
81
Lo SVlLUPl'O DI PROGRAMMI STRlJJTUR.>\TI
'++++++++");
++count;
return
3.30
~;
Che cosa-visualii.zerà il seguente pragrnmma? #include
~ li c:arattcre di ra bulaziooe, \ '1:, peù.à. e,~s'ere u ciliz~.:im nèll_a iscruzicmc pdntf·pèr s~par:u:e le colo.bne i::On 1~
r
delle tabulazioni. 3.26
Scrivere un programma ç che ucillu.i un ciclo per produrre la seguence tabella di valeri: ~
A
At2
A+4
~
'S
s
7
9
~
8
10
12
9
j1
15
12 15
1~
13 16 19
17
18 21
3.27 'Frovace i due numeri maggiori era IO valori, usàndo un approccio sìrnile-all'.Esercizio 3.24. Nora: porcele prendere in input ogni valore soltanto un:i volta.
3.28 Modificace il programma della Figum 3.1 O, i.n rnç;4o da convalidare l'ffipuc. Rei cera.ce su ogni input, qualer-a.il valore: imtne.i;i;o fqss'c dlvers() tla I o da.2, finché l'mence non immcma un valore corFetto. 3.29
Che cosa visualizzer.ì_il seguente programma? l#incl.ude .;std10. h> main() {
3.31 (Problema deil'else appeso) Dccermirrace l'output d'ognuna delle scgLtenà istruzioni quando x è 9 e y è 11 e quando x è 11 e y è 9. Osservate che il compihMre ignora i tiemci all' inremo di un programma C. llcomp .ilarore e inolrre as:socer~ sempre. un !!lSe all'if precedente, sempre che non gli sia stato derro di fue :ùrrimenLi. ama.verso la dìsposiiionè ddleparenresi graffe { }. Daro che, a prima vista, il programmatore non può es~ere sicuro ddl:i corrispondenza di Ull else con un i f , questo problema è defìnico "dcll'dse appeso". Abbiamo eliminaro i rientri dal codice successivo, per rendere più inccressame il problema. ($u.ggerime.mo: applicace le convenzioni dei rientri che a.vece appreso). a) if (X < 10)
if
(y > 10)
printf( "**"'• ..\n" l;
e1Se
pr inrt( ~#####\n 1' l; printf( '$$$$S\n'');
b) if (X< 10) { if (Y > 10) printf('*•~•\n'li
} eise {
printf ( "###11#:\n• ) ; pri ntf("$$$$$\n"); }
3.32 (Un alrro problema dell'else appeso) Modi1ìcace il codice seguence in modo che produca l'outpur mostraro. Ucilir.lacc le cecaiche di riemro appropriace. Non pocrece cscgLLire..alue modifiche
82
CAPITOL03
che non sia110 degli inserimenti cli parentesi graffe. li çompilarore ignora i rienrri in un programma C. Abbiamo eUminato L rientri dal coclice seguente, per rendere più 1meress;1nre il problema. Nora: è probabile che non sia necessaria alouna modifica. if (y = 8) if (X _:_ 5)
rio" una per volta da de~-rra a sinisrca, u:ti.Li7.zate gli opemrori di divisicme e dl modulo. Nel siscema numerico decimale, la cifra più a dèscrà h;t un valore posiz.ion;tle di I e quclle che si susseguono a sinima hanno un valore posiaionale di lO, poi '1 00, poi 1000, ecc.; it.llo stesso modo, nel sistema numerico binario, la ci.fu più a descra ha un valore posizionale di 1 e quelle chç si susseguono a sinistra banno un valore posii.ionale di 2, poi i. poi 8, ecc. Di conseguenza il numero 234- pocrà essere inccrpretaro come 4 • I + 3 ' 10 + 2' 100. l.:cquivaJcnre decimale del binario 1101 sarà I • I + O • 2 + I • 4 + I • 8 o l + O ~ 4 + 8 o 13). 3.37 Sentiamo p;tclare spesso dj quan.co sian.o veloci i computer. ln che rno tJOtece dt.!rerm lnarequa11to è rea,l1nc11 te veloce l:i voscra m acchina~ Se.rivere tLn programma con 'Un dclo while chcconri uno per volta da 1 a 3.00().000. Ogni volra che il conto raggiungerli un mulriplo dj 1.000.000, visualizzerete il numero sullo schermo. Ucilizziae il vomo orologio per misurare il cempo impiegaro da ogni milione di iterazioni :ùl'inremo dcl ciclo. 3.38 Scrivere un programma che visualizzi J 00 ascerisch.i uno per volta. Ogni dieci asrecischi, il vostro programma dovrà visualizw.re un ca ratte.re newline. (Suggerirne.neo: concare da 1 a I00. Usate l'operatore di modulo per individ'ua.r:e rurre le volte che Il comarore raggi unge un mufr:ipl.o di 10).
3.39 Scrivece un programma che le&,oain.iaput un incero c. inseguito, determ in.i e-visualizzi quami 7 sono compresi nelle cifre dcll'inrero.
J
3.40
• • • • .-- ... .. '*
..
,_,
[I._ _. . = :=~---------] 3.33 ScriYçce un programma che legga in input illaco di un quadraro e quindi lo disegni uci l iu~1ndo degll asteris_chi.11 vostro programma dovrà funzionare _can runi i quadrati con dilrn:nsioni dei lari comprese tra 1 e 20. Per esempig, se la djrnensione !erra dal vostro programma fosse 4, dovrebbe: visualizzare:
l
vosuo
.
.. .
..._
Il vos1-ro progran:umt porrà utiliz1.are solramo ere istruzioni printf: una della forma pri~tf( ' • "); una della forma prirrtf ( • •) ; e una della forma
printf( •\ n") ;
visu•Ji,rncj·
Scrivete un prog.r;rnuna che contin_u.i a visualiizare i multipli dell'incero 2, ovverosia 2, 4, 8,
16, 32, 64, eec. Il vostro ciclo non dovrà J.lll!:i terminare (dovrcce insomma cre-.t.re un ciclo infìnico).
Che cosa succede.cl quando eseguirece qnesro programma? ~ ..
.
3.35 Un palindromo è un numero o una fr.m~ di resto che. da sinistra a desu:a o da desrra a sinistra, si legge nello Hesio modo. Per esempio, ognuno dei seguenci in ceri di cinque cifre è un palindromo: 1232 l, 5555'5, 45554 e !1611. Scl:.ivete un programma che legga in input un lnrero di ci nq ue ci&c e determini s~ si tratta o nò di un palindromo. (Suggcrimemo: per scindere iJ ownero nelle sue singole cifre, uriliv.ace gli opemrori di divisione e di modulo).
3.36
.~
.. • .. .. .... * • ' ...... . '* ...
3.4 t [
,.. ~
,.. ~
* ... "' ...... * *
Modificate il programma che avete serino nell'Esercizio 3.33 in modo che visualizzi un qua~; « J, dimc.,,;onc lca> d,J programm• """ 5, ®"'bbe
vuf •;'."
Scrivete on programma che visualizzi il seguente diseg!lo di una scacchiera:
.. . . . " .. "* " "" * "' .Jr* ... -- ....
d) Assumendo x = 5 e y =7, sarà prpdocto l'ourpuc seguente. Nora: le ulrime ere printf sono mere parei cli un'istruzi-Ooe composta.
3.34 dn
83
Prendere in inpuc un incero corueneme ~oltamo degli O e degli I, ovveiosla un incero "binario", e visualizzare il suo equivalente decimale. (Suggerimento: per prebiare le~cifre del numero "bina-
3.42 Scrivere un programma che legga il raggio di un cerch.io (come un valore di cipo floa:t) e quindi calcoli e vism1Jl?:7j il diametro, la circonferenza e l'area. Utilinare il valore 3.14159 per te. 3A3 Cosa .non va nella seguente ibtruz.ione? Riscrivere l'ib-:rmziqnc in modo che esegua quello che probab iI111 ence il p·rograJilmato re stava rnatando di ocre.nere. printf ( ' %d' , ++(x + y)) ;
3.44 Scrivere un programma che legga in inpur tre valori di c:ipo float diversi da 1.ero e, quindi, determini e visualini se possono r:ippresenrarc 1 laà di un triangolo.
CAPITOLO
84
3
3.45 Sccivecc un programma che legga in inpur rre inc:erl diversi da zero e, quindi, determini e visualizzi se possono essere i lari di un triangolo r~ttangolo. 3.46 Una azienda vuole rrasmerterc: dei dati sulla line;i. telcforuca, ma i suoi responsabili sono preoccupari dal facto che i propri cdefoni porrebbero essere spiaci. Trnci i loro dac i sono trasmessi come inceri di quamo cifre. Vi h:inno quindi chiesco di scrivere un programma che crirrografì i loro dari io modo che possano essere rmsmc:ssi con maggior sicurezza. Il vosno programma dovrà leggere un inreco di quamo cifre e crittograF.ufo nel modo seguente: sostiruice ogni cifra con (la somma di quella cifra pit1 7) modulo 10. 111 scguiro, scambiare la prima cifra con la cerza, e scambiace kt seconda cifra con la quana. Visuafo.7.are quindi l'incero crirrografuto. Scrivere un programma a parre 'Che prenda in input un intero crinogrtifaro di quamo cifre e lo decifri, in modo da formare il numero originale.
3.47
nfattoria.le di un intero non~ neg:u:ivo
l1
CAPITOLO
Il controllo del programma Obiettivi Essere in grado di utilizzare le srrutnu:e di iterazione fo r e do /while.
si scrive nl (pronunciaco "falforiale di n") cd è defìnico
come segue:
n!
=11 ...(11- 1
11!
=
1)
•
~11-
(per \•;ilpri c!i 11.m~ggiori o uguali a I)
2) ...• · I
• (pe.ii
t
Il=
I 2!
I 3!
e=I+-+-+-+ ... c) Scrivere un programma che approssimi il valore di , urilizz.ando la formula
J- ~ X e" =l+-+-+-+ ... l! 2! 3!
;
Comprendere la selezione multipla, u.tilìnaodo Ja.strucru.m di scle7.iooe switch. Essere in grado di utilizzare le isrruzioni break e continue per il conrroUo del program.ma. Essere in gr:tdo di utili:u.1.re gli operat ori logiei.
O).
Per esempio, 5! =5 · 4 · 3 · 2 · l che è 120. a) Scrivere un programma che legga in inpm un lorero non negativo e quindi calcoli e visualizzi il suo fattoriale. b) Scrivere un prognunmacheapprossimi ilva.loredeUa cosmmemaremaàca e, ucifo..z.ando la formula: I I!
4
4.1
Introduzione
A questo punro, il !errore dovrebbe essere a proprio agio .è on il processo d i scrimira cJj un semplice ma completo programma C. In questo capitolò, sarà tr:rrtara più derraguat:unenre !'ire.razione e, nello sresso rempo, saranno presentare :llrre srrurru:re cJj controllo per qoe~i:'ul cima, ovverosia la Struttura for e quelb do / while. Sarà imrodorra anche la srrurcur:i. di selezione multipla swi tch. Discureremo della istruzione break, per uscire immcruacamcnce e rapidamemc da certe srrurrure di controllo, e deUaiscnrzione continue, per ignorare la parre rimanemc dcl corpo di una srrum1Ta di iterazione e procedere con la successiva ire.i-azione del ciclo. Il capitolo ruscucerà inoltre degli operatori logici utilizzaci per combinare fra loro le condÌ'Lioni e, infine, concluderà con un riassumo dei principi della pl'ogrammazìo.ne smmuraca presemad nel Capirolo 3 e nel Capitolo 4.
4.2
Gli elementi della iterazione
I.a maggior parre dci programmi rich iede delle iceta?.ioni o cfrli. Un ciclo (/.Qop) è l Ul gruppo di Ì!!tnrLÌoni die il computer csc~tlrà r iperutamente, fì nc.hé una «.na crmdizio11e di cqnrin.utizi'<>ne del ciclo rimarrà vera. Sinora abbiamv discusso cli du~ ci ~JÌ di iterazione: J . .eicera.zione conrro1lara da un contatore 2. I:iceraz.ione conrrollaca da
Wl
valore sentinella.
J;iterazione concrollara da un contatore è derra a volte iterarione definita, perché conosciamo esanamente in andcipo il numero di volte che il cjclo sar~ eseguito. !.:iterazione conrrollara da un valore sentinella è decca a volte iterazinne indefinita, perché non è noto in anricipo .U numero di volre che il ciclo sarà eseguito. Nella icerv.ione comrollaca da un contatore, è urilizz.a.ra una varinbile di controllo per comare il numero delle ireraz.ioni. La variabile di controllo sarà incremenrara (di solim di 1) ogni volra che sarà eseguito il gruppo di imuzioni. l i ciclo terminerà quando il valore della
CAJ11TOLO 4 variabile di controllo indicherà cbe sarà sr::no eseguito il numero corretto di iterazioni; a q uel punto, il compurer porrà continuare l'esecuzione con Liscruzione successiva alla srrucrura di c-0nrrollo.
I valori sentinella sono uciliz.zaci per conrrollare una icerazione quando: l. il numero preciso delle iterazioni non è noto ÙLa.ruicipo e 2. il ciclo include delle isrruzioni che oncrran.no dci dari ogni volca che qucsc'ulcimo sarà escguico.
/* Iterazione controllata da un contatore * / #include main () { int counter
11 valore sentinella indica la "fine dei dati" e sarà immesso dall'utente dopo che rutti i veri elementi informarivi saranno stati fornici a1 program.111:l. l valori sentinella. dovranno essere
4.3
87
lL GONLROU..O Olil. l'ROGRAMM1\
return 0; ,_
Una iteraiiio11e concro.Uara da un comatore richiede; t. I l nome dj una variabile di controllo (o comacore del ciclo). 2. Il valore iniziale della variabile di conrrollo. 3. Lincremento (o decremento) con cui la variabile di controllo sarà modificata ogni voica
2.
a 4
5 6
nel corso del ciclo.
4. La condizione che verificherà il val.ore finale della variabile ili conrroilo (ovverosia:, quella che determinerà se il ciclo dovrà conrinua.re). Considerare il semplice programma mostrato nella Figura 4. l che visualizza i numeri da 1 a 10. La ruchiarazione
'T 8 ~
10
int counter = 1;
Figura 4.1
assegna un nome alla variabile di conrroUo (counter), la dichiara di tipo inrero, le riserva uno spazio nella memoria e le assegna il valore iniziale 1. Quesra dichiarazione non è una
ra 4. L, inizializzando counte r a 0 e soscicuendo la scrurrur.a while con
istruzione eseguibile.
;
Avremmo anche potuto d ichiarare e i.nizializzaI:e counter <::on le istruzioni int countér; c oljn t~r
= 1;
La dlchiar~one, anche in quesro caso, non è una isuuzi:gne eseguibile, mencre l'assegna-memo lo è. In seguj co ucili2zerem'o entrambi i mero·d i per l'iniziali.zzazione deUe variabilL I:iscruzione ++counter;
iflcretnenterà iJ contatore dcl ciclo d i l ogni volta che quesw satà eseguito. La condizione di cominuazioue del ciclo nella scruccura while comrollerà se il valore della variabile di conrrollo sia inferiore o uguale a 1 0, ovverosia l'ultimo valore per il quale la condizione risulrerà vera. Osservate che il corpo d i questo while sarà esçguito anche quando la variabile di conrrollo varrà 10. li ciclo terminerà quando l
Iterazione controllata da un contatore.
Normalmente, i prograrnmamri C renderebbero più c0nciso il programma della Figuwhilè (++counter <= 10) printt c·%d\n", counter);
Q uesto codice consentirebbe di risparmiare una .istruzione, poiché l'incremento sarebbe eseguito direttamenre nella condizione del ciclo while, prima che la sressa ~ia vecifìcara. Questo cod ice el iminerebbe anche le parentesi graffe intorno al corpo del while, perché a quel punto essò con terr!!bbe u.ua. sola isrruz.ione.. Scrivei:dl c::odice in un modo cosl conciso richiede una. cerra pratica.
Errore tipico 4. 1
Dato ,·he i valori in virgola mobìle potrebbe:ro essere approssimati, utilizzare dc!Le variabili di quel tipo per il controllo dei cicli, potrebbe produ.rre dei valori imprecùi del contatore e provocare dei conrrolli di termitutzi.oiie 1wn acèitrati. Buona abitudine 4. 1 Controllate le iterazioni determinate con dei va/ori interi.
88
UPITOLO
4
Buona abitudine 4.2
Fate' ·~:ientrare con degli spr1.zi e.delle tabul.azioni le istruzioni nel corpo·di ogn.111111 delle stnttture. di c·ontrollo.
Buona abitudine 4.3 Inserite una riga vuota prima e dopo ogni principale strzmum di controllo in modo da e11idrnziaritl afl'interno del progrttmma.
Buona abitudine 4. 4 Troppi livelli di nidificazione potrebbero rendere il programma incomprensibiit>. Come regola generale, cercate dì roitttre l'utilizzo dipiù di tre livelli di rientro.
propria co,ndiz.ione di continuazione. Dare che la v:iriahile di conrrollo sarà ora uguale a 2, il valore finale non sarà scato ancora superaco e di conseguenza iJ progr
La Figura 4.3 ill usrr-.a più dett;;igliammente la stru.rrura fo r della Figura 4.2. Nocare che la struttura for ''fa cucco": specifica ogni elemenro ùeèessario a una iterazione conu·ollara da un contatore con una variabile di conrrollo. QuaJorancl corpo del for siano presenti più isrru?;ioni, saranno necessarie delle parenresi graffe per defmire il corpo del ciclo.
Bitona abitudine 4.5
t
for
e.ii iterazione fOr gèScisce aucomacicamente mrri i dctcagU di una l.rerazioue controllatà
main() {
int counter; I* inizializ,azione, condizione di iterazìone e incremento */ / * sono tutti inclusi nella intestazibne della struttura for */ for ( count er = 1 ; countér <= 10 i counte·r++)
printi ( "%d\n", co unte r)'; return 0 ; }
Figura 4.2
Iterazione controllata da un contatore con la strutturafor.
li progrl).IÌllila opererà come segue. Nel momento in cui la srrurrura for incomincerà a e~sere esc~m, la variabile di ~0 n.rroll.o counter sarà ini::dalizzata a 1. In sc.guiro sarà venfì.caca la condizi.one di cominuaz.ione del ciclo: counter <= 10. Da1:0 che iJ valore iniziale di counter sarà 1, la condizione sarà soddisfatta e quindi l'is;U2Ìone pr intf visualiu.crà il valore cli count er, vale a dire 1. La variabile di conrrollo sarà quindi incremcmaca dalla espressione counter++ e il ciclo ripartirà nuovamente, con la verifìca dclla
•
for ( counter
La struttura di iterazione for
/* Iterazione control lata da un contatore con la struttura tor •/ #include
Valore finale della variabile di controllo
Nome della variabile di controllo
Cqrt1bin411efo le ~pazillhit'e 71àtic11,/i inserite pi:ima e dopo le stru.ttiJri! di. co11.tro!lo con ii rientro d.ei loro corpi in ima porizione più ifrternn rispt·tto aile relative testate, ddi·ete al vostro programma llrut apparenza bidimensionale che ne mig;lio1·erà enormemente la kggibiiitÌl.
4.4
89
Il. CONTROLLO DEL l'ROGRAJvlMA
parola chiave
Figura 4.3
1;
counter
t
Valore iniziale dellà .variabile di controllo
<=
•t
counter++)
10;
Incremento della variabile di controllo
I componenti di una tipica intestazione di un for.
Osservare che la Figura 4.2 milizza la condizione di .conrinuazione Jd ciclo counter <= 10. Nel caso .in cui il programmatore avesse erroneameme seri.tra counter < 10, il ciclo sarebbe staro esegulro soltanto' 9 volre. Questo sarebbe stato un ripico errore logica chi.amaro "errore di imprecisione di uno''.
Errore tipico 4.2 Utilizzare. un operatore relazionale errdto o usare un valore finale erraio per il L'01ltatore d~L dc.lo, tdl'interno df!Lla cond1$ione di una struttura whi le o tor, potrlÌ provocare 4.egli errori di i1nprecisione di uno. Buona abitudine 4. 6
Urarc il valorefinak insieme all'operatore rektzionak <=, all'interno della condizione di un11 str11tt1m1 while o tor, aiuterà a evilflre gli errori di imprecisione di uno. In un ciel.o utilizzato-per vis11hli.2mre i valori da 1 n 1O, per esempio, la condizione di crmtimrazùme del ciclo dovrà e!sere counter <= 10 piuttosto che çoµnt:er < 11 o counter < 10. Il formato generale della smmru:a for è for (espressione]; esprenione2; espresri.one3) ismlZione
90
CAPITO!,() 4
dove espressiont!l inizialiuecli la variabile di concrollo del ciclo, espressione2 sarà la condizione di concinuazione ed epressiond incrementerà la variabile di controllo. Nella maggior parte dci ca~i lasmmura for potrà essere rapprescnram da un while equivalente, come segue:
Errore tipico 4.3 Usnrc le virgole invece dei punti e virgq/11 nella inteitazione di un tor.
espressione] ;
Errore tipico ef.4
while (espressione2)
istruzione esprmùmd;
L'inserimento di un punto e virgola immediatamente alla destm della intestazione di un tor nnderÌJ il corpo di quella stmtturn tor una istruzion~ vuota. Questo Ì' normalmente un errore di lot)ca.
}
C~è una eccezione a questa regola che sarà discussa nella Sezione 4.9. Spesso, espressione] cd esprersioru3 saranno delle liste .di esp ressìoai separare da virgole. Utilizzace in questo modo, le virgole saranno in realrà d egli operatori virgola che garant iranno la valutazione da sinistra a d estra dell' elenco di espressioni. Il valore e il cipo dJ una lis.ta cli espressioni separare da virgole saranno quelli dell' ultima espressi-One ~deUa lii;.ra. l:operarnre virgola ·è utilizzarn m<;>ltQ ~pesso nelle s[rutcurc far . Il suo ucilii.zo prladpale è quello di consenrire al programmatore di uttlizzare le inizializzazioni e/o le espressioni di incremento multiple. Per eseµrpio , in una singo la ~trurtura for potranno esserci due variabijj di conuollo che dovi:annò essere inizializzare e incremencare.
Buona abitudine 4.7 Nelle sezioni di inizializzazione e di incremento di untr struttura tor, inserite solo delle espmsi
91
h. CON'l'ROI 1.0 OL\l. PROGMMMi\
~
1
saranno tutte equivaleoò. Molti programmatori C preferiscono la forma counter++, perché l'incremcmo avverrà dopo che sarà sraro eseguito il ciclo all'interno del corpo. Per q~esro metivo la forma del poscincremenro sembra pili naturale. Daro che il preincremenro o iJ poscincrcmenro della variabile in quesw caso non ai;>pare in una espressione, entrambe le forme di incremento avranno lo sresso effetto. Entrambi i punci e vìrgola nella scrurrura dd for sono obbligatori.
4.5
La struttura for: note e osservazioni
1. L'inizializzazione, la cond.iz.ione di concinuazione del ciclo e l'incremento po rranno co11[enere delle espressioni arkmetiche. Per C$empio, supponcie che X = 2 e y = 10, l'istruzione for (j = M; j <= 4 * X
* Yi
+= y I X)
$acil equivalente alla isrruzione
tor ( j • 2; j
<= 80; j +• 5)
2. ".I.:increroeuro" potrà essere negacivo (in cal caso sarà in realtà un decremento e il ciclo effettivamente coruerà a ricroso). 3. Qual.ora la condizione cli concinuaz.ione ~el ciclo sia ~Isa sin dall' ~o, la porno.~e aJJ'~ 1 rerno del corpo del ciclo non sarà esegum1. 1.esecu:1.1one procederà mvece con l 1scru210ne successiva alla suucrura far . 4. LavaciabHe di conr:rollo è spesso visualizz.aca o ucilirz.ata nei calcoli all'inrerno del corpo di un ciclo, ma non è necessario cbe lo sia. :t. àpico usare la variabile di conr:rolJo per couaollare l'iterazione, senza menzionarla mai nel corpo dclcido. 5. Il di;igrammaddla scrurrura far è rnolro simile a quello dellasrnmura while. Per esempjo, il diagramma di flusso della isrruzione for fo r (counter = 1; counter printf( "%d ", counter);
<•
10; counter++)
è moscrato nella Figura 4.4 . Questo d iagramma di flusso rende evidence cbe l'i1lizializ.7.azione sarà effocruara solo u na volta, mencre l' incremento sàrà eseguico solo d opo che s;trà stara compleraca l'istruzione all' interno del corpo. Osservare che (a pan:e i cerchiecti ele frecce) il diagramma di flusso conricf}c ·solra:m;o dei rerrangoli e un r~mbo. l~ma ginace, anco(a llna vol ta, che Il programmatore po$a accedere a un conten 1 r~r~ capiente di srrurmre for vuote. La quantità d i queste è cale che, a:ccaca.standole e n1difìcanclole con le alcre suutture cli controllo, egli porrà formare unalmp1emenrazione stru rwxara per i l flusso di controllo di un algoritmo. [ reaangoli.e i rombi saranno quindi completati con le azioni e le decisioni appropriare per l'algociuno.
Buona abitudine 4.8 Nonostante iL valore della variabile di co11trollo poJra essere modificato tmche all'interno del corpo di ttn ciclo far, ciò potrà generar.e degli errori Logici difficili da individuare. Quindi sarà meglio non cambiare tale valore.
92
CAPITOLO 4
93
It. cm-rmo~.o l)f.L l1ROCRAMMA
Buonn abitudine 4. 9 Le istruzioni d1e precedono un tor e quelle aU'intcnUJ del tuo corpo potmnno spesso essere compattate nrfla intestazione del f or, ma evitate di farlo poiché ciò renderà meno leggibile il programma.
Stabilisce il valore iniziale della variabile di controllo Verifica se è stato raggiunto il valore >--
finale della variabile dJ conrrollo
Figura 4.4
printf(.%d•, -.i count er);
counter++
Corpo del dclo. Può essere composto da molte ltruzioni
Increment a la variabile di
/* Somma con for */ #include
ma in () {
int sum
controllo
number;
far (number = 2; number ~ um += num.ber;
Il diagramma di flusso di una tipìca strutt1,1 ra for.
<= 100 ;
number
+= 2)
printt( ~s um is M\n", sum);
4.6 Esempi di utilizzo della struttura for l seguenti esempi mosrrano dci metodi per far variare la variabile di conrrollo in una srrurrura for.
a)
= 0,
r et urn 0; }
Far variare la variabile di conrrollo da 1 a 100 in incrememi d i 1.
)
sum is 2 550
for (i= 1; i<= 100; i++) b) Far varia.re la variabile di conrrollo da 100 a 1 in incremenci di -1 (decremenri di 1 ).
for c)
(i= 100; i>:::
~
1; i· -)
~
la variabile di connollo da 7 a 77 a passi di 7 .
_Far variare
tor (i = 7; i
<= 77; i
+= 7)
d) Far variare la variabile di conrrollo da 20 a 2 a pa5si di - 2 .
e)
= 20;
i >= 2; i ·= 2)
Far variare la variabile di controlJo sullasegueatesequenza di valori: 2 , 5, 8, 11 , 14, 17, 20.
to r ( j = 2; j <= 20 ; )
-t·=
3)
f} Far va.ri;ue la variabile di c.ontrolJ0 slùla seguente sequcnrza di valori: 99, 88, 77, 66, 55, 44 , 33, 2 2, 11 , 0 . f or ( J = 99 ; j >: 0 ; j · = 11 )
l prossimi due esempi forniranno alcune semplici appliçarioni della stmrrura for. Il programma della figura 4.5 ucilizza la srrucrura for per sommare tutti gli interi pari da 2 a 100.
05;5ervace che il corpo della srrucrura for nella -Figura 4.5 in realtà porrebbe essere unico alla sezione più a destra della incestai.ione del for , utilizzando l'operatore virgola ncl segoenre modo: for (number
= 2;
ili.ni7.ializzazione sum
number <= 100; sum += number, number
Somma con fo r.
Buona abitudine 4. 1O Ljmiutte a una sola riga, se possibile, la dimemione delle intestazioni di uno struttum di controllo.
Il prossimo esempio calcolerà l'inreresse composto, urilizzando la muuu.ra f or. Considerare la seguenrc enunciaiione del problema:
f
for (i
Figura 4.5
+= 2)
= 0 porrebbe anch'essa essere unica alla sezione di inizializzazione dd for.
Una pmonn investe $1000, 00 i11 un libretto di rispannio, che re7lde il 5 ?erc~nto di intéresse. Calcolate e viswilizznte l'ammontare dcl déntrfo rziil aonto rdbt fine dt. ogm anno, per JOanni. supponendo che tutto !'interesse sia sw:to ltzJ.citt.to in deposito sul conto. UtiiizMte fa seguente formula per detenninare le suddette cifte: a= p(l
+ r)"
dove p
è l'ammontare dell'investimento ùzi:i;i.ale (ovverosia il capitale)
,.
è il tasso di interesse a;muale
n
è il numero degli 11nni è /izmmonttire nel deposito alla fine dell'anno n-esimo.
Il
Quesro problema richjedeyà un ciclo che eseguirà i calmi.i indicaci per ognuno dei 1O anni in cui il denaro rimarrà nel deposico. La soluzione è mosrrata nella Figura 4.6. L'lSrrunura fo r eseguirà il corpo del ciclo 10 volre, variando una variabile di conrrollo da 1 a 10 in incrementi di I. li C non include un operm~re per l'operazione di elevamento
9.4
CAPrt"OLQ 4
Ù ·CQNIROLl.O DE.I.. PROC)RAMMt\
a . I:>Qtem.~, rurçavi.a porremo utilizzare a ques.to stopo la Fu.n.ziòne pow. della libreria srandard. La fu.ntione poW(Ji(, y) ~kola iJ valoi:e dix devaro al.la.y - e.sima pbrenza. Il double e un tip:o di dat!> in vù:go.là rnobile rno.lto Simile .aJ fioat , ma una variab.iJe di tipo doubie può immag~ztnare numeri molro pÌll gr-a:ndi, cwn una precisione più alca di Ili! float. Os:Servare che, qtialè.ra venga miliuaca una funzione man;matka come pow! dovrà essere focluso il file di intestazione math. h. In Feal:tà, ques-t~ programma funzioDerebbe, ina male, anche senza l' inclusiçmç cli math . h. L.a tu.ni,ioiie pow richiede due argoiiirnd double. Osserva:re chç year è perQ illl iorei:o, Ii fil~ math . h iodu.de appunto dcl.le in.ff>nn.a:zioril cht5 i.o.dic;aao al çompilatore di Gotivertire il v.alore di yèar in una rappréSèorazione double -i:ç.mp.or.;inça, prima di rid1iama.re Ja funzione. "l'hli informazioni sono contenute in WHl enrit.à chlàrilara pro.tori.po di jùnzione d.i pow. I ,prnrotipi di funzione. sono una n.uqv:a impor~ tarfre e.àracterisrici deH'ANSf C e saranno spiegarj nel Capjçolo ?· Nello stessu c.:iP.it.9lq, forniremo un compendio di pow e delle al_cr~ funzioni marematiche (!.ella libreria. ./'" Galcolare l ' .i:nte.resse c omposto ,. ,
#include ~s taio . hj #inélude
95
Bu.otta abitudine 4.11 Non .utiliZZ1Jte varùtbifi 4it:ipo float o doubl~per (J}eg1/ite cf!.kofi}irian?ifrri. l.'i?'ri.prèPsione de;im1meri in pfrgo/!1 mobi/fpotràprovocm'c degli 'mori chèp;-6tfumumo vahri.mo'netali n(m t;'tfrtetti. Negli r:'Iè1·ttki .e.rplorì:rèi'no {'J.,tifizzq d.eé intllri j>
Due qua1frirariv~ di dolfari, ·espressi in float e im.rn:ag.aminari nella: 4llil'tchioa_. ·pocrcl;>-bern essere 14,23.4 (che sarebbe visualizzato come !(23 i;:oo ~ . 2f) e l8,.ualiz.~a.Zione pott~bbe apparire c.Qme: 14,·23
+ 1'8,67 32' 9:1
ma.in ( )
~ però evide.nre che la 1iOmrI1'1. d~ singoli nuri:fec-i, cos) èor:ne vertgonò visualizzaci, debba èss,efo 32,90! Sietè .stati a..v.vì.,saà!
{
int
y~ar;
d'otfb-le amount 1 prinG'ipal printf ,("~As~21 s'\ n ~ ,
a,ppar\rà, in 21 pos'izio.fu di visualizzazi.one.11 2 s·pècifica la previsione .(v.ale a dire, il numer9 d:i·posizioni deciinall). Qualora anumero dei caraeteri vìsualizza:ci sia inferio re a.14. qimeosio~ oe del <..'ampo., iJ valore sarà automaticamenre gjusti.fi.aato a d.fst1-a all'i.n te(Ilo dd 9UTlP.0· .ç10 sar-à p<1rtic0la.rmenre utile per allineai:~ d_~ valori 'i·n virgola.mobil~ con I(}. ste~a precision·e. J·nserire un - - ($_egpo men9) tra .i.I% e·.la dime~ione del qrmpc.'i; per gt,'W;i:fic4Y.è·a sinistra. ii valore.iriseci~Q in quel c;amp.o. Osse.r:v.-are..1z.he il se.gp:o nieno porrà anche essere urili2.11aro per giusrifìGa.te...;i sinistra gli interi (&me in ·515 _6d), o [e srrioghe di cai:a.ti:e1:i ~come in% - as). Nel Ca:pimlo 9 cr;mei:etno .in dettagli.o le pocenri éapa:cirà di formattazione éU printf e scanf. 0
Gfl depo:sdi~
2
1
ru
4spe~ilì-ca cmwcrsifm.e %21 • 2f è.~c~r.a urifo.ui..a nd pr:ogram:m~ p.e.r v.is.ualiz?.,ir.e il val9ce della v~riabile uount f1 21 nel.la.speci6ç_a.d.I ciinv.e;c;siòne-de.noca la difncmùme..del campo· io çuj i I valore sarà wsu.a;l.i.zza.ro. Una d.i.mcttsione di campo 21 specifica il valore visualizz-at0
Caleelar.e l'interesse composto con far,
Ossén(ate che àob:iam0 dichiararo Ie variab_Jlj amount, princ-:j.pal e rate con .il dpo .d ouble. A'bbiàmo "farro ciò per scmplici.rà, p~rché avremo a cl1é éa:re wn parr:i Ìraz.ioriarie di d.Blla·ri.
4.7
La struttura di sele~ione multi.pia switch
Nel Cap~co{o,3 , ahbiam0 discussa' della struttura ~ i selezion.e singol.a i .f e di que.Ua di seleziqne dopfiia i f / .else. A vol.ce però l1.ll ~lg0ririilo p·errebbe rid'uede.rl': -che una data variabile od: ~p ressione venga cuo.fromatil èlisdmamerue .con ogmmo dei valori che essa può assume.te. e che,, a s'ec:;ònda dcl cisufrato del c.onfròruo, .vengano inrraprese delle azioni d.imnte. u e fo.r.nisce la struttura di selezione mulcipla switoh (interrmrore) per g
La strua:u.ra switc·h cònsistedi una sede di eti-c;bctte'casec.(c:;aso) è di un caso 0pzi.onale default. 11 pr:ògramrrm. nella Figu.r.a 4.7 lùilizza swì tch, per comare il numer::o di og1runa delle teccerè omilltrre dagli studenti come votazione al rermiDe di un esame. Nel progra,mmà, 11utçme i.rtunerterà le lettere di yotaziò:né d'.1e ~ state àssegnare à un'µ' dasse. Alfinféruo della irirest!l~iòne del whllé~ whHe ( (
Enter the letter grades. Enter the E'OF éharacter to end ìnput.
printf("Enter the letter grades.\n'); printf("Enter the EOF character to end input. \ n") ;
A B
while ( ( grade = getchar() )
e
switch (grade)
t
!:
/* switch nidificato nel while * I
aI
case ' A' : ca se ++aCount; break;
I
case ' B' : case ++bCount; break;
I b I:
;
6
EOF) {
/ * i l voto er a una A maiuscola /* o una a minuscola "'/
A
.,
e E
1ncorrect lettèr grade ente ved. ETitèr a new gr ada. I " i l voto era una B maiusco l a */ / * o una b minuscola • /
case ' C': case •e•: ++cCou nt; break;
I " i l voto er a una C maiuscola / * o una e minuscola *I
case ' D': case 'd': ++dCount; break;
I* i l voto era una
r
D maiuscola o una d minuscola */
..
,
.,
/* i l voto era una F mai uscola *I /* o ~na f minuscola */
case
I*
\ n': case ' '·
D
A
B
ì otals far each l&tter grade are: A: S B: 2 e: -s D: 2 F: 1
Figura 4.7
case 'F ' : case 'f' : ++fCount; break ; 1
D F
ìgnor~.
Gjuesti caratte ri nell' in,put * I
br~ak;
default: /* intercetta tutti gli altri caratteri */ pri ntf ( 1• rncorrect letter grade ent ered. "); printf( " Enter a new grade. \n")~ break; }
Un esempio di utilizzo di switch.
l '~-segnamenco incluso nelJe parenresi ( grade = getchar( ) ) sarà eseguito per primo. La funzione getchar (dalla librerja srao.dard di inpurfourpur) leggerà tm cararcere daUa tastiera e lo immagazzinerà nella variabile incera grade. Normaltner:ite i cararceri sono immagazzinati in variabili di tipo char. Una importante carnueristica del C è runavia che i earattcri possono essere immagaz•1iinaci in qualsiasi cipo di dato intero, poiché all'inrerno del computer sono rappresenrati come interi di 1 byr~. Di cénseguenza, porremo rrarrare un carattere sia come inrero sia come caratrerc vero e propria, secondo il suo uti lizzo. Per ~empio, l'isrruiione
pr i ntf( ''The character
(\e)
has the value %<1.\n", ' a 1 , ' a ' );
uri.Lizzerà le specifìche di conversione %e e %d per visualiizare rispenivamence il cararrere a e il suo valore incero. Il cisulraco sarà:
The character (a) has the value 97. printt ( • \nTotals f or each letter grade a_re: \n") i printf( "A: %d\n", acount); printf("B: %d\n ", bCount);
J..:.incero 97 è la capprcsenrazione numerica del carattere ud compurer. Molri compucer uciliu.ano oggi l' irmemc di caratteri ASCIJ {American Standard Cwlefor lnformation lnterchtmge, Codice Americano Sttlndard per lo Scambio delle Informazioni), nel quale il 97 rap presenca la
98
C\l'ITOL.0
4
lener
Le istruzioni di assegnamento, considérare nel loro complesso, hanno in realcà un valore. Qucsm è precisamente il valo(e che sarà assegnam alla varfabile alla sinistra del segno=. Il valore dell'assegnamenro grade ~ getchar () sarà il cararcere resriruico dalla getchar e assegnaco alla variabile grade.
li facto che le isrru1.ioni d i assegnamente abbiano dei valori porrà essere urile per inizializzare diverse variabili con lo Stesso valore. Pcr esempio, a
= b = e = 0;
valurerà in primo luogo l'assegnamento e = 0 '(pE>iéhé l'operaco,re = associa da destra a sinisrra). Alla variabile b sarà g uindi assegnam il valore delPassegnarnento e = 0 (ovverosia O). In seguito, alla variabile a sarà assegnam jJ valore dell'assegnamcnco b = (e = 0) (anch'esso O). Nel programma, il valore delfassegnrunen.ro grade = getchar() sarà confrontato con.i l valore di EOF (un simbç lo Hctù acr")nimo sca p~r "end ot fìJe" , "fine dcl file"). Noi u tilizzeremo EOF (che r10rmalrnence vale - 1) coi:ne valore senrinella. L:utente premerà una combinazione di casti dipendente dal sistema, per in dic.'lre la "fine del fìle", ovverosia "Non bo piì1 dari da immettere". tEOF è una costante simbolica ìruera definita nel file di intesrazione (vedremo come si definiscono le costanti simboliche nd Capitolo 6). Qualora il valore assegnato a grade sia uguale a EOF, il pr?gramma terminerà la propria esecuzione.1nquesro programma, abbiamo scelro di rappreseru:are icaracreri con degli int, poiché EOF ha un valore incero cbe, lo ripcriamo ancora una volra, normalmente è -1.
1J. CONTROLLO DEJ. l'R()GRAMMA
99
ognuna delle etichette case. Supponece che l'ureme abbia immesso come vocazione la lecrera C. Questa sarà auromaricamence confroncara con ogni case dello switch. Nel caso sia scara verificata una corrispondenza (case 'C ' : ), saranno eseguite le istruzioni di quel case. Nel caso della lettera C, cCount sarà .incrementara di 1 e la scrurrura swi tch sarà abbandonata iromediatamenre con J'isrnuione break. :Cismu.ione break induce il conrrollo deJ programma a con tinuare con la prima istruzione dopo la struttura switch. I.:ismu.ione break è urilizzaca perché alaimenci sarebbero eseguici insieme rurri i case di una istruzione switch. NeJ caso in cui break non fosse µtilizzara. in nessun posto della sc:ruttura switch, allora ogniqualvolca fosse riscontrata una corrispondenza all'ime.rno della struttura, sarebbero eseguite anche Je istruzioni di rurci i case rimanenti. Qualora nos1 sia srara riscomrara nessuna occotrehza, sarà eseguito iJ caso default è s.arà. visualizzaco un messaggio di erro re. Ogni case può contenere una o pit1 azioni. La strutmrn. switch è differe.me da rurce lé altre smitnate, poiché in u11 case dJ switch no n SOFIO m:.eessarie le parentesi graffe incorno alle az.ioni. m ultiple. li diagramma di filusso generi.ca per una stru.uura d i selezi'o ne multipla switch, che utilizzi u n break per ogni case, è moscram nella Figura 4.8.
azione del caso a
break
azione del caso b
br eak
azione del caso z
'bre.ak
Obiettivo portabilità 4.1
Le combinazioni di tasti per immettere EOF (fine del file) dipendono dal sistema.
Obiettivo porr:abilitlt 4.2 Controllare la costante simbolic11 EOF, invece che -1, rtn.derà i programmi più portabili. I.o standm·d ANSI srabilisce che EOF deb.ba essere un valore intero negativo, ma non necessariamente -1. Di conseguenza EOF pot:rebbe avere valori diversi m sistemi differenti. Sui sistemi UNIX e molti altri l'inclicacore cli EOF è immesso premendo la seguenza di casti
Q uesra notazione indica di premere il Easro rerum (o em er, o invio) e gujndi d i premere simultaneamcnce entrambi i tasti ctrl e d. Su alrri sistem i, come sul VAX VMS della Digical Equipmenc Corporacion o in MS~DOS deUaMicrosofi: Corporarion, l' indicatore di EOF può essere immesso p remendo
I:uccrue immetcerà le vor.azioni alla tastiera. Nèl momento in cui sarà scato premuro il tasto recum (o encer, o invio), i caratteri saranno lerci uno per volta dalla funzione getchar. Qualora. il carattere immesso non sia uguale a EOF, si entrerà nella srrurrura swi tch. La parola c;hiave swi tch è seguita dal nome della variabile grade ua parentesi tonde. Q uesca è denominata espressione di controllo. Il valore di questa e,sprçssione sarà confromaco con
azione di default
Figura 4.8
La struttura di selezione multipla switch.
. 100
CAPITOL04
lL CON'm.QLI.O l)l! L PROGRAMMA
Il diagramma cli flusso rende eviderue che ogni istruzione break, alla fine cli un case,
B11ond abitu.dlne 4.. I5
fa in modo che:il comrollo esca. immediatam ente dalla struttura switch. Ancora w1a volra,
osservate che, a rarce i cerchietci e le frecce, il d iagramma di flusso contiene selo rcmu1goli e rombi. Immaginare, :mco.i;a, che il programmato re abbia accesso a un conrenicore capienre pieno di strurrure swicth vuote. [a quantità di queste è raie che il p rogrammaror e, acc:uasrando le e nidificandol e con le. altre srrurrme di conrrollo, possa. formare una implemenra4ion<;' scrurrurara per jj flassò di controllo di un algori tmo. J rettangoli e i rombi saranno quinùi completati con le azioni e le decisioni appropriate all'algorirmo.
Errore tipico 4.5
Dlmentftm-c una ùtrugione break qualom ne iip. necmaria una in una stn~ttura swi tcfi. Bttona aliitudine 4. I 2 F,mzite .un caso defa.u l t nelle istruzioni swi t;_ch. Nonrt11lm'ente i casi no.n controllati in modo e~plicito a/L'interno di u·1w swi tch saranno ignorati. I/ ctt.so default aimm} a evitarlo, spingmdo ilprogrammatore a concentrarsi sulla necessità di elobomre le condizio.n i eccezionali. Ci sonlJ s.ituazioni in cui non sarà necessario nemma elaborazione per il ,·aso default. Buona abitudine 4.13
Sistemare il caso default per ultimo ~considerata una bur,mn 11bittJdi'f'te di program.trmzione, sebbene Le clf.t,-usofe case e quella del coso defaultiossa110 p1·esentarsi in qualsiasi ordine tlll'intemo di .una struttttro swi tch. Buona abitudine 4.14 [r1 una struttura swi tch, tp.mlòra la clausolli default sia sistenuita per ultima, l'ism1zfone break ali'intemo di quejl'ultimo caso TlDn sarà necemzria. ALettni programmatori però includ.ono 1,guafmente un break per motivi di chiarezza e simmetria con gli altri case. ·
l?icordn.te difamù·elc ùtn1zioniper l'el11,bomzionc dei camtteri net()/ini: presemi rte!L'inpw, quando ciahorate i cnratteri imo per volta. Ossei:vare che le d iverse etichette di caso sistemare insieme (come c ase ' O' : c ase ' d ' : nella Figura 4.7) significano semplicemenre che per cnrrambi i casi sarà esegu i ~9 lo sresso insieme cli azioni.
Quando urilizzare 1:1 scrurrura swi tch. ri.cordacc che può e.~sere urilizzara solranto per conrrollare u na espressio1~e intera costrmu, ovverosia, ogni combina~ione di costanti di caracrere e Lncere che possano essere valutare come v:alori inreri Una costarrre d i tipo carattere è rapprcsenrara con il carattere specifico po$ro tra apici singoli, come in ' A' . Per essere riconosciuti come coscami di tipo carar:rere, quesci.devono essere racchiusi alfinrerno degli apici singoli. Le cosranri ince.r e sono semplicemem c dei valori inceri. Nel noscro esempio, abbiamo urili7-zam delle cosrami d i tipo cru;arrere. R icordate e.be i ca.ratceri sono in .retJ ltà dei valori inceri mcroGrin.aci in tJJl byce.
I lingu~ ponabili, come iJ C, devono avere delle climensioni Elessi bili per i tipi cli daro. Applicazioni differenti possono ave.re bisogno d i i meri cli dimensioni differenti. 1L C fornjsce d iversi cipi di daro per rappresentare gli inceri. .tintcrvaHo dei valori interi per ognuno dci tipi fornici dipende @I particolare hardware del computer. In aggiunta ai tipi int e c har, il fornisce i ripi s hort (una abbreviazione per short int) e long (per l ong int) . Lo srandard ANSI specifica che il campo di variabilità minimo dei valori i.nreii short dc\(C essere ±32767. Per la gran magg!oranza dei calco!i inreri. sa.r;lnno sufficienti degli interi long. Lo standard specifica che il campo di variabilità minimo dei valori long deve essere ±214748;3647. Sulla maggior parre dei compurer, gli int sono equivalenti agli short oppure ai long. Lo standàrd srabifa~ce che iJ campo di vari.abilità dei valori int deve essere grande almeno quanco q ueUo degli iareri short, ma che non può e-sserc più grande ù i quello degli inceri long. U cipo d i dato cha r porrà essere uciliz.zaco per rappresear.are degli inceri nel t'.affipo cli va riabilirà ±127, oppure ognuno dci ca:rarrcri facenri parce dell'insieme dei caratteri d.el computer. ·
e
Obiettivo portahilità 4.3
Nella srrunura switch della Figura 4.7, le righe case ' \ n ' : case ' ' ; break; indurrru.mo il p rogramma a ignorare i caratteri cli newline e di spazio. Leggere i caratteri uno per volta può causare -alcuni problemi. Per fare in modo che il programma legga i cara.a:eri, questi dovranno essere inviaci al computer premendo il tasto invio sulla tastiera. C iò provocherà l'inserimento nell'inpu t del carattere newline, subito dop9· quello che si desideri elaborar~. Tale cara,ttere d i oewline d ovrà spesso essere tracrato in modo speciale, per far funzionare correrrament e il programma. Con l'inclusione dei casi precedenti, nella nostra scrurrura swi tch, preverremo appunto la srampa del messaggio cli errore od caso default, ogru volta che nell'input sarà .ìoconrraro tu1 newline o uno spazio .
Errore tipico 4. 6
Non ekt.borare i caratteri di newline nell'inpttf, q11.ando si l.eg,gono dei caratteri rmo per vtJLt11;. -p_otrà prrn10CtLre degli errori Logi.ci.
Quµ/ora prroediate di elaborare degli intf!TÌ che possano ricadere n.LL'e.stmio del campo di. varittbilità ±32767, ma desideriate essere in grado dijùrfimzio1zare il vostra programmà su diversi sisrcmi tli compute1; allora dovreste utilizzare degli interi long. giacché la dimensione degli i nt pqrrebbe variare dlJ sistema a sistema. Obimivo efficienza 4. 1
In situazioni in cui le prestazioni sono importanti, in cui la memoria èprezioso o è necesS1t1ia una cerra velocità, sipotrebbepreferire l'uti&zo della dimensione più piccola degli. interi.
4.8
La struttura di iterazion e do/while
La srrurmra di irerazione do / while è simile alla smmura while. La condizione di continuazion e del ciclo, nella saun u ra while, è controllata aJl'inizio dello sress.o, pri-
ma che sia eseguiro il corpo delJa iterazio ne. L a strucrura do / while conrrolla la condizione di conti n uazione del cid o dopo ch e è stato eseguiro il corpo deUo srçsso; d i
CAJ!ITOl.O
4
conseguenza, le istruzioni alJ'imerno del corpo del ciclo sarfillno eseg·uire almeno una voka. Al termine di una istruzione do / wh i le, l'esecuzione continuerà con l'istruzione sa ecessiva alla clausola while . Osservate che nella suurrw:a do / while non sarà necessario ucilizzare le parentesi graffe, qualora all'interno del corpo ci sia soltanco una istruzione. Tuttavia, le parentesi graffe sono indas,e di solito per evirare la confusione tra le srruuure while e do / while. Per esempio,
lLCONTROl.1.0 DF.t PROGRAMMA
103
accesso a un capienre contenitore di srrurcure do / whi le vuote. li numero di quesrc è tale che il programmatore, accatastandole e nidificandole con le alue scrurrure di conrrollo, possa formare una implemenrazione srrurrurara per il Busso di conrroJlo di un algorirmo. I renaogoli e i rombi saranno quindi complerari con le azioni e le decisioni appropriare all'algoritmo.
I * Usare la struttura di iterazione do/while */
while(condizùme)
#include
è normalmenre vista come l'imescazione di una struttura while. Una struttura do / wh ile senza parentesi graffe incorno a un corpo formaro da una singola isrcuz.ione apparirebbe come
main() {
int counter = 1;
do irtru:i:ione v1hile(condizione);
do {
che porrebbe creare confus ione. I:ulrima riga, while (condi zione ); , potrebbe essere fraintesa· dal lettore come una strutrura while conrenente tma istruzione vuora. Di conseguenza, per evirare confusioni una struµura do/While çon una istruzione si ngola sarà spesso scriua nel modo seguen te:
do {
istruzione }' while (condizione);
, count er); printf ( "%d } wh i l e (++co un ter <= 10 ) ;
ret urn 0 ; }
t
t
2
Figura 4.9
3
4
5
6
7
8
9
10
Usare la struttura do / while.
Bu.onrt abitudine 4.16 Alcuni programmatori includono sempre /,e parentesi graffe all'intemo di una struttura do / while, anche quando rum sono necessarie. Ciò aiiaa a eliminare l'ambiguità tra la struttura do / while contenente una isrruzione singola e la struttura whil e.
azione
Errore ripùo 4. 7 i
I cicli infiniti. sono provocati quando la condizwne di continuazione del ciclo in ttna smmura while, for o do/while non diventa mai falsa. Per prevenirli, assicuratevi d1e non ci sia zm punto e virgola immediatamente dopo l'intestazione di una struttura while o tor. In un dcLo controllato da -un contatqre; a.ssicurarevi che-la variabile di controllo sia ir1crermmtat11 (o detremrmtat:a) n:ei cqrpo dei d.cio. In un cialo contro/!11to da 1.1:n valore stntineL/a, a.ssicurrttroi che aLla.fjn:e qittfto siapreso in inpitt. Il p.1:0gramma nella Figura 4.9 utiliza.a una st.rutmra do /while per visualizzai:e i owneri da l a 10. Norace che la variabile cli comrnUo counter è stara incremenrara (con un prdocre.mento) nella sei.ione per il con(.rollo della continuazione dcl ciclo. Osservate anche l'utilizzo delle parentesi graffe per racchiudere il c;erpo della srmrmra do/while formaro · da u.na isrruzione singola. 11 diagramma di flusso della struttura do / while è mom~ro nella Figura 4.1 O. Questo diagramma dj Busso evidenzia che la condizione cli continuazione del ciclo non sarà ve:rifìcaca, fintanto che l'azione non sarà srata esegufra a lmeno una volca. Ancora una v0ha., osservare che, a parce i cercbje:tti e le frec€e, il diagramma di Ausso contiene solcanro un rettangolo e un rombo. Immaginate, di nuovo, che il programmarore abbia
vero
o Figura 4. 1O La struttura di iterazione do / while.
4. 9
Le istruzioni break e continue
Le isrruzioni break e continue sono utiliu.ate per alterare il flusso di comrollo. J.:isrruzione break, qualora sia eseguita in una struttura while, fo r, do / while o switc h, provocherà ruscir.a immediata da quella struttura. 'Lesecuzio:ne·del p rogramma coorinuerà con la prima isrruzione successiva alla srruttura. I.: utilizzo àpieo della istruz.ione break è per ancicip~re l'uscita da un ciclo, oppure: per ignora.re la parre rimanente d.i una srn.mura switch (come nella Figura 4.7). La Figura 4.11 dimosrra_ l'utilizzo della isrrazione break in una
lì CA:rrroLo4
104
smmura di icerazione for . ~iscruzione break sarà eseguita quando La Strtlrtura if avrà determinaco che x avrà assumo il valorè 5. Ciò tcrminetl l'esecuzione deUa isrruzioue for e il programma potrà conrinuare con la funzione printf susseguente. TI ciclo s_arà est
11. CONTim u
/* Usare l ' istruzione #inélude ma in () { int
105
o DEL JIROGltAMMA
con~inue
in una struttura for * /
x;
far (x = 1; x <= 10; x++) {
i f (x -
5)
continue;
printf("%d •
/ * saLta i l codice restante del ciclo solo se x == 5 */
x);
}
printf ( '' \nUsed continue to skip prin'ting the IJ,alue S\n"); return 0; }
Buona abitudine 4.17 Almni programmatori pensn110 che break e continue violino le nom1e della programmazione strutturata. Dato che l'effetto di queste istruzioni potrlt anche essere ottenuto da recniche di progrnmmnztom strutturata, come impareremo presto, questi. programmrttori non itti{izzano break e continue. /* Usare l'istruzione break in una #111olude
struttu~a
Figura 4 . 12 Usare l'istruzione continue in una struttura for .
Obit!tr.ivo efficienza 4.2
for */
Le istruzioni break e continue, qwmdo snnn u.tiiizztJ,te in mod1J appròpriato, samrmo eseguite più 11eLoceme11te delle corrùp<>ndenti tecniche strutturati/ che a.pprenderer11o presto.
main () {
int
1 2 3 4 6 7 B 9 10 Used continue to skip printing the value 5
Ingegneria del software 4. I
x;
tor (x = 1 .I
X
C'è una dicotomi(l tra la ricerca di una progeu4zione di software di qualità e quella di software più efficiente. Spesso uno di questi obiettivi è raggiunto a discapito detii1ltro.
<::e 10 j x++) {
--
5) if (X Qreak;
!"'
interrompe i l
~ic lo
solo se
X
--
5
~1
4.1 O Gli operatori logici
printt ( '%d n I x);
Fino a questo punco abhia.mosrudiato $olranco delle condigi.oni setnplicicome coun te r <= 10, total > 1000 e: number I= sentìnelValue. Abbiamo espresso quesrc cond-iz.ioni con. l'uso degli operatori relazionali >, <, >=, <= e di quelli di uguaglianza == e I =. Ogni decisione ha verificato precisamcncc una condiz ione. Se avessimo voJuro conrrollare delle condii.ioni multiple in una deci$ione, avremmo dovuto e.seguire i suddetti conaolli con delle isrruzioni discinte o con delle strucrure if o if /else nidificate.
printf( " \nBroke gut of loop at x -- %d\n " , x); return 0;
, 2 3 4
Brok·e out O'f
io~
at x
=:
5
Figura 4. 11 Usare l'istruzione break in una struttura for .
l
l i C Fornisce degli operatori Logici che possono essere uciliz7.aci per formare condizioni p.iw complesse. combinando q_ueUe semplici. G li operatori logicd sono: && (AND logico) , : i (OR log~co) e I (NOT Logù;o derro anche negazì,one logica). Considereremo degli esempi per ognuno dei suddetti.
1'ci6
CMI.:TQLQ4
.Sup-ronete éhe, prima di stegli.ère ·Un determinato percorso di esecuzione, vogliamo in un cerco punto del programma due condizioni siano entrambe v:ere. In queste <::as0, porremmo utilizzare f'operat9n; JgJ® && ço~ç segue:
~siturarci <::he
if (:gende r = 1 && age >o: ·65) ++·$e niorF11malés;
==
Quesr-a istrµ:zion~ i f contiene due r:.:ond.izioni sempU.eL La condiziQne gender 1 porr./i essere valutara, per esempiq, p\er detem1.i.n~re se una_p.ersoa:a s~ di-sesso fe.IIllilini.le. La con~zione ~ge >= 65 saj valucai:a pèr dete~are. se. unà çerta persona si.a. urL cittadino a:n.Ziano. Le dué..c0ndi.zioni semplici sil..rarrnO'va1uta1:e. pe.r prime perché le priorità di= é >= scirrd più alte-di queJJa di&&. lti SegUÌW, J'i srraziòne.i f Gònsid èrè.tà .Ja
=
La. tabella deUa Figura 4. 13 descrive l' 0peramre &&. L1 rabe11a mosrra rurte I.e quattro possibili combin.az.ioni ~valori zero (falso) ·e diversi da zero (vero) pernspressione l ed e~pres sione2. Le tal;>elle di qm;sro, gen~r~ ~ono- sp~~so d1famace ta.k#ledi 1!,"erità. 11 e valuta oo l ttnte le espres~kuii che includa.n9 degli opeta:t9.r.i c~lazi9nall, !-'li uguàgli;tn:>..a· ~/Q_logiçi. Sç:bb~e il C 4n1?osri_iJ -y,aJore ver:o COI!I l , esso actètr~ come verò ogni v;lliare-dkvèrs.o d.a 'Zero. espressione I
espresslone2
espressione I && espressiene2
o
o
o
o
diver$o da zero
ò
dive(SO da zero
o
o
1Q7
e preruicrà lo srudenre èon una '~!\." qualora una o eumunbe le co.ndi1,ioni semplici siano ve.re. Osservare d1e il messaggi'0 '"Student grade is A" n.o n sarà visualizzar9 ~0Jo quando enrrambe !e condizioni sem,plici sa.ranrro false (e.ero). La Figura 4. ~4 ç una tabclla di \'.e dtà per loperatore JQgiço OR (l : ) . espressione I
espres5ìònè2
espressione I 11 espressione2
(j
o
o
o
diverso dà zero
l
diverso da zero
di verso da :ie.rn
diverso da zero
1 lk& ;;i,@e >= 65
Questa condi:ziorte sarà ver:a se e solo se entrambe le amdizio.ni semplici saranno ver.e. Infine, se 1a sudderra condizione wmbillata saFà effetcivamenm vera, alfora il comacore s en io r Fe mal es sarà increniemaco di 1 . Qualqra una f> enrrambç le ~onclizj_o,n;i semplici siano false, Ll programmaJgno.rerà. l'int,remeoto e procedei:à cç>n l'kruzione sueçes.~iva alla struttura if.
Figura 4. 14 Tal:>elladiveritàpèrl'operatore: : .(QRlogìco) .
I:operamre && ha una _p1iori-rà maggi.o.rç çlj l :. Emr.ambi g!i <:>_petatod assodano c;la sinistra a. d~src-a. Una espressì·one cqnteneme gli opetarori && 0 i : ~arà valutar~ . solranto fincamo che non sarà nòtn Ja·sua verità_0 falsicà, Di Cònseguenia, la valmcione della c,:ondirione ~ end er
==
1
&& a·ge
>::
65
fotmèrà:, qualora gender 11011 sia uguale a 1 (a qucl pun.ro, l'i.nter:i: espre5sio.ne sarà skurainence falsa); mentre com:inuera, q ualora gender si·a uguale a 1 (poich.é.l'ìmera espressione porrebbe ancora essere vera se age >= 65}:
$.Ì
Obietti/lo èfficianZIJ 4.3
. / cl.iversq da zero
diverso da z.ero
Figura 4.13 Tabella d i verità per l'operatore&& (ANO lo~iCo).
Cot.fsideriamò ora l'operarorc : : (OR logico). Supponete çh·e, pr-ima di s~eglie(e un eé.rtti perc0~0 d i esecuzioné, vogliamo assjeu:ra.rci clie a un c.eno puntò del prdgramma u.n:i. o eotrambc:. le condi?ioni s.iano vere. 1n ques.to caso useremo l'opèrar0.re : : , comé nel s.egueme 1Ì:rui:u:nenrci cl.i programma: H
lL CGNTRQLLE> DEL l.'.ROG.11AMMA
('s.ernest.erAverage >= 90 : : f.i.nal Exam >-= 90) prin t'f ( "·Student grade iS A\ n") ;
Q11e~ta i~ttu"z.~911.e q ;rn.tie.n.,e anch'e,s~a due §.o·µdi1,ieni semp lici. La .cBn.d.i-ti.Q:ne seme$terl\verage >= 9~ sai'~ vaht.ra~a p:er= deterniìna.re S:e lo stud~re del cm;so meriò uru1 "A"; grazie -a. un n:mdi-me.n to coname nel cotse .d el semesfre.. La Gbil.di.z:io'n:e f inaJ;E'xam >= 90 S
>"' 9·0_ : : fìna l Exam
>"' ·90
N~L(nsprè.ifi0:11i che ùtilizzana l'Qpera~iire
&&.-fate in nHJ.tlo che ltt.pr.ima condizione si.a rptella,.che avrà piìt pi·òbabUità di essere falsa. Nette e5pressioni che.rJ,tiliZZt.tno .l'operatore f f,fate in mo.do che fa prima condizione sia que/u;. che avrà_più.pvobabilità"di ~J~ere vera. Cib·potrà ridurre il ternpo di esernzione dèl prqgrammn.
li C fomis<;e I ~la negazione logka)· ()é.r consentire al prograi:tuna[(;>r.e di ••.iuverrir.~" il valore di llna <':òndiziotie. A éiiffereu-za. degli operarori && e l :" che combinano due condizi0.ni (e sono qtùndi degli operatori binaci), quello di negazione logica. hac solo un:a.. singola c::ondizi0nc come operando (ed è quindi un ope:Ea+9I!! un.aria). 1.'.opetatore di _negazione legica-a.11gica) 'Sia falsa, co·me nel s.egueme &:.ammènto·di èoèli'te: ·
if (I (.grade =-=- sentine1Va1 ue)) pr i ntf(" The n&xt grade is %f\nµ, grade);
Le parenresi jucorno· a1Ja condfai.one gradè = sentinélValue sono necessarie perché l'operatdre di negw-i.òn.e logica -ha. una priorifa mà&giòre- dell'operato.re di uguaglianza, la Figura 4.15 è una tabella d.i verità per f opcrarore di negnziohe logica. Ne.Ila, maggior j>:artè dei cisi, Ll progì·am.rtl.4rb,te porrà. evitare di uò.liz:za:re la riégazio1i.e logica, e,c;primtndo la condi7jo.ne in modò diverso. con uri a:ppropr.iam operatore relazionale. Pè.r e.Sen:1pio., l'isrrnz.iòne pm:ed.eme porrà essere ·sGrirra anche nel modo seguen te:
Cwrro1.04
108
if (grade I= sent i nelValue) printf("The next grade is %f\n", grade_);
e
La tabella nella Figura 4. 16 mostra la priorità e l'associarività dei vari operarori introdon:i sino a questo punto. GU operarori sono mostraci dall'alto in basso in ordine decrescence di pciocità. espressione
lL CONTI~Ol.1.0 DEL l'J{OGRAMMA
rura ru controllo. Lespressionc sarà crarrara come fàlsa qualora il suo valore sia O, mcmrc sarà consider.ira vera ael caso cbe il valore sia diverso da zern. ll secondo aspetto è che nel linguaggio gli assegnamenti producono un valore, ovverosia quello che s~ àSs~aro alla variabile a sinistra ddfoper-.icore di assegnamento. Per esempio, supponere che vogliamo scrivere:
e
if (payCode == 4)
printf("You get a bonus!");
!espressione ma
o
che acciden.calmeme scriviamo
= 4) printf('You get a bonus!");
it (payCode
o
diverso da z:ero
Figura 4. 15 Tabella dì verità per l'operatore! (negazione lògica).
Operatori
Associatività
Tipo
( )
da sin istra a de~rra
parentesi
da destra a sinjsrra
unan
da sinistra a destra
molciplicativi
da sinistra a destra
additivi
da sinistra a destra
relazionaJj
da sinistra a destra
di uguaglianza
&&
da sinisrra a desa:a
ANO logico
I I
1 1
da sinistra a dcsrra
OR logico
?:
da desua a sinisrra
condizionale
da destra a. sin.i.ma , da sinisrra a desrra
di assegnamento
+
++
*
109
I
( tipo )
%
+ <
<=
-
I=
+=
>
>=
*-=
/=
%=
virgola
Figura 4. 16 Priorità e associatività degli operatori.
4.1 I Confondere gli operatori di uguaglianza ( = = ) e di assegnamento ( =) C'è un àpo di errore che i programmatori e, indipendememente da quanto siano esperti, rendono a commettere cos) frequenremen·ce che l'abbiamo ritenuto me:citevole di una sezione disr:inra. ·raie errore consiste nello scambiare accidemalmenccgli operatori == (uguaglianza) e = (assegnamento). Ciò che rende questi stambi così dannosi è che essi, solimmence, non provocano degli errori di sintassi. Di solito, infarti, le istruzioni cbc conccngono questi errori sono compilare correttarnenre e il programma sarà eseguito fino al suo compleramenco. generando probabilmcme dei risultaci non correai a causa ru degli errori logici, durame la fase di esecuzione.
Ci sono due aspccri dcl C che causano qucsri problemi.. Uno è che, nel linguaggio C, ogni ~pressione che p1·oduca. un valore può essere utilizzata ndla sezione di decisione di ogni srruc-
Li. prima isuuzionc i f assegnerebbe correrramenre un bonus alla persona il cui codice dJ pag;imento è uguale a 4. La secoi1da isrruzione i f i.nveçe, quelJa çon l'errore, va.lurerl!bbe l'espressione di assegnamenco alJ1intcmo della sua condiziorie. Questa espressione è un asscgnamenro se,rn:plice il cui valore è la cosmnrc 4. Dato che ogni vak>re ,Lverso da zero è interpretato cqme "ve,ro", la condiiionc di qucsca isrruzione i'f sarebbe.considerata vera e la persona riceverebbe semp.re un bo.nus, indipendenccmcme da quale sia il suo reale codice di paga.memo! r~
~
Enore tipico 4.8 Usnre L'opemtore ==in un nssegnnmento o uti/i$Ztl.r'I: !'opemtore =in 1m1t crmdiziom di ugitaglianur.
Normalmeuce i programmatori scrivono le condii.ioni in questo modo x == 7 , con il nome della variabile a si nisrra e la. cosranre a destrè!. Jnvercendo le loro posizioni, facendo cioè in modo che la cosrance sia a sinistra e il nome della variabile a destra, come in 7 == x, il programmarore che soscicuisse accidentalmc:nce l'operatore == con = sarebbe protetto dal compilacore. li compilarore, infan:i, lo mmerebbe come un errore ru sintassi, poiché sul Lato sinistro di una isrruzione ru assegnamento può essere sisremaro soltanto il nome di una variabile. Quesro evirerà almeno la potenziale devaswione di un errore logico durante l'esecuzione.
1 norill delle variabili sono detti anche lvttlm: (per "lcfr value", valore di sin istra) proprio perché possono essere urilizzari sul laro sinistro ru u n operatore di assegna.memo. Le comrnci sono dette invece rvttluc (per "righr value", valore di desrra) proprio perché possono essere urilizwre solcanro sul lato destro di lLO opefatore di assegnamento. Osservate che un lvalue può anche essere utilizzato come rvalue, ma nQn viceversa. B11on11 ttbi1udi11e 4. J 8 Qurmdò una espressione di .u.guttglianza contiene mm llttricchife e una costt1nt11, come in x == 1, akuni propmnmatodpreferiscono scriverla con la costante a -sinistra e /11 vnrirzbife a desh'a, per proteggersi tlati(rrore Logico che si verificherebbe, qualora sostituissero 11ccider1talmente t'operatoi·e == co11 =. Caltro lato della medaglia porrebbe essere alrce.rcanro spiacevole. Supponete che il programmatore voglia assegnare un valore a una variabile con una sempUcc isuut.ione come:
= 1; ma scriva X== 1; X
invece
1 LO
Q&rroL04
}mchdn qm.;5r9 ~0 1 non sì. crarr.a di un errore di sintassi. 11 çompilaJere valu~e.rà pfottç>sto catidi'damerué l'espressione condi.zipnale. Qualora x fosse µgilllle a 1, b çondizioné sarebbe è<'lnsiderar~ vera ·e l'e·spre~s_i0ae r~ti tn::ii:ebh~ il valore 1. Qua'.lora x ll'0Il f-0.sse uguale a 1, la colldizion,e sà!:ébbe G:ons.iderafa fhl'sa. é.. l' esp11essi6ne reStìtuirebb:e J1 yalor.e 0. &id.pendente mente da quale v.aJ.or.e sa:ra resiimim, noti ci sarà nessun operarore di a.~se.gn.a memo, per.ciò, il .val:ox;e andrà sempliG:ememe pers0, e quello di x x;ester~ inai'térata, eau5ando prnbabilmente un enrore logico durame l'esecuzione; Sfonunatamente non abbiamo a dispgsizjone un n::uccç:i pr;iJiçç> per aiu~i cpn ques.ro probl~a!
4. 1l Riassunto della programmazione strutturata L prngrrse, cosa ancora più importante, abbiamo app(t'So che la prog~:un:.ma.zl0m: stmttur:'1.ta prodqce p·rogram.mi che sono più sc;rµpiiti (ri:pen,o a· qµdli non stnl.tfuiWi) da co.mp.rendcre e quindi cl~ collaudare, mett~re l\ pw:m), modifiaue e anche da dimos.cyare to:rrem ncl senso matèmarico dcl rtrmine.
4- CONTROLLO DJ!.L PROGRAMMA
..-. .e
~ .e
o
·~ ::i t:
:;: ._ G>
e o
.H ~
Ul
!!
"O
11' L..
::i ._., .µ
.b lii
::J
>
~
~
t..
o
~
~
::J
t:
..,::J L..
lii
1 Capircili ~ e;~ SL$on11> s.offeana,ri sulle stI'l,l~ur.e di ç01m0Uo del C. Qgni s.aurrura è sratt presenrara, rappresentata in diagranimi cli flusso e discussa: _separa,ra,rnente con degli esémpi. Ot:t cicap.icolere.mo l..risu4;i.ti dci Capitoli 3 e 4 e lntrodw:rem o !+Il sérnpliG.e lrrsillr:i;le dì r~golc per la còs1;rùzioae cli progf~mi st'rUrruriti e pèr le foro prtop#e.rà.. .LaBigµra-4.17 cias~lJ.Dl~ Le ,srrurrure cli controllo dl'scusse nei C,apiroli ;3 e 4. l c,;~riliierci s0no utilizzati.n'ella:fìgup per indicare gli unici punti di enc.rara e di uscita di ogni struttura. Collega«.::arbirra:cianrent~· j singqli simboli dS UB diagrarrim:a di flusso _pou.à çònducre a
ptogrfuntili non scrutt4ràci. Di ci)a.Segu,énia, la categoria dei -prògtamma'.(ori ha scelto di itb,mb:in ar'e i simboli per i diagrilrillhl di -flusso, i'n :itiodo rale da formare uri imieme lim.Ltaro di strutturè di controllo e di cosrruire sokamo prngiammi srtmrurari, ·combinando appwpriatamente le strutture di con troHo ~econdo due sole semplici modalicii. -Per semplieiù.r, SQ!IQ ~&.t.e µrilizzarç soJ~t<;! srrqrrure d:i conrr.0llo ~on \ill:J. s_ì.agela çnr:mJ'a ç qsi:;ii:a: c'è solo un mq:do per entrare e 4Jll sfila ID4Uie:ra pçr ~i~e dalla Stryr_m ra di c0_rrtrqll9. CoJlegar.e !e s.m,i.rttu~_çli c;onrr.l!)llo fil.sequenza, i·n moq0 da fo rm_are-dei _p.rogra.mtni strui!1;urar;i, è sèin'p.lice: il punro di uSc.irJi cli lilla scructu r~ di còmrollo.è còrine~s.6 di.mtameme ;li pumo èli enrrara della stl'w:rura di concrollo scrccessiva, Iti altre parole. le muctuie di comrbllo saranno SÌ:Stéfuate in un pr.ogramma unicamente l\ma dopo l'alrra: ab.biamo perciò ehiarnato questo processo "acca~StaJJ,J,ento delle -sa urmre di comrello". Le regole di formazi
La Pigura_4.J 8. moscra le ri:gol.e per foaiiare àppropriai:ameute dei programmi strurrurati. 1.e regole assumono <::he 0gni simb.olo cli remmgolo nei diagrammi di flusso . possa essere utiliu~to per Indicare qU;alsiasi a'Zione, incluse quelle cli input/ouq;>ut. Vap:plicarione délle regble della Figura 4.18 piodnrrà un.diagramma di-flusso sttJJ.tru:r:aro eo'n ·un aspetto ordunrb e .simile ai màmiiiciti.l delle CdsrruiJoni. Per illsèmpi0, applicando ripèllitarneme La regola 2' al diagramma di Ausso elemenrart; se ne- produrra uno scrutnuato c0nte11ente molti rettauge).i in sequenza (Figma 4.20). O sservare che la regala 1 g~nererà u-na Ga't~~ ça_ di Sl:rJ.loU: ur~ qi coatrol1o; per questo motivo l:a chiamei;-e:m:0 regqla di tu:ctt:{Jfstamt:nto.
Figura 4. 17 Le strutture di sequenza, selez.ione e ripétizk>ne con un ingres'so e una wscita singoli del lìnguagglo C.
11 2
CAP1T01.0
4
l t. CONTROLLO DEL. PROGRAMMA
113
Regole per la formazione di programmi strutturati 1) Incominciare con il "diagramma di flusso elememare" (Figura 4.19). 2) Ogni renangolo (azione) può essere sostituito da due recra.ngo.l.i (ai.ioni) in sequenza. 3) Ogni rerrangolo (azione) p uò essere sostituito da una qualsiasi suurrura di controllo (sequenza, if, if/else, switch, while, do / while q for). 4) Le regole 2 e 3 possono essere applica.te cip~ruraroenre e in qualsiasi ordine.
L-~--' ',
''
ti
''
''
Regola 3
',,
''
Figura 4 . 18 Le regole per la formazione di programmi strutturati.
''
''
\~
r-------------- --------------, I I
I I I I
I
Figura 4. 19 Il diagramma di flusso elementare.
,,
lt ,~
I
,.
I
I I I
I
.
, 1..---- ------ -
__ ________ f___ I I I
I I
'
I
,
I I
--.
Regola 2
...
Regola 2
Regola 2
...
, ,,
,
I
I
I
I I
I
I
I I
I
I I
I I
-------- ---,' '----------- -- ---~---
;:.
La regola 3 è dena regobi di nidificazwne. Applicando ripetutamence la regola 3 aJ diagramma di Ausso elementare, .5e ne produrrà y.no con srrurrure d1 conuoilo nidificare in modo ord:inaro. Per esempio, nella Figura 4.21, iJ réttallgoJo dd diagramma di 8usso elementare sarà prima sostituito da una struttura di selezione doppia (if / else). In segllito la regola 3 sarà applicata di nuovo a enrrambi i rettangoli della srmrmra di selezione doppia, sostiruendo ognuno di quei renangoli con altre srrurrure di selezione doppia. I rettangoli traneggiati incorno a ognuna delle struaure di selezione doppia rappresenrano i rettangoli che sono stari sosciruiri.
I I
I
I
I
I I
___________ _ .___ I
I
'
I
...
:I II
I
I I
I
I, ,---- ------ ----- ----- -- --- , I
-------------II' elementare.
' ,'' ' ------------------------,------I
I I
iI
'
I
I I
Figura 4.20 Applicare ripetutamente la regola 2 della Figura 4. 18 al diagramma di flusso
'
' ,,
I I
I
:
Regola 3
:
I
I
,I
''
'
I
Regola 3
I
J
I I
I
I
' I I
'I
I I
I
I I
I
I
I
I
I
I - - - - -----~ ---
-------------'
I
I
I
I
I
I I I
Figura 4.21 Applicare la regola 3 della Figura 4. 18 al d iagramma di flusso elementare.
114
WPITOL04
La regola 4 genererà delle $t:rutrure più grand i., più complesse e più p rofondamenre n idi ficate. 1 diagrammi di Ausso che possono essere formaci, applic-and0 le regole d ella Figura 4.18, costituiscono l'insieme d i turci i p ossibili diagra.romj dJ Ausso srrutcurati e, quindi, l'insieme di curti i possibili programmi smmu.rari.
h. CONTROllO DEL PROGRAMMA
La programmazione strurruraE:L promuove la semplicità. Bobm e Jacop.ini hanno dimostrato che sono necessarie solo i'.re forme di controllo: •
Mattoncini accatastati
Mattoncini nidificati
D D D
Sequenza Selezione
È p roprio grazie all'eliminazione della isc:ruzione goto che questi marroncini di cosuuzione non si sovrappongono mail' uno suH'alrro. La bellezza dell'approccio srrunuraco è che utilizziamo soltanto un piccolo numero di semplici pezzi, con un singolo ingresso e una sola uscita, e li assem bliamo soJtanco in d ue semplici maniere. La Figura 4.22 mostra i ti pi di cos~ruiioni, onen ute con L'acc'-a rascam ento dei mattoncini., che si possono formare attraverso l'appliCazio ne della regola 2 e i tipi d i costruzioni, ottenute con l'accarascamento dei mactonciru, ehe non possono apparire n ei cliagiamm i di Busso scrua:w:ati (grazie alla eliminazione della istruzione goto).
11 5
Iterazione
La sequenza è banale. La selezione; è implementata in uno dei rre modi: •
strutl'ura i f (selezion e sem plictZ} stru ttura i f I else (selezjone doppia)
•
struttura swi tch (sele-1.ione mnlcipla)
D i fatto, è elementare dimosrrare che la semplice struttura i f è sufficieme a fornire ogni forma di selezion e: mero ciò che possa essere fatto con le scrucrure 1f / else e swi tch porrà essere implemencaco con La stru ttura i f . t:iceraziooe è im plcmenrara io uno d ei ere modi: •
srru rrura while struttura do / while srrurrura for
Mattoncini sovrapposti (illegali in programmi strutturati)
È elementare p r-0.vare che la scrucrura While è suffièienre a fornire ogn i forma d i iterazione. Tu tto ciò che p.oss:a essere farro con le srrurrm è do/while e for porrà essere implemenraro con la scruccura while.
La combinazione di quesà risulraci dimostra che q ualsiasi forma di controllo di cui si potrà aver bisogno in un programma C porrà essere espressa con rre sole d i esse:
•
sequenza srrurcura if (selez.ione)
• Figura 4.22 Mattoncini accatastati, mattoncini nidificati e mattoncini sovrapposti.
Se le regole della Figura 4.18 sono rispettare, ua diagramma di flusso non strurruraco (come quellq d ella Figura 4 .23) non porrà esse.re crearo. Se non siece situ.ci che un particolare diagramma d i flusso sia srrutrurato, appUcate le regole della Figura 4,18 all' inverso in modo da pro:vate a ridu r.re il di agr~a. di flusso a quello elemencru:e. Se il diagram ma di fl usso può essere ridorco a q uell0 elem entar e, allora il diagramma d i flusso originale è scrutruraco; altrimenti, nordo è.
srruccura
wn ile (iterazione)
Queste srrurrure di controllo potranno es.sere combinare in due soli modi: accarastaodolc e nidificandole. La programmazione sutLcturaca promuove di cerro la semplicir:à.
Nei Capimli 3 e 4, abbiamo discusso di come comporre i programroj wn murrure d i controllo concenemi azion i e decisioni. Nel Capitolo 5, introdu rremo un'altra u nità di srrum 1razione del programma chiam ata .f!mzione. Apprenderemo come costruire dei programmi. complessi combina ndo le fun zioni, che saranno formare a loro vofra da scru tr:u re cli controllo. Discuteremo anche del modo in cui l'urilizzo delle funz ioni promuova la riusabilità del software.
Esercizi di autovalutazione 4. 1
Figura 4.23 Un diagramma di flusso non strutturato.
____
Riempire gli spazi. in ognuna delle segu
11 6
CAPITOLO
4
e) Nelle ripecizioni concrollace da un concacore si utiliz.ta una per concare il numero di volte che un gruppo di istruzioni dovrà essere ripenuo. d) L1struzionc: quando eseguita in una sttucrura di ice.razione, indurrà l'esecuzione immc:diara della irerazione successiva dd ciclo. e) l.:imu1.1one , quando eseguica in una srruuuradiirerazione o in uno switch, causer~ l'uscita immediata dalla srrurtura. f) La è miliu.aca per coorrollare .una parricolare variabile o espressione per ognuno dei valori costanti inceri d1e essa porrà assumere. 4.2 Stabilite se le seguenci affermazioni sono vere o false. Qualora la .risposa! sia falsa. spiegacene .il moàvo. a) Il caso default è obblìgawrio nella srrunura di selezione switch. b) !.:istruzione break è obbligaroria nel caso default di una strurrura di selezione switch. e) Cespressio11c ( x > y && a < b ) ~arà conside= vera qualora lo sia x > y oppure qualora In sia a < b. cl) Una e.~pressione contenerne l'operator~ : : sàràc:;on·sidcra'ra vera se uno o entrambi i suoi openwdi sono veri. 4.3
e
Sc.i;ivete una isu-uzione o un loro insieme per c~cguire ognuno dei segueoci Còmpili: a) Sommare gli !meri dispari tra I e 99 urilizz~ndo uua srrurrurn for . Supponete che siano mtte dichiarate le variabili sum e count. b) Visualiz1.are Uvalore 333,546372 in un campo lungo 15 caratteri co11lcprccisioni1 , 2. 3. 4 e 5. Giusrilìcate a sinisrr.i l'ourpur. Quilisarann,o i cinq.ue valori visualizzaci? e) Calcola ce il valore di 2, 5 elevaro alla poren.za 3 uriliizando la funzione pow. Visualizzare il risulrato con precisione 2 i:n un c.unpo con dinie.nsione pari a 10 posruoai. Quale sarà il valore: visualiu,uo? d) Vìsualizutc gli imcri da l a 20 uriliz7.ando un cido whìle e la variabile contacorc x. Supponc1e che x sì:1 ~à srara dichiarara, ma mm inizializzal3. Visualiuace solo 5 inceri per riga. Suggeri memo: usate il calcolo x % 5. Scampacc un caraccere newlinc: quando il valore di questo calcolo sarà 0, akcimenci visualiv..ate un Ctratterè di cabuhzione. e) R.ipecc:te l'Esercizio 4.3 (d), uciJ~zzaude una smmura tor. I
4.4
1i·ovate l'errore in ognuno dei seguenci frammenti di codi.c e e spiegate come correggerlo. a) x=1; while (X <= 10);
lL CON' rROLLO DEL f)ROCRAMM.I\
Risposte agli esercizi di autovalutazione 4.1 :~) definita. b) indefìnit3. c) variabile di conrrollo o conm:ore. d) con1:inue. e) break. suuuura di sclt'Z.ione swi toh.
4.3
a) sum = 0; fo r (count = 1 i count sum += count i b) Prlntff "%·15.1f\n ", printf( 1'%· 15. 2f \n~, printf('"%· 15 . 3f\n", printf( "%· 15.4f\n", printf( "%· 15.5f\n",
case 2: printf("The number is 2\n"); break; default: printf('The number 1s not 1 or 2\ n'); break; cl) 1l codice seguente dovrebbe visualiu.are i valori da I a I O. n = 1;
printf("'isd\n', x++l; else pr.intf("l\sd\t", x++); o X
= 0;
while (+tx <= 20) { if (x % 5 ="' 0) prifltf("%d\n", x); else printf('l\sd\t", X); e) for (x = 1; x <" 20; x++) printf("%d ", x); if (X \ 5 == 0) printf ( • \n•); else prìntf( • \t•); o
n++) i
99; count
e) printf ( "%10. 2f \n", pow(2 .s, 3)).; d) X = 1 i while (x <= 20) { printf( \d", x);
}
e) switch (n) { case 1: printf( 'The number is 1\n");
fì
4.2 a) Falso. Il caso default è opzionale. Se non è necessaria nesi:una azione di defauJ. t , allora non ci sarà nessun bisogno di un caso default. b) falso. I.;is1rur.ione break è u1.Wzzara_per uscire dalla siruttma switch. l.:is1ru1.ione break non sarà richiesta qualora il caso default s.ia l'u1rimo. e) 1:a1so. Quando si utilliza l'opera1ore &&, e1:u:ra.mhe le i;spressioni relazionali dovranno essere vere perché l'inrera espressione sia considerata tale. d) Vero.
XHj
b) for {Y., .1; y I= 1. 0; y += .1 ) printf(«Dilf\n», y);
g) Il codice segucnre dovrebbe sommare gli i meri da 100 a 150 (supponere cne tot al sia già mua inizializzata a 0): for (x = 100; x <= 150; x++); tot al. += x;
a) Errore: il punco e virgola dopo l'intcswione del while provocherà un ciclo inlìnito. Corraione: sosciruire il pumo e virgola con una { oppure rimuovcce il ; e la } . b) Errore: l'uciliz.w
4. 6 Stabilire quali valori della variabilo:: di controllo x saranno visual.izzati da ognwia delle seguenti istruzioni for: ~ for(x = 2; x <= 13; x += 2) printf("\d\n", X); b} tor(x = 5; x <= 22; x += 7) printf("%d\nM, x);
(y = 1; y t= 10; y++) pri.ntf(«\f\n .. , (float) y I 10);
e) for(x
t) Errore: manca l'istruzione break tra quelle delprimo case. Corre-Lione: aggiungere un break.alla1ìne dcllelmuzioni del primo case. Osservace d1c questo potrebbe non essere necessariamente un errore. qualora il programmatore avesse voluto che le istruzioni dcl case 2: fossero eseguire ogni volta
= 3; x <= 15; x += 3) printf("%d\n", x);
cl) tor(x = l; x <= 5; x += 7) printf("%d\n", x); tj for(x = 12; x
~= 2; x ·= 3) printf( "%d\n ", x);
4 .7
Scrivere delle iscruzion i f or che visualizzino le seguenti sequenze dj valori: a) 1, 2, 3, 4, 5, 6, 7
b) 3, 6, 13, 18, 23
Esercizi 4.5
11 9
lL CONTROU..O O.EL PROGRAMMA
C) 20 J 14 J 8 t 2 ! "4 I • 10 d) 19 , 27' 35, 43, 51
Trovare l'errore in ognuna delle seguemi lsmrzioni CNota: dpotrebbe essere più di un errore): a) For (X = 100, x >= ·1, x++) printf(.%d\n ' , x); b) TI seguente codice dovrebbe visualiZ?.are se un daro intero è pari o dispari: switch (value \ 2) { case 0: printf("Even integer\n•); case 1: pri ntf( 'Odd integer\n•); }
;
e} U codice scguenre dovrebbe prendere in input un intero e un carattere e visualizzarli. Supponete che l'urente immerca come input 100 A. scanf ( "\d" , &intVal) ; charVal = getchar(); printf( '' Integer: %d\nC'l1aractel": %c\nr, intVal, éharval); d) for (X
= .000001;
X <=
printf(~%.7f\n " ,
.0001 j
e) rl codice scgucnle dovrebbe inviare in OLicpUl gli ioceri clispru·i da for (x 999; x >e 1; x T=2) printf('\d\n", Xli
=
f) il codlce segueoce dovrebbe visualizzare gli interi pari da 2 a 100: counter = 2;
counter += 2; While (counter < 100);
Ghe cosa farà il programma segueme? ~include
main() {
int i, j ,
X, y;
printf(aEnter integers i n the range 1·20: scanf( "'6d\d ' , &x, &y);
u);
= 1; i<= y; i++) tor ( j = 1 ; j <= x; j ++ l
for (1
printf("@");
printf("\n");
X += .000001)
return 0;
x);
Do { if (counter % 2 =~ 0) pr1ntf("%d\n•, counter);
4.8
999 a 1:
4.9 Sccivere un programma che sommi una sequeaza cli i.ri:teri, Supponete cbeil primo intero leLCo con la scanf specifichi il numero dei valori d1é dovranno c:ssere. immessi. Uvostro progr.urunadovrli leggere solo un valore per tigni volra che la scanf sarà eseguica. Un.a tipica ~equenza di input porrebbe essere: 5 100 200 300 400 500 dpve 5 inruca cbe dovranno
CS$Cre sommaci i 5 valori sucçessiYi.
4. 10 Scrivere un progr.uruna che calcoli e visuali:z:Li la merua di diversi inceò. Supponete che l'ultimo valore lecco con la scanf si:i quello ddla sentinella 9999. Una cipica sequenia di iopur porrebbe essere: 10 8 11 7 9 9999 che indica che dovtà essere calcolata la media di umi i valori che precedono 9999.
120
CAJ'lTOL.0
4
4.11 Scrivere un programma che rrovi iJ minore di diversi imeri. Supponere che il pdmo v::dore letto specifichi il numero di quelli ancora da leggere. 4.12
Scrivere un progr;'lmma eh..- calcoli e visualizzi la somma degli inreri pari da 2 a 30.
4.13
Scrivere un programma che calcoli e visualizzi il prodorro degli inceri dispari da I a J 5.
la funi.ione faaoriale è urilizzara frequ<:ncemern:e nei problemi di probabilica. Il fuccoriale cli un incero positivo n, scricro o!<.' pronunciaco "f.moàaledi n", è uguale al prodo tto degli inceri posicivi da l a n. Scrivere un prQ!,rramma che valuti i furrociali degli inceri da I a 5. VisuaHuare i risulcaci in un formaro cabularc. Quale ,tifficolrà porrà impedirvi cli calcolare il furroriale di 20? 4. 14
4.15 Modificare il programma deU'incer\!sse composro deUa Sezione 4:6 in modo che ripeca i suoi passi per cassi d'imercsse dcl 5, 6, 7, 8, 9 e 10 percenro. Dcilizzare un ciclo fo r per va.tiare il casso di ince.resse. 4.16 Scrivere un programma che visuafu.zi separaramence l'uno sorro l'akro i seguenti disegni. Urilizzare
4. l~ Un:i azienda di vendita per corrispondema vende cinque diftènmri prodoc[i i cui prezzi 11.I denaglio sono mosLraci nella seguente cabell:i: Numero di prodotto
(B.)
......
• ......... ...:1'-t lii"'!\'
• 1dl1f:Jf. .... -"Jt;_'Ji:lt ~~
*"**
........
• •ff•~•~ -.
·~··~
• •• ••""1 1
..................
"'*"..
~--···· 'llw•••••
*......,,. .........
_,.__.. ....... . . . . .
:Jt"**-'fH!r
.,..
~··
(C)
'.lt.t**-"'"'
"'li" *'.fF**c..;"'-***~#A °*'if'if{ii~*
*''*'°
..._., .... ~1'"
.......
~.
-'* ..,. ~
(D)
... lt •
~-·
*if11 1c A•-+1' lt
t-ri* • • ~****•'ti'
.._.-"*"'"*· -- ·
......... ""*• • *"
Prezzo al dettaglio
2.98 4.50 9.98 4.49 6.87
2
3 4
5·
Scrivere un programma che legga una seri.e dj coppie di numeri come segue: I) Numero d.i pro
uo rogramma dovrà ucilizt.are umL istruzione switch per aiutare a decennin:ire jl pre-lZO
TI
de;~~lio ~ ogni prodotto. 11 vomo, pr~gr:unm'.1 dovrà calcol:tre e visualiz.zare il valore corale al demt-
.glio
cl! turri i prodotti. venduci ndl uluma semmamt.
4.20 {A)
Completate le seguenti tabelle di vericà, .riem.pit.mdo i relativi spazi con O o 1.
Condizione I
Condizionel
o o
o diverso da 7.ero
d.ivécso da zero
J. TI numero di conto ~d djente 2 . TI limire di aredico del cliente prima della re.::essione 3. Il saldo corrente del dienre (vale a dire, l'ammon:care che il cliente deve all'azienda). Il voscro programma dovrà calcolare e visualizzare. il nuovo lim'ite di credito, per ogni dientc, e dovrà and1e dererrninan: (e visuali~:wre) quali di loro hanno dei saldi correnci che ~cdono il loro nuovo limire di credito.
4. 18 Una inceressanre applicwone dci computer è il disegno di diagrammi e di grafici a barre (derri a volte aiscogramrni"). Scòvere w1 programma che legga cinque numeri (ognuno compreso tra I e 30). Per ogni numero leuo. il voscro programma dovrà visuali7.7.are una riga contenente quèl numero di ascerischi adfaccnli. Per esempio, se il vostro programma leggesse il numero serre, dovrà visualizz.a re • • • • • • • .
Condizione I && Condizionel
o o
o
diverso da.zero
diverso da zero
Condizione I
Condizione2
Condizione I 11Condizionel
o o
o
o
***"......,. ...... *
4. 17 Riscuotere il denaro divenm sempre più difficile nei periodi dj recessione, per quesLo morivo le aziende porrebbero resrringere i loro limi.r.i di cred iro. per evitare che i propri comi di credito (il denaro loro dovuto) divçnrino troppo s.osraniiosi. Come risposta ;t una recessione prolungara. una aiienda ha dimezzaro il Limice di crcdìco dei propri clienti. Di conseguenza, se un parcicolare cliente avesse avuco un Li.mire di crediro di $2000, questo sarebbe ora di $1000. Se un clience avesse avuto un limite d i creèlico di $5000, ques.ro sarebbe ora di $2500. Scrivete un programma che analizzi lo scaco di credito per: m: clienti di quesra a7.ienda,. Per ogni cliente vi saranno fornici :
I i. J
lL CONTROLLQ DEL PRClCRAMMA
di versQ da zero diver~ da 1.eco Condizione I
dive rso da zero
o divecso da zero !Condizione I
o diverso da 1.Cro
4.21
Ri,scrjvére il programma della Figura 4.2 in modo chel'iniz.iali7.zazione della variabile counter sia. esegu:iLa nella dichiarazione, invece che ocUa suurcura f.or. la vo.rwone media della classe. della f'gura 4 7 in modo che calcoli ·1 " · • 1 4.22 Mod.i ncate 1. programma
4 2 3 Modificare iJ programma della Figw:a 4.6 in modo che utilizzi sol~ruo degli inr~ri ~er calco~ nerar1e come quanmà intere di I cifr · ·
. .· . . . lare l'inreresse composro. (Suggerimento: rran:ate ru.uc . e. . •e mo . . rispecualizzando cencesmu, e dollari di pomoni sue nelle risultato 1 · "separare" co · In · · 1 . . ceocesuru. segui , civamence le.opera2ioni di divisione e modulo. Inseme un punco}.
rus.aivete il progr:i.mma deUa Figura 4.7 ·SOSticuendo l'istruzione switch con d,elle. scmrrure defaul:t. Riscrivere quindi questa nuova versione, sòstituendo le storurrure ff/èls·e nidi.fie
4.3.0
if /else nidifìcace: scare ari;em; a c:ràrtare appropriataiuc;me il caso ·di
Cakvlat.c il valore cLi TI a partire dill.a Seri(! in:6n.ita
3
di cui il v:O..fuò. program1,1\_a avrà b~og1~0 per caleqlareJa paga di Qglli çlip'encl1=:me, in b1.1$e al pn,>prio codice cli p,a~entoappropriati
a)
4.2:5 v;isualfaz.ate una tabdla di equivalenza rra decimali , binari, ()[rali ed e.sadecima.li. Q ualora non abbi.are famWarità. c::ou i suddetri. sisi:emi. numerici, cm1sulc:ace prima l'Appendice E, se-volere remare di eseguire questo eserci11io. 4 .26
123
4. 29 (Leggi di De Morgan) 1n questo capfrolo abbiamo discusso degli opémori logici&&; : ·: e I . Le Leggi di De Morgan pou~~o a volte renderci più prarica la formulazione di un1nsp.ressione logka. Queste leggi srabiliscono che l'espressione I (conèliiionel && concli7.iòné2) è laglcamen.c~ equjvaJeme alla espressiom: ( I amdiziond ·: : I 10011dizi1:me2 ); lnolcrc, l'esp.ressione I ( contli:tio.nè 1 : I coildizione2) è logicamente equivalemeaU.a espressione ( lc;ondizionel && lcondkiooe2) , Utilizzare le L.eggi di De Morgan per scFivere delle espressioni·equivalenti per ognuna di quelle seguenti e quindi scrivere un programma che .diinosrri ehe l'espressfo.ne-0riginale-e quclla n.uov.a sono, in ogni.ciso, e.quivalenci:
i. >= 1 &g. j < 4) i ·ITT
lL CONTROLLO DEL J?ROGlti\MMA
qu~sta
sef.i'e. Qua.i)ci cèrmini di qt1~$ta '-5Jirie dovrece utiliz.za:rè, priinà dj ocrcn_ eèe 5,14? 3,141? 3, 1'415?
3; Ul);;).? 4.27 ('Fe~ne pitagoriehe) Un rriang0lo retrango.lo f'UÒ avere fari che .siano rutti ·interi. Dinsieme dei tre valori interi pe·r i Ia~i dj. .un ttiariKolo rettangolo è detto· rema pitagoriea. ~uesri rre laci de.v.ono ·soddi'sfarcda relazione.secontlo la quale la somma dei quadrati dei due ca~eti è uguale:al quadrato della ipore.nusa•: Trovare wrré I.e. reme p.iragoriche per latoi , lato2 e ipotenusa che non sian~ maggio10i di S:tlfl. ·Utilizzatoe un tiiplo .Giclo fo.r nìd.ifkaro ,che ,provi semplicememe: mrr.e le possib.i.lhà. Questo è un esempio cli éla.boraiione een "forza bruta'.. Non piaee a mofrì dal ptù1ro di visra esrecieo.-Esistono pi:rò moh~ ragionì l?e'f cui quesre·rern.iche ~on0 imporrami. fu p.11i.m'.0Juogo, con .f.ineremenro della po16mt di cakolo a un t irmo cosl-feaomeJ'ale, le·.soluzienì che av,r.ebbero richiesto ·anni o addirirru.ra secoli di elae.oraiioM; per esse.re ocrenme con_;! a cetnologia di solo un po' di anni fa, o~gio=o pòl:reboèrò esS'~tè Citèemtte in.ore, in m.i.oud o addirim1rain.secondi! lnsecondo luogo,.aome aflPr.e nden~re nei-co;rsj pru a-Vailiari di inf6m1acica, e'~ un gran numero ·di problemi inte_rè~sami per i quali illfo, ès'i~rè n~sail a1fprO-ècio algotirrnico 11oc6' éli.yérso da quello aélla. fòraa Òrutà. fo qudro lìbro ìnvescigheremo su. ml')lfi ti·pì di mecòÀOlO.gie 'per la s.olui iène dci pr.oblemi. Considereremo mòld ;tppr.Qc;cL<.on. fu,rz;i bm~a .a di.versi pio5lani in,teressa:na..
4.28 l.)na azic11çla feaibuis~~ j PfO,PQ cLipendenti d.iscin15!1endoli tra managet (.eh<;: riq:vom> un s-alario fiswsertim;ina1_e), lav~rar9ri ;i ~re(~~ !'i~v<;>no ima p-aga oraria .fi.s:$a p.er le p9m~ 49 ore cli lavoro e "un'ora e me-1.z.a", gw~r9sia t,5 VQite la [>aga OJ'ar.~, pe_r le •Ofe ,cLi ~Cl'àOJclimri.9 'effertua.~e), Li.vero.tori a tJrDV\~giene (che riceNqno $250 p.iù il ).7% delle loro vendite lprde serrim3naH), qpp.ure lavoratori a eorrimo (ehe ricevone una·cifra fissa di denaro ad arduolo; per ognuno di quelli proclot:ri: in q_uesra azienda ogni laverarore a cotàmo lav~ra·:solramo su un upo d.i arcicoll?}· Seri.vere un .progpunma che calcoli I.a g~~a settimanale di egni dipendrote. Non eonoscete in anticipo il .numero dei dipendcmi, Ogni cipo di dipendente ha il p,roprie codice d.i pagamemo: i n;ianag~r hanne 1, i lavora~ rori .a ore hanno 2, q_uelli a provvigione 'h an.ne ,3,e quelli a eo.rtimo hanno 4. l:Jrilizmre una sa:unura swi te h per
Sc_civere un prqgramma che visua.li1.2.i il scgueme diseg_no di un rambo. Po.crete utiliòz.1.re delle is_rt~iqni pr.intf che visuali.za.ino ogpuna un. singolo asrerisro (*) o Lmo spazio. Massùnii.1.are rl vo~9 uriliz.zo ·delle ripe:ckieni (con strucmrc for nidificare)· e minimizzate il numero di imuzìoni
4:.31
p·rintf. 'lr1J,"lf
..,.,"',,..... "
it',it';ill'
ili/}*.--~
,lo~!•-.f~~ ,,,~~
A.3·2 .tvf9dificarc il prog~ che avere scdcco nell'Ese.rcizie 4.31, in modo.da.leggete un numero 4iwarLcompres.o n:ell'imervallo da I a I 9 per specifiGare il numero di righe compte~e ud rombo. li V<:).SU'fl programma; dovrà quindi visualizzare un rombo della. misuta apptòpria:ta. 4 .33 Se ayeèe familW-ità ç911 i numeri ramani, sç.rivece un prO:gtamma eh~ visuali.7.:zi una rabeUa conceneme m:rri.i llllffi~ti romani equivalemi a quelli decimali çbmpre.si ne.ltirtrervallo da l a: 100. 4.~4 Scrivere wi programma che visualizzi una tabella comenellte i numeri binari; orta.li ed esadecimali equivalenti a quelli decimali rnmpresi nell'lmervaUo dal a 256. Se non avete fumiJià.cità con ql.i.ès~i siscemi rrumerici, consultate prima J"Appendice E; se volere tentare iii eseguire ques.ro è.sekizio.
4.35 Descriveteil pr~~ che u$eréste per 50stitu.irè LU'I cklq dO'/while oon una.scructur'1-.W'hile èqli,iv";Ilen.rè. Qu,i.ie prE:lbie.tna intonrre.re:ste qu.a1er-a cenca~ce cli sO;stiwire Lm ciclo while con una strurm1:a do/while équivalence? Supponete che vi s.ia scaco chiesEo cLi rimuavçr~ un tido while ? di $osritull:l0 cpn una sJrùrrura 'do/while.Di quàle alt(à.sr.ruttµra di eonrroll0 avt\!te b~ggn_o e ççime l~ userere, pòr ;issi<:;urarvi çhè iJ progµ.m.ma cisultame si çomporti esm:ament\! c;omeJ'ori~?
L24
CAJ>l1'9W4
4.36 Scrivere un programma che prenda in inpm un anno compreso nell'intervallo dal 1994 al 1999 e utilizzi una irerazioac con un ciclo for per produrre rrn calendario compend.iat0, v1sualiz.z.aro in modo ordina.ro. Artenti agli anni bisestili. Una cricica alle istrui.ioni break e continue è che non sono srrua:urace. In realtà le isrruzioni break e continue pos.~ono sempre essere sosriruire con isrruziooi smnru.rare, sebbene furlo possa essere scomodo. Descrivere in generale come rimuovereste mm: le:isouzioni break dal cido di un programma, e come le sostituireste con qualche istruzione stmnw:ar.a équn~etue. (Suggeri memo: l'istruzione break abbandona un ciclo dall'interno dd suo corpo. I..'.altra,maniera per abbandonarlo è facendo in modo che il controllo di continuazione dd ciclo fallisca. Nel controllo di continuazione dcl ciclo considerare l'urilizzo di un secondo concrollo che in~chi "usi;ita.anricipaca a causa di una condizion~ di 'hrea.12"). Ucili7.7.atc la tecnica che avere appreso in quesco esercizio per rimuovere l'iscrm.ionc di interruzione dal programma delfa Figura 4.11 .
CAPITOLO
5
4.3 7
4 .38
I )
Le funzioni Obiettivi Comprendere come cosrruire i programmi in ~odo modulare partendo da piccoli pezzi chiamati fum.ioni. •
farà il scgueme frammento di prngramma? fo r (i= 1 ; i<= 5; i++) { Che cosa
Inrrodurre le comuni funzioni matematiche disponibilinella libreria standard del C. Essere i.n grado di creare nuove funzioni.
•
-fo r ( j = 1 ; j <= 3; j ++) { for '( k = 1; k <= 4; k++) printf{ "~ ''); printf{ • '"");
Comprendere i meccanismi tLtilizzari per passare le.infomiazioni alle fi.u11.iot;Ù.
•
Introdurre le tecniche disimulaz.ione d1e utili7Zlllle1a generazione dinurneri c.'l.Suali.
•
C-<>mprendere come scrivere e urili'l.z.a.rè le funzionj che richiàlnano se stesse.
}
pr i ntf ( '' \ n • ) ;
Descrivete in generale comesimuovcreste ruue le isrru2iò11i continue dal ciclo di un programma, e come le sosri 11ù resre con qualche ist:ru.zione smm:w:ara ~quivaleme. U cilizzau: la tecnica che avcte svilupparo in questo cserci:iio per cimuovere l'istruzione continue dal programma della Figura 4 .12
4·.39
Descrivete in generale come rimuoveresre le istruzioni break da una srruuura switch e come le.sosrituiresce con qualche iscruzione strurruraca equivalcnre. Ucil.izzare la recnica (forse scomoda) che avere sviluppato in questo esercizio per rimuovere le ismuionj break dal programma della Figura 4.7.
4.40
/
5.1
Introduzione
La maggior parre dei programmi per computer che siano stari scritti per risolvere problemi dd mondo reale sono più corposi dei programmi presentati sinora, in questi primi capiroli. I.:esperienza ha dimostrato che il modo migliore, per sviluppare e amministrare un pTOgramma corposo, è di cost:ruirlo panendo àa pezzi p_iù piccoli o moduli ognuno dei quali sia più maneggevole del programma originale. Questa tecnica è derra dividi e conquista (dal larino divide et impera). Questo capirolo descriverà le cararrccistiche dd Linguaggio C che Facilitano la progertazione, l'implementazione, il funzionamento e la manutenzione di programmi corposi.
5.2
I moduli di programma in C
1 moduli in C sono chiamatifim.zioni. I progra.mmi C sono scrirci tipicamente combin d i enrrambi i ci13i di fun.z.ione. La libreria standard deJ C fornis~e una cicca collezione di funzioni per esegu ire i comuni calcoli macemacici, per la .w;lnipQl~<.me delle stri nghe e dei cararreri, per l' inp ur/oucpuc e per moire altre operazioni utili. Ciò renderà pi ù sempUce il lavoro del programmatore, poidlé lé suddette fu nzioni forniranno molte delle capacità di cu i egli avrà bisogno.
Buona abitudine 5.1
Familiarizzate con la ricca collezione di funzioni ;ncLuse nella libreria rtttndard de/i'ANSI C.
126
CAPrrorn 5
LEFUN210NI
127
I ngeg;neria dei suftware 5.1 Evitate di inventare nuovamente In ruota. Util~te le fimzioni incluse nella Libreria standard rlell'ANSI C, qual.ortt sia possibile, invece di scrivere delle nuove fimzi.
worker 2·
worker 3
Utilizzare le fimzioni della libreria standard d.eli'ANSI Caiuterà a renderepiùportabili i programmi. Per quamo le funzioni della libreria standard n<>a facciano cec.nicamente parte dd linguaggio C, esse sono fornire immancabilmente con tutà i sistemi conformi allo sraudard ANSI C. Le funzioni printf, scanf e pow che abbiamo utilizzato nei capiroli precedenr.i sono appunto delle funzioni della libreria standard .
Per defìni·re dei compiti specifici, il program.mai;mç porrà scrivere delle funzioni che possano essere ucilizzate· in molti punti del programma. Queste sonp a volre c;hlauiace fonzioni definite dal programmatore. Le ist:rnzioni che ddì.niscono effetti vameme la funzione, sa.ranno scritte solo una volta e saranno nascoste alle alrre funzioni. Le funzioni sono invocate da wu chiamata di fimzione. Q uesta specifica il nome della funzion e e fornisce d~e i.nfurmaz.ioni (gli argomentt) di cui la funzione chiamata ha bisogno, per mmplewe le anivirà per le quali è scaca progerrara. Una cipica malogia per runo ciò è queUa dclla scrurrura gcrarchic::a di un'azienda. Un capo (la funzione chiamante o chiamante} chiede a un' operaio (la fonzione chiamata) di eseguire un compito e tornare indietro a. riferire, quando il lavo(ò sarà staco e.seguito. Per esempio, una funzione che voglia visualizzare delle informazioni sullo schermo richiamerà la funzione operaia printf per eseguire quel compito, in ~guito printf visualizzerà le.suddette informazioni e comedLindie.cro a riferire, ovverosia restituirà il controllo del programma, alla funzione chiamante quando il suo compito sarà stato complerato. La funzione capo non sa in che modo quell'operaia ~à i compici che le sono sc;rri assegnati.. Eopcraia potrebbe anche nchiamare alrre funzioni op etaie e il capo non ne sarebbe a conosc.enz.a. Vedremo presto in che modo questo "incapsulamento" dei dercagli dcll'ìmplemèntazione promuoverà una buona progettazione dcl sofrwàre. La Figura 5.1 mostra la funzione main mentre comunica c:On diverse operaie in modo gerarchico. Osservare che worker 1 agisce come una fimzione capo per worker4 e worker5. le relazioni craJe funzioni potrebbero and1e essere diverse dalla strurrura gerarchica mostrata in questa 6.gW'a.
S.3
worker 4
Figura 5. 1
Re lazione gerarchii::a tra la fu nzione capo e.quelle operaie.
1
printf( '%.2f", sqrt(900.0));
Nel momento in cui quesra iscruzione sarà eseguica, sarà invocata la funzione sqrt della libreria matematica per calcolare la radice quadrar.a del numero conrenuto nelle parentesi (900 . 0 ) . li n umero 900 , 0 è l'argomento della funzione sqrt. I.:isrru1.ione p recedente visu.alizzerà 30, 00. La funzione sqrt accerta un argomento di òpo double e resciruisce un risultato double. Tutte le funzioni della libreria matemarica restiruiscono il tipo di dato double.
Bu.ona abitudine 5.2 f ndudete ii file di intestazione matematico, 11.ti.lizzando la direttiva del pt·eprocessore #include , quando utilizzo.te Le fanzùmi della libreria mmematica.
Errore tipico 5.J Dimenticare di includere ilfile di irrtestazione mateJnal:ico, quando si utilizzano lefimzùmi della libreria matemntùa, potrà provocare dei risultati strani. Gli argomenti della funzione possono essere delle qmanci, variabili o espréSsioni. Supponendo che c1 = 13,0, d = 3,0 e: f = 4,0, l'istruzione printf(",9 6.2f", sq 1•t ( c1
Le funzioni della libreria matematica
Le funzioni ddla libreria .matematica consencono al programmatore di eseguire celi cipici calcoli matematici. In quesco conresro urilizzeremo v arie funzioni maremariche per introdurre il concerto di funzione. Più tardi nd libro, discureremo moire delle alcre ~oni incluse nella libreria srandard deJ C. Una lista completa delle funzioni incluse nella libreria standard del C sarà fornita oell'Appencilce B. NonnaJmeme le fum.ion i sono utilizzare in un programma scrivendo il nome delle sresse, seguiro da una parentesi tonda aperta, dall'argomentu (<;>ppure da una lisca di argomenti separati da vicgole) della funzione e da una parentesi conda chiusa. Pei: esempio, un program,m ~tored1e desideri cakolare e visualiz.z.are la radice quadraca cli 900, 0 pocrà scrivere:
worker 5
+d
• t) )i
calcolerà e visualizzerà la i;adice quadrata d i 13,0 '+- 3,0 ~ 4,0
= 25,0, vale a dire 5 1 00.
Nella Figura 5.2 sono riàssunte alcune delle funzion i incluse nella libreria mare_m atica del C. Nella figura le variabili x e y sono cli cipo doubi.e.
S.4 Le funzioni Le funzioni conseruon0 al programmatore di suddividere in moduli un programma. Tu a:e le variabili dièbiarate nelle ddìnizioni dì funzione sono variabili locali: esse sono n oce solmnto in quella in cui ,soao srate definite. La ma~gior parte delle funz.ioni con_ù ene una lista di parametri.. Questi forniscono il mezzo per comunicare l_e infoana.7.ioni tra le funzioni. Anche i parametri di una funzione sono delle variabili locali.
12$ Funzione
Descriziòne
Esempio
sqrt ( x)
.radk:e quadrata di x
s qrt(900.0 ) ~30 1 0 sqrt (9 .~) è 3 1 0
exp(?C)
.funzione esponenziale e
exp( 1 .0) è 2 , 7f8282 exp(2.0) è 7 ,389056
l og(x)
logaritrri.0 namralc di x (in b.ase e)
log(2 . 7182&2} ~ 1,.~ 16g(7 ..389056) è. 2 , 0
l,og10(X)
lògl!.ritmq di x (in. bas~ l ò)
log:10(.1 . 0 ) è 0 , 0 log10 ( 10. 0.) è 1 , 0 lo_g1~ ( 100 . 0) è 2,0
di ~tarda.ripèri:t.i.one del çodic;è.all'in,remo di un prégramn1a. lmpadiertare il C0dicein forma di fu..dzi~n~ éOP.senti·~à allo sr~o di essete eseguit.o in div
Ogrti fanzù;né dtivré.b}Jè /Ji'nitr11.-si a èsèfJ.tlre w1 compito iir.z.goliJ e ben definito, m111ztre il n~1té d.dlafim~ione. dmirebbe.esjfrfmere·.efficacé17~ente quel cony>ito. Giò faciliterà l'astt-a-
zume upromuo.ver:à ltt riusabilità del softwtlre. Ingegneria del ~oftware 5. 4 Se non ;·ùisdte Il sctgUài tt?l. f1a'IJ1è çonr:iso cheJ1tprhnii t'at.tiviti'I. svolta dalla vomnfrtnz.iime, è problibile che t{l.tttstà stià tffntàndii di eseguire troppi compibi diversi. m questi. ~asi, di solito è meglio s.uddivideda in·.diverse fan.zioni più piceale.
val.o re asso Iuro çl.i .x
se x > 0 allora fabs(x) è x $e x = 0 aUora t abs (X ) è 0 1 0 se x < 0 allora fabs( x ) è - x
arrotonda x aU' imero pi_ù. pii;:.eqlo non minore dix
ceil(9 .2)
floo r (x )
arroroncla iX" all'in ter0 ·pi:ì.i: grande nh n m·3:~1ore dix
f .loor (9 . 2 ) è 9 , 0 floor (-9 . 8 ) è -10,0
p9w(x,
x elev~co alla _pgrçnz.a y O
pow( 2 , 7) è 128 , 0 pow(9 , . 5) è 3.0
degli mcen cpmpre§J tra 1 e J.O (Figy.ra 5.3).
fmoél(x, y)
resto di x:!r in-virgola rnobile
fmod(13 . 657 , ? . 333) è 1,9§12
#i~eludi
sin (x )
.~ei'le> rrigonametrlco di x
s i n(0 . 0 ) è 0 ,0
fab$ (X)
ceil(x)
y)
(x è espr.essa.ì.n cos(x)
tan( x)
è~ 10 , 0
ceil( -9.8) è -9 , 0
(adiaotP
coseno rrigonomfiltico dix (1! 'è espressa in ntdiru;ìri)
é.65 ( 0. 0•) è 1 , 0
ra.ug~tevi.go.norn~tdca di x
t an(0 . 0 ) ·è 0, 0
5.5 Le defmizioni di funzione Ognuno :d.ei programmi c:he :i_bbiamo presen~to ·è stato for.Lliaro da: una :fun,ziQ'ne clriarnata main c;hc;, pi';r eseguire i propri compiti, ha rié:hia.rnaro quelle della li'.brer.ià scandard. Consider.iaoio 'o ra in che modo i programmacori possano scrivere le proprie fun:zion i pers0nalizzare. ~;~nsi~rate . un .pmgramma chç urili.zJ.;i
r1iCl P.
funzione square
per c1k:'olare j
quadraci
I * l)na funzione :?Quare qefJ.n-ita dal p.rog ra·mmatore * /
i nt square(int);
I* prototipo a.ella funzione */
main () {
i nt X;
(icè espressa in J:':\iliami): Figu"a S·. 2
u.rµi
for (x
Funzioni comunemente utllizmte.della libreria matematìc~
Ci sonò ruvér.Semt>.tiyazioni per "Sl;lddividere in funziom".1+11 programma. l'.~pf!rQçcie div.idi e conqu ista rende maneggevé:>lè lo -svilup,p0 del pmgrammà. Un'-alrr~ moriv(lzione ·è là riusabzY.ità del-software. u~eJe funzioni esistenti come l;)Jmiehi di-cosrruzjoru: p,er deare i tiuovi p.rogtammi. La du~abillr.à de! ~.oftware è UJl0 degli d emenl!i principali del mov.im.éfro per la pto·~6.pe . orienr.a.ta. agli qggetti. Con ill! brnn_1.ng!11e di funzione e uAa buona.ddìnizioae, i prog~~pa-çràri no e'S.$µe çtea_ri da fl.1nzigni sranda:rdizzare·4ie ~eguao<;> dei compici sped:fki, piutì:o:sro che es5ét:e co5trlliçi uti:llzzando un çodiçe per-g~r'I~. Ql!est.a te~ni~ ç eqno~ciuta €6nie astrazi.om. Noi usiamo l'astrazl.bne·ogni volta.clìè serivia:.ino dci.prqgrammi che includano de.llefunuon:i incluse nella librcii:israndard, come printf sçanf è pow:Un.a ter~.a rqocivaziouè è I
•r,
10 ; l!<++) sci uare(x));
µr:i ntf ( ~ \n"); l"'eturn 0;
htgigntrin. dt.L iàjt:Waré 5.2 Nei programmi contenenti molte fimzioni, main potxebbe.essérè impkment_q.to ciJfhe u71 gruppo di çhiamate a fim;liioni che eseguono il grosso Il.et lavbro deiprogram1nit.
= 1j x -=
pri.ntf("%d
}
'/" De'tini:ilorie délla funz;ione *.I
int
squ a r~(irit
Y)
,.
{
returh y .. y; }
['
f
4
Fig ura S.3
9
16
~li
36
49
64
81
1100
Usare una funzione definita dal programmato r.e.
J
CAPITOLO
130
5
~ B11ona abimtline 5.3
lf2J
La funzione squa re sarà invocata o richiamata nel eorpo di ma in all'illrerno· dell' iscru-iione printf ", squar-e(x));
La funzione square riçeverà una copia del valore di x nd parametro y. In séguito square calcolerà y • y. li risulraro sarà restituito alla funziqqe printf all'imerno del main n~I punco dell'invocazione di square e printf visualizzerà il risultato. Questo processo sara ripetuto J O voi ce uciliz.zando la srrurrura di iterazione far.
La definizione di square mosa:a che questa attenderà il paramerro inrero Y. La parola cbjave i nt che precede il nome della funzione in-dica che square restituirà un risulraco incero. L'imu'Zione return neJla fum.ione square i:estin,ùù il risultato deJ eak9lo alla funzione chiamame.
La riga int square(int); è un prototipo di fo~one. I.:int all'incemo delle pareruesi informa il ~n~pilawreche square si aspercerà di ricevere un valore intero dal chiama:nre. L ~n~ alla s1~1sua del no~e della funzione square- infoDDa il compilacore che qu~ca resmwrà al ch1amance un n~ultato incero. Il compilarore farà riferimemo aJ protocipo della funzione, p~r .c~ncrollare.. ~e le c:hiamate a s quare contengano il tipo di riromo correrro, il numero e 1 cip1af'propnan per gli argomenti e che questi siano forniti nell'ordine corretto. I prococipi di funzione sara.Jino trattati in dettaglio nella Seziaoe 5.6. Il formaro dì una definizione dj funzione è
Dimenticare di rertituire un valore da una funzione che dovrebbe farlo potrà condurre a erro1·i inattesi. Lo standard ANSI stdbilisce che il ris11lt11to di questo tipo di omissùmi sarà indefinito. Erroré tipico 5.4 Restituire un dato dtt untt funzione il cui valore di ritorno sia stato dichiarato di tipo void provocherà. un errore di sintassi. Buona nbitudiné 5.4 Stabilite sempre in modo esplicito il ripa di doto restùuùo, anche se lo, sua omissione farebbe restir:uirc un int per default. Il tipo restituito da main, invece, è normalmente omesso. La lista dei par4men-i è un elenco concenc11re le d i.i:hiariu.ioni dei paramelri, separati da virgok, c;he saranno ricevu ti dalla funzione quando sarà richiamata. Qualora una funzione non riceva alcw1 valore, la lista deiparnmetri s:uà void. Il tipo di ognuno dei pataì:nerri dovrà essere specifìcaro esplici(amente, salvo che .non siano di tipo int . Infimi, qualora non sia scaco specifìcarq il con~pilacore presumerà che si trarci d i un int.
Errore tipico 5.5 Dichiarare i parametri della funzione, qualora siano dello stesso tipo, usando la fimna float x, y invece che float x, float y. La dichiarazione flost x, y in realtà renderebbe y un parmnetro di tipo int, poiché int è il default. Errore tipico 5. 6
! ul'z iJrrore di sintassi inserire un punto e virgola, dopo la parentesi destra che chiude l'elenco dei parametri in una definizione di funzione.
Inserite una riga vu()ta tra le definizioni di funzione, per separarle e aumentare lo leggibilità det programma:
printf(''%d
LEFVN7.IONJ
Errore tipico 5.7
dichiarazioni
,! rm errore di sim-assi ridifini;·e un parametro d~Lla funzione come variabile loc11le alla stessa.
istruzioni
di.
Il nome della funzione è un qualsiasi idenrifìcacore vilido. Il tipo dei vawr:e ri~rno è quello del risulraro restituiro al chiamame. Il tifo def.:valore di ritorno void tnd1ca che un-a funzione non resùruirà alcun valore. Un tipo det valore di ritorno non specificato sarà sempre conside~o un int
Errore tipico 5.2 Omettere il tipo per il valore di rirorrw in una definizione di funzione causerà tm errore di sintassi, qualora il proeotipo della fimzione specifichi per il valore di ritorno un tipo diverso da int.
Buona abitudine 5.5
lndudere ii tipo di dato per ogr.1i parametro presente nel relativo elenco, nnche qualora fosse d.el tipo di defouit int. Buona abitudin~ 5. 6 Per quanro non sirf. scorretto farlo, non utiliuate gli stessi nomi pttr gli argomenti passati fl una fimzùme eper i corri.rpondenti parametri inseriti nello, relativa definizi.one. Ciò aiuterà a evitare ambiguità. Le dichiarazioni e le istruzioni inserire all' imernò delle parentesi graffe for.mano il cotpo della jù.nzione. U cor_pò della fum.ione è chiamato an~he blocco. Un blocco è semplkemeni:e un'i,muzione r:omposta che include d elle dichi:arazioni. Le variabil i potranno essere
CAITI'rn.O 5
152
di'chiarat.e in qualsi·asi b locco~ questi pottanne ess,~re nidificati. Una fitnzione non può..rnai l!§s41t .4efì'1'iitil "aitintenw r.li u1la/.trt1 fonzffJ..tre.
El ~
Enw:e tipico 5. 8 Defi.nire una. funzione all'interno di un!aftra funzione è im errore di J'intassi. Buona abit11Jd.iné·5. 1 Scegliere dei nomi. difunzione e. di pttrllmetto.sig11#ficaiivi i'rtndérl/. i progrtli'!lttIÌ pif.t le%2}.b/.li e ahtterà a eu.itar.e L-'itsn. eccessivo dì commenti. lngegt1flria del rtiftwm·è 5.5
133
S.6 I prototipi di funzione Una delle p iù impga~~çcçrìsriçlie ~çlrANSJ çç il prowtipo di,fatizio~ncpmimw.ddi'ANSl ç pr~~ in pre,stito quesra. Gtt:arreriscica dagli syil.npp-ar0ri del t++. Un prorocipo di fu.niiòoe inçl.ica aJ compiL"U,orè;, il cipo dd dam tesri'PJJ-rv cblla fun~ion.e, il nurnerb dei p~ameai.clie quella si aspecra di r.ieev~:~, il cipo dci paramerri e l'ordine in çui questi sono arresi. Il tompilacore utilizzerà i pro:tot!ipi per·.ngono rim:ediq a questa la.cuna.
Una ftmziòné non dovrebbe essere più L1mg4. d.i i1:Ua pO:g/n11.1v1;eglio ancora,, 11-1111 jìtnzione non do11reb'be es.sere più lu.nga di una mizza pagù:i.a,. Lefo'ri$iorii picèolif fo.voriseono la riusabilità dei sofiwa111:. .
1 * Trovare i l. mC1,ggiore di tre interi "/ #in~lude
]ng'f;flleriu, del !Oftware5.6
m:ain ()
I prògrarhmi dovrebbero essere scritti come cq[Jezio'tli di fim~iò.n~p.iccole. Ciò ti tende.rn più semplici da'·scrivere., c'Oi/audt1r.è, mitt.ere n. pttitto e modifica.re.
Und.fa.i:i::it»it. chericbiet:/4. u~,gil~n nt.f;ntro:dipàràmettip'(ft:rebbul_o'l/.P-wolgel'e troppi compiti. Gòniitfertttet/à po1sibilim di SJ4d.i.vidérla in funzùmi più pitcok che tef.égt:lit:Jto de.i ciimpi# diliimi.. Eùitestazùme del/afimzionè tlovre.bbe 1ientrare in 1d14 rigtJ.., se passi.bile_. lt.tg~gner.ia dei softwq,re 5. 8
l/.pi
retu r n 0;
1* Defi ni.z_ion-e della funzione maximum * / int max_imum(i.nt x, int y, int z) {
int
è srara i.tw0cm~
espressione;
restituirà a1 chiamante il valore del!' espressi.one.
Il no~tio-second~ èsempie .utilizièJ:à 1.ali:u:µ,ione·m·aximom defìnirn dall'ueen.ce, per de..terroinarè e .resrituiré il .rD.a~iore fra rr.e inreri {Figura ).Zi). I rre interi s:a:rann.0 presi in input con sc~nf. In seguiro, gli inceri saranno passà.ri àlla .funzione max·irilum che derer;:mineFà quale· sia il roaggime di essi. QueStO val'oJie sara resÒmitO aJ ma i n dfil'isrruzi.Ìoae re:turn deÌI;!. funz.lone maximum. 11 val~r.c: :r~rituiro sarà assegnato alla variabile l a·rgest çhe ~ v1~1,1a!izµta in s(lgµito ..d.a printf .
= ~i
H (z· > max) max
r:-èturn;
~etur~
max
i f (y >= max) max = Yi
ca. N:Gl casp io cui Ja lì.m:do'.ne· non re.s.tiruisca alcnn risulta.Co, iJ controllo sarà r~cituito sempliéemcm,.ré qua,nd!) sarà r~ggiunra. l;i p:aremesi graffa destra che ch.iude la. fun~ione, oppure .ei;egueudò l'isrrnz1cine Nel caso che la flmzi0ne rescitujsca .un risultare, J'is.rmziohe
dell.a f. unzione
i nt a, çi. g;;
lngegn'éria del s-oftware 5.1-
~
I"' (1rçito'tipQ
int maximum(int, ìnt, int};
= z.;
return max; }
linteP 'l:fìr.-ee in,1:e:gers·:
2~
85 H
Mtttdrllu(ll is: 00
Ente.a tllooe i(lte\QEHi·s ·: 85 .22. 17 Mpxd.rnum is: 85
Enter ttrr.:e'El :lln•te,ger..s ·:
.22.
17 8&
Matcimuf!l is;: 8'5,
Figura 5.4
la funzione maximum definita dal progr?mrnatore.
*f
CAPITOLO
5
Buona abitudine 5. 8
lnrludete per tutte /,e fimzioni; rekttiviprowripi in nwdo da trn.rn vn.ntag,gio daUe cop1uità di controllo di tipo implementate 11el linguaggio e Utilizzate k dirl!tti11e liinclude del preprocessore per ottenere, dai file di intestazione op-propria.ti, i prototipi delle fimzioni incluse nello libreria rtandard. Utilizzate inoltre liinclude per ottenere i.file di intertazione contenenti i prototipi di fimzione utiliuati da voi e dai membri dei vostro gruppo.
Il procoripo di funzione per la maximum dellii.Figura 5.4 è
135
L BFVNi.'.IONt
Le regole: di promozione si applicano automaric:ameme alle espressioni che contengono dei valori di due o più cipi di daro, derte anch.e espressioni di tipo mi.sto. Ogni valore in un'espressione di cipo misco sarà promosso aucomacicamcme a quello più alro dell'espressione (in realcà, sarà creaca e urilizzata w1a versione cemporanea cli ognWlo dci valori: quelli originali rimarranno invariati). La Figura 5.5 elenca i tipi di dato nell'ordine da quello più alto a queUo più basso, con le relative specifiche di conversione per printf e scanf. Specifiche di conversione per printf
Tipi di dato
Specifiche di conversione per scanf
int maximum(int, int , int) ; Quesro prototipo di funzione stabilisce che maximum riceverà çre argomenti int e restiruirà un risultato dello stesso tipo. Osservare che il prorocipo deUa funi.ione maximum è uguaJe alla prima riga della sua definizione, eccetto che i nomi dei paramecri (x, y e z) non sono stati inclusi.
Buona eibitudine 5.9 A volte, i nomi dei ptll'tJTtietri sarannò incli1si nei prototipi di funzione pet scopi documenmtivi. In ogni modo ii compilamrè' li igm7rèrit_. Errore tipico 5.9 Dimenticare ii punto e virgolo alla fine deL prototipo di funzione provocherò un errore di sintassi. Una chiamata di funzione che non corrisponda aJ suo proroàpo provocherà un errore di simassi. Sarà generato un errore anche qualora il prmoàpo e la defìn.izione della funzione non concordino. Per esempio, se il prococipo della funzione nella Figura ?.4 fosse sra.co serino come void maximum(int , int , int) ;
il compilatore avrebbe generato un errore perché il àpo di ritorno void, indicato nel protocipo della funzione, sarebbe scaco dive~o da quello int specifìc::aro nell'inn:sraziooe della Stessa . • Un'alcra imporcanre cararceci.scica dei procoripi di fu.azione è la com:izione degli argomenti, ovverosia la amversione forzara degli argomenci al ripo appropriaro. Per esempio, la funi.ione della libreria macemacica sq rt porrà e.ssere richiamata con un argomento incero, fi.ul.Zionando ancora correcramente anche se il suo prototipo in math. h specifica. che l'argomento debba essere di tipo double. t:iscruz.ione pr'int"f (" %.3f\n 1'
1
sqrt (4));
valurecl correrramence sqrt ( 4) e visu.afuzer.à il valore 2, 000. n protecipo di funzione fà in ,modo che il compilarore converta il valore intero 4 in qudlo cli tipo double 4, 0, pdma che lo 'Scesso sia passare alla sqrt. ln generale, i ~alori degli argoin~n.ri che non corrisponda.no precisamenre ai cipi dei para.merci defoùci nel prococipo sà.rànno converri:ri in modo appropriato, prima che la funzione sia richiamata. 1àli conversioni po.crebbero però causare dei risulraci scorretti, qualora non fossero rìsperrare le regolè di. prortJozione del C. Tali regole specificano in quale modo i vari tipi dj dato possano essere convertiti tra loro sem..a perdita di informazioni. Nel nostro esempio con sqrt, un int sarà convertiroautomaticuneme in un double senza che ne sia modificaco il valore. Nondimeno un double ~oovertito in int troncherebbe la pane fuu.ionaria del valore double. Anche converrire i ripi più grandi degli inreri in quelli più piccoli (per esempio, un long in uno short) potrà produrre dei_val.ori modi:frcaà.
l\slf long double l\sf double l\sf float unsigned long int l\slu long int !lsld unsigned i nt !lsu int l\sd short l\shd !\se char Figura 5.5 Gerarchìa di promozione per i tipi di dato.
\Lf \lf \f
\lu \ld \u
l\sd l\shd \e
Convertire dei dati nei cjpi più bassi produce normalmente dei valori scorrerti. Di conseguenza, i valori potranno essere convenici in un tipo più basso solo assegnandoli esplicicamence a una variabile di ripo più basso, o utilizzando l'operacore di conversione. 1 valori degl i argomenri d i funzione saranno convertici ai ~dpi dci parametri defin iri nel relarivo prororipo, come se fossero stati assegnaci direrramencc a variabili di quei ripi. Qualora la nosua funzione square che ucilizza un parame.rro incero (Figura 5.3) fosse stara richiamata con un argomenc:o io virgola mobile, quéSro sarebbe sraco converrito in un int (un npo più basso) e square avrebbe resùruiro un valore sco.rrerro. Per esemp.io. square (4 . 5) resrimirebbe 16 invece di 20, 25.
[iJ
Errore tipico 5. J O
Convertire w1 tipo di dmo più alto, rispetto 1tlla gerarchia di promoziom:. in uno più basso potrh modlfic1m1 iL vawre dei dati. lL compilatore forme rà un $UO prorodpo di funzj9ne, qu;tlo.ra questo non sia staro incluso in un programma, urilitzando la prima qi;:a»rreru:a del.la fll.flzione: ovverosia. la défìni.i iooe o una sua chiama.ca. Per default, il compilacore assumerà che la funzi one rescicut...-ca un. int e non presumerà nulla relacivam.ence agli .argomemi. Ne consegue che, qualora gl i a.rg0menri passati aJla funzione non siano corretti, gli errori non sarann o individuaci dal compilatore. Error~
tipico 5.11
Dimenticare un prototipo provocherà un errore di sintt1.ssi, 9ualora ii ripo restituito dalla funzione non sia un int e la definizione di quei/a appaia nei programma dopo una sua chiamata. In caso contrario, dimenticare iLpr(!t(Jtipo di una ftmzùme potrà causare tm errore durante la fase di esecuzione, oppure u11 risu./tato inatteso.
l
136
CMrro.LO 5
Ingegneria del software 5.9 Un prototipo inserito all'esterno di ogni defini:à.one di fimzùme si applicherà a tutte le relati vi: invocazioni che appariranno nel file dapo il prototipo. Un prototipo inserito a/L'interno di ima funzione si applicherà so/o alk chiamate eseguite all'interno della stessa.
S. 7 I file di intestazione ?gni Libreria standard ha un rorrispondenre file di, ir:te:rtazibneche ronriene i prototipi per tu ree le tunzioni incluse in qudla libreria, olrre che le defìnizioru dei vari tipi di daro e delJe cosrami oecessa.rl a quelle funzioni. La Figura 5.6 elenca alfabeti<::ameme i file di intestazione della libreria srandard che potranno essere inclusi nei programmi. Il termine "macro", usato diverse volte nella Figura 5.6, sarà rrarrato in dercaglio nd Capitolo 13, "11preproces.5ore".
137
lEFUNZIONl
File di intestazione della libre ria standard
Comiene le defìnifjoni comuni dei tipi di daro utiliz-Lari dal
c per eseguire cenj calcoli.
Conriene i prototipi per !e fun7.ioni d i inpuc/ourpuc della libreria s1.andard e le informazioni utilin.ate da queste ulrimc. Contiene i prorocipi delle l;ùnzìoui per 1a conversione dei numeri io ceSto e viceversa, p.ér l'allocazione della memoria, per i nwneci casuali e per altre funz.iouidi uàlità generica. Contiene i promcipi delle funzioni per l'elabora;o,ione delle srrtogbe. Contiene i prororipi di fùuziòne e j [ipi per la manipolazione dèll'o.ra e déllc dat,e.
<~tdlib. h>
File di intest azione della libreria standard
Spiegazione
Conriene le macro e le informazioni per aggiungere delle istruzioni diagnosridie che forniscono un aiuco duranrc la messa a punto del programma. Contiene i prototipi per le funz ioni che verifìcano talune propcierà dei ca.rarrcri, nondié per quelle che porranno esse re utilizzare per convertire le lettere minuscole in maiuscole e viceversa. D efinisce le macro che saranno utili per comunicare le con dizioni di errore. Contiene ~ limiti del sistema per la dimensione dei valori in virgola mobile. Contiene i limjci del sistema per la dimensione dei valori inceri. Conciene i prorodpi difuazio:ne e alrre informazioni che conseo tiranno a un pro~ram:ma ili essere ada[tato alla località in cui sarà eseguito, La nozione dj località co:nsenre aJ siscema di gesti re le diverse convenzioni ·delle-varie aree del mondo per espri mere infori:naziqpj c0 m<;; la dara, l'ora, la valuca e i grandi numen. Concieoe i protocipi per le. funzioni della Libreria matemarica. Contiene i prototipi per le funzioni che consentono di aggi rare l'usuale sequenza di chi<1mara e ritorno da Funzione. Contiene i prococipi di funzione e le macro per gestire le va rie condizioni che porranno insorgere durance l'esecuzione del programma. Definisce le macro che conscritono di gestire delle funzioni per le quali il numero e i tipi d~i argomenti siano sc.onosciuri.
Spiegazione
Figura S.6
I file di intestazione della libreria standard.
Il programmatore poc:rà creare dei file di inresrnzio.ne permnalizzaci. Anche i me di inccsrazione definiti dal programmatore dovranno rerminare in . h e potranno essere inclusi utilizzando la dlrettiva del preprocessore #include. Per esempio, il file di intestazione square. h potrà essere incluso nel nosrro programma dalla dlretriva #include • square.h " posta all'inizio del programma. La Sezione 13.2 fornirà ulteriori informazioni sull'inclusio-
ne de.i fìle di inresrai.ione.
5.8 Invocare le funzioni: chiamata per valore e per riferimento ln molti lillguaggi di programmazione esisrnno due moru per invocare le funzioni: la chittmatt1 per valore e la chirm111tn per rijèrimento. Quando gli argomenti saranno passati in una chiamata per valore, sarà preparata una copia dei loro valori e questa sarà passara alla funzjone_cb!amara. ~e modi~che efferruate alla copia non inreres.seranno il valore originale della va:rn1bile definita nel chiamante. Quando un argomento sarà passato in un.a chiamara per riferimento, il chiamanre eonsemirà efferrivameme alla funuione chiamara di modi.fìcare il valore originale della variabile.
Le chiamare per valore dov,rebbero essere ucilizzare ogniqualvolta la funzione chiamata non abbia la necessità di modificare il valore ddla va:riahile originale defLllita dal chiamante. Ciò pr.ev.e rrà gli effetti collaterali accidcmali che inrralciano pesanremente lo sviluppo di sisremi sofrware correrci e affidabili. Le chiamare per riferimemo dovrebbero essere urili1.zate solo con funzioni affidabili che abbiano bisogno di modifìcare 1a variabile originale. In C, curte le chiamate di funzione sono per valore. È però~ possibile simulare la chiamara per riferimento, come vedremo nel Ca.pirolo 7, urilizzando gli operatori di indirizzo e quelli di deriferimenco. Nel Capirolo 6 vedremo che i verrori sono passad aurornacicamenre con una chiamata per riferimento simulata. Dovremo aspettare fino al Capitolo 7 per una piena comprensione di questo complesso argo memo. Per ora, ci concenrreremo sulla chiamata per valore.
138
CAJ'ITOLO
5
Generazione di numeri casuali
S.9
LE FUNZIONI {
int i;
Ci prenderemo ora un breve e, si spera, diverrenre diversivo con una popolare applicazione della programmazione, vale a dire la simulazione e il gioco. In questa e nella prossima sezione, svilupperemo un programma di gioco ben strutturato che includerà moire funzioni. 11 programma utilizzerà molre delle strurrure di ç:onrrollo che abbiamo scudiaro.
for (i= 1; i<= 20; i++) { printt("%10d ", 1 + (rand()% 6)); if (i % 5 == 0) printf("\n");
C'è qualcosa nell'aria di un casinò che rinvigorisce ogni tipo di persona; dai giocatori incallici che aaomiano i lussuosi cavoli in mogano e felrro per il gioco dei dadi a quelli che infilano monetine nelle macchinerre mangiasoldi. È l'elemento della casualità, la possibilità che quesra possa convertire una manciata di monere in una montagna di riccheuc. I.:clememo della casualità può essere incrodorto nelle applicazioni per compurer, urilizzando la funzione rand della libreria standard del C.
}
ret urn 0; }
5 2 5 :5
Considerare la seguenre isrruzione: i
=
r and{);
La funzione rand genera un intero coh1p.reso rra O e RAND_MAX (una cascame simbolica defìnita nel frle di incescazionc ). Lo standard dell'ANSJ stabilisce che il valore di RAND_MAX debba essere almeno 32767, cliç è and 1ç il v;tlore massimo per LU1 intero di due byte (ovverosia 16 bic). I programmi di questa sezione sono stati coJlaudati su un siscema C con un valore massimo per RAND_MAX di 32767. Qualora r a nd generasse davvero degli inceri a caso, ogni numero era Oe RAND_MAX avrebbe la scessa possibilità (o probabilità) di essere scdco oglli volra che r a nd fosse cichiamaca. L'imervallo dei valori prodorri direccamenre da rand è spesso differente da quello che sarli necessario in una specifica applicazione. Per esempio, un programma che simuli il lancio di una monccina potrebbe cichiedece solcanco O per "resca" e 1 per "croce". Un programma che simuli iJ lancio di un dado a sei fàcce richiederebbe degli inceri compresi nell'incervallo da l a 6. Per mostrare l'utilizzo cli r and, svilupperemo un pregramma che simulerà 20 lanci di un dado a sei facce e visualizzeremo iJ valore onenmo da ogni lancio. li prototipo per la funzione rand può essere rfrrovaro in . Uri.lizzeremo l'operatore modulo(%) in congium...ione con rand nel modo seguente: rand() % 6 per generare degli inceri compresi nell' interv<ùJo da O a 5. Questa opct"azionc si chiama 1-iduzione in scala, mcnrre il numero 6 è detto fattore di scafa. ln seguiro trasleremo l' intervallo dei nwncri generati, aggiungendo l al nosuo ristJtato precedencc. La Figura '5.7 conferma che i risultati sono compresi neltinre.rvfillc:i da 1 a 6.
Per mosrrare che questi numeri si presénterann6 approssimat:ivamence con la stessa
probabillrà, simuleremo 6000 lanci di un dado con iJ programma della Figura 5.8. Ogni intero da 1 a 6 dovrebbe presentarsi approssimacivan1eme 1000 volre.
/* Gli interi, ridotti in scala e trasl_a ti, generati da 1 + rand() % 6 ~1
#include #include
ma in ()
139
[ Figura 5.7
5
a
3 2 2
5 5
1
14'
4
4
Gli interi, r idotti in scala e traslati, generati da I
]
1
+
randO o/o 6.
/* Lanci a un dado a sei facce 6000 volt.e */ #include #include
ma in () {
int face, roll, frequency1 = 0, f requency2 0, frequency3 = 0, frequency4 frequencys = 0, frequency6 = 0;
0,
tor (roll= 1; roll<= 6000; rol~++) { + rand() % 6; tace = switch (tace) { case 1: ++frequency1; break; case 2: ++frequency2; break; case 3: ++frequency3; break; case 4: ++frequency4; break; case 5: ++trequencys; break;
{cominutt)
14.0
CAPITOLO 5
6: ++f requency6;
break ;. } }
Nella Figubl. 5.9 è m0.sr:fato t',miliizZ<;> della. fum.iqne srand. Nel prqgrarnma utilizziamo il tip0 di darò un s i g'ned.1 cliè è unabbrevìaz.io1tè·pe.r un s i gned i nt. ·un•i nt è immagazzim1:rò in. alm:c.no dù!:! byre ·di tncm·òJia e· può wntenere valori. posicivi e n.ega:àvi. Aoche una v.àliabilé cli ripò ùn signéd è iftu:RagaZizina.ra in alménò due byte di memoria. Un unsigned i nt di èl.ue byte può conrenere s0lcanc0 valori posit ivi compresi nell' inte.r:vallo da O a 6B5~5. Un uns ~g n_ed i nt di quattro byre può avere solo valori posiii:vi çomprnsi ne!l'int<;.FVailo da O ;i 4294~6729?. La funzion:e -srand ac.Get:ta come ai:goa:reuro Ufl v;tlqre 1,m ~igned . La ~peci-fìca di <::QnVèçsiçne \u ç uriliz?-ata p:e.r Ie;gg~e uo yafo.re. unsìgned c0n la fi.uni0nè scanf. TI prQ.to-i;ip,o di funzione per·s r and si, trova in. <.s tdlib . h>.
Qualora volessimo randoIIJ..izzan: senza la necessita di imrnetwre un se.me qgni volta porremmo milizz;_rre un'i:sm.izi,ooe c:ome:
10~.è
3
4
9;74.
5
11004
§
11/l~
Figura 5.8
Eseguiamo diverse volre il programma e analizziam9 i risulrari.. ·o~sçrv~e cilie ~i ott~r rà una sequem.a diversa di numer.I casual i ogni volta clie iJ pr<'lgramma sa4 eseguito, pucché ve.i;lg;i fornito un seme diffe~enre.
Fre<111ie.n ifl~
1· :2
srand(tìme(NULL));
Landare 6000 vo!tè un dado a séi fa~cé.
Riducendo in scala e rraskn.d:0 l 'i:nte.rvalfo, c;o!Jle mustra l'putput del programma, al;>bi_wie. miliz.t(lro la :fu4tjon~ ran.d p~r sÌ:mula.te re;ilisricamente il lanci9 di un chdq 3 ·sei facc~. Qsifetv.aré th'é nojl è 'Staro fO.miro itessim GL,s~:r ru d~faul t ueJ.ia strattu111 SWìtCh. Osseiyate anche J' urili·a.o della sp:ecifka di cònvei:si0ne %s per virualizza.Ee le stringhi: cli caràneri " face ~ e 11 Frequency 11 ~<.mi~ ihresraz.ioni di ctilenna. Dopo aver midiatO. i vettori nd Capitolo 6, mostreremo come sostituire elegantemente l'i'nrera srmrrura swìtch ç9J1 1,1n'i$~z.içne di una ~9J~ riga.
&eguendo nubv.amem:e i:! programma de.Ila Figura 5.7 si produrrà
[
5
6
a
2
4 '3 1
2<
5 !ii
141
in g\:lrgo rm1d01ni~o11ce (da. random, a caso) c;;d ~ ($eguira. con la. funzione s rand della l_ib.r:eri~ St:).,0<4fd. La funzio ne. s r·and ricey~ uri àrg6meur0 inrcro uns i gned e /11jemi1:1a la fumìone r and, in modo da indurla a generare una diversa s:cqutnza di numeri casuali ad ogni c:Secuziòfle del p.rògramma. ·
crn~e
~~é
l.F. FUNZ.ION)
'5
~
5 '5 2
~
6
4
f$.q j
Ql,lesta in:durre.bbe Uçocnputer a leggere il su9 orologio interno _r;i.er ottenere a:uro.m.acic;;amçnrç µn v~lor~ per i.I seme. La fon.tlone time restituisc~ l'om cqm;nte clej giorno e:Spn~ss.à in sec.oodL Qu~sro valer!;: sa.r.à colivefcim. in uo ~m li.cii:z;t segnò e uri.lizzato d>i:i:lé: seme per il generatore cU numeri casuali. La funzitme t ìme riceve.éà. come argomento NULL (nor.tti.iil.ménr.e t ime è Ì:i1 gra:do di forci:ré al prdgrammarme unà. s:rr.inga &e rai:prese.nra l'ora .del giorno; iJ NULL dìsabilirn appunro quc:;sra capaciià per una chiamata speoifìca di time). Il premripo di fwl1..ione per time è iu
