POLITECNICO DI MILANOPOLITECNICO DI MILANO SEDE DI … · POLITECNICO DI MILANOPOLITECNICO DI MILANO SEDE DI CREMONA Anno Accademico 2002-2003 Laboratorio del Corso di Informatica

POLITECNICO DI MILANOPOLITECNICO DI MILANOPOLITECNICO DI MILANOPOLITECNICO DI MILANO SEDE DI CREMONASEDE DI CREMONASEDE DI CREMONASEDE DI CREMONA

Anno Accademico 2002-2003

Laboratorio del Corso di Informatica 1 codice 060012 - 7.5 crediti

www.cremona.polimi.it/info1

Gianluca Attolini

Gianluca Attolini - A.A. 2002-2003 laboratorio del corso Fondamenti di Informatica - Politecnico di Milano sede di Cremona pagina 0

INTRODUZIONE Turbo C++ Menus e Hot Keys........................................................................................... pag. 1 Come si usano i Menu...................................................................................................... pag. 1 Hot Keys ....................................................................................................................... pag. 2 Elenco delle Parole Chiave definite dal C ANSI.................................................................... pag. 4 Per poter eseguire un programma C..................................................................................... pag. 5 Identi ficatori in programma C............................................................................................ pag. 5 Tipi di Dati .................................................................................................................... pag. 5 printf ............................................................................................................................ pag. 6 scanf............................................................................................................................. pag. 7 Scriviamo il nostro primo programma................................................................................. pag. 8 Riassumendo... .............................................................................................................. pag. 9 Operatori ed Espresioni in C.............................................................................................. pag. 10 Puntatori [1]indirizzo e valore puntato................................................................................. pag. 11 Istruzioni di Controllo Condizionali (if else switch) ............................................................... pag. 11 Istruzioni di Controllo Itarative (while for do while) .............................................................. pag. 13 Direttive del Preprocessore ............................................................................................... pag. 14 Funzioni........................................................................................................................ pag. 29 Puntatori [2]& *.............................................................................................................. pag. 51 In Out con FILE.............................................................................................................. pag. 81

ESERCIZI Esercizio 01 (usare il debug del TurboC)............................................................................. pag. 15 Esercizio 02 (vari abili tipi ed assegnamento di valori)............................................................ pag. 15 Esercizio 03 (stampa della tabellina ASCII) ......................................................................... pag. 16 Esercizio 03a (stampa tabellina ASCII gestione output a video) ............................................... pag. 17 Esercizio 04 (cal colo del Vettoriale) ................................................................................... pag. 18 Esercizio 05 (valutazione del maggiore tra due input)............................................................. pag. 19 Esercizio 06 (scegliere operazioni aritmetiche tra due numeri) ................................................. pag. 20 Esercizio 07 (restituire una stringa al contrario)..................................................................... pag. 20 Esercizio 08 (uso di for while do while)............................................................................... pag. 21 Esercizio 08a (veri fica equidistanza di 3 punti)..................................................................... pag. 23 Esercizio 09 (mettere in ordine alfabetico 10 stringhe)............................................................ pag. 24 Esercizio 10 (print f stampe a video formattate) ..................................................................... pag. 28 Esercizio 11 (stampa di char con simboli grafici oltre 127)...................................................... pag. 28 Esercizio 11a (menu di scelta) ........................................................................................... pag. 29 Esercizio 11a1 (calcolo del fattoriale con funzione) ............................................................... pag. 30 Esercizio 11b (stampa di char con simboli grafici oltre 127 con funzione) .................................. pag. 31 Esercizio 11c (stampa di char con simboli grafi ci oltre 127 con menu e funzioni) ........................ pag. 32 Esercizio 12 (scambio valore tra due variabili senza usarne una terza) ....................................... pag. 34 Esercizio 12a (input sequenza di numeri analisi a coppie di esistenza dell'inverso)....................... pag. 35 Esercizio 13 (programma che discrimina input uso di #define ed enum)..................................... pag. 36 Esercizio 14 (programma di lancio del dado uso di rand) ........................................................ pag. 40 Esercizio 15 (programma di lancio del dado con rappresentazione grafica) ................................. pag. 41 Esercizio 16 (programma indovina la parola)........................................................................ pag. 42 Esercizio 17 (programma QUIZ domande e risposte in array) .................................................. pag. 44 Esercizio 18 (mettere in ordine alfabetico stringhe libreria string.h) .......................................... pag. 46 Esercizio 19 (acquisire la pressione di un tasto getch)............................................................ pag. 48 Esercizio 19a (acquisire la pressione di un tasto speciale getch)................................................ pag. 49 Esercizio 20 (gestione di un menu di scelte con funzione e tasti speciali getch) ........................... pag. 51 Esercizio 21 (scambio del contenuto di due variabili con funzione e puntatori)............................ pag. 52 Esercizio 22 (gestione di stringhe di caratteri ARRAY) .......................................................... pag. 54 Esercizio 23 (gestione di stringhe di caratteeri con puntatori)................................................... pag. 55 Esercizio 24 (programma di criptazione di caratteri base)........................................................ pag. 56 Esercizio 25 (programma di criptazione di caratteri evoluto).................................................... pag. 58 Esercizio 26 (stampa del calendario anno 2003 e calcoli tra date) ............................................. pag. 61 Esercizio 27 (programma per raccolta dati di studenti struct) ................................................... pag. 67 Esercizio 28 (battaglia naval e contro computer) .................................................................... pag. 69 Esercizio 29 (gioco delle tre cart e contro il computer) ............................................................ pag. 72 Esercizio 30 (Lista di numeri interi).................................................................................... pag. 75 Esercizio 31 (Rubrica Lista di dati struct) ............................................................................ pag. 77 Esercizio 32 (utilizzo dei FILE) ......................................................................................... pag. 81 Esercizio 33 (Utilizzo dei FILE e Liste)............................................................................... pag. 83 Esercizio 34 (Modularizzazione di un programma C utilizzo FILE e liste).................................. pag. 85


Turbo C++ Versione 1.01 per DOS prelevabile da:

http://community.borland.com/museum/

richiede registrazione gratuita

- Turbo C++ Menus e Hot Keys - L'Ambiente Integrato di Sviluppo Turbo C++ IDE offre tutto quello di cui c'è bisogno per scrivere, modi ficare, compilare, l inkare, eseguire, e per effettuare il debug dei programmi. La Barra dei Menu si trova in alto allo schermo ed è il punto di accesso per tutte le funzioni dell'IDE Per accedere alla barra dei menu: Premere F10, oppure Cliccare in qualsiasi punto sulla barra con il mouse. È possibile scegliere una delle seguenti voci della barra dei menu; - (System); File; Edit; Search; Run; Compile; Debug; Project; Options; Window; Help:

- Come si usano i Menu -

Ci sono tre possibili modi per accedere ai comandi dei menu: Premere il tasto F10 e utilizzare i tasti freccia per scorrere l e voci, quando si è sel ezionat a la voce desiderat a premere ENTER per eseguire il comando. Premere ALT e la lettera evidenziata della voce di Menu desiderata (ad esempio ALT - F per accedere al menu File) utilizzare poi i tasti frecci a per scorrere le voci, quando si è selezionata la voce desiderat a premere ENTER per eseguire il comando. Con il mouse cliccare il titolo del menu desiderato, il menu scende ed è possibile selezionare il comando desiderato cliccando nuovamente Se una voce del menu è evidenziata significa che si è selezionata quella voce I comandi dei menu possono essere seguiti da tre punti o da una freccia verso destra o da una combinazione di hot keys.

… stanno ad indicare che scegliendo il comando si aprirà una dialog box

> sta ad indicare che verrà aperto un sotto menu

CTRL XX sta ad indicare la combinazione di tasti per la selezione rapida del comando


- Hot Keys -

Menu Hot Keys Alt - Spacebar Per accedere a - (System) menu Alt - C Per accedere a Compile menu Alt - D Per accedere a Debug menu Alt - E Per accedere a Edit menu Alt - F Per accedere a File menu Alt - H Per accedere a Help menu Alt - O Per accedere a Options menu Alt - P Per accedere a Project menu Alt - R Per accedere a Run menu Alt - S Per accedere a Search menu Alt - W Per accedere a Window menu Alt - X Esce dal Turbo C++ e torna a DOS F10 Per accedere alla Barra dei menu Editing Hot Keys Ctrl - Del Rimuove il testo selezionato ma il testo non viene

inserito nella Clipboard (Edit | Clear)

Ctrl - L Ripete l'ultima ricerca effettuat a (Search | Search Again) Alt - S R Apre la dialog box di Trova e Sostituisci (Search | Replace) Alt - S F Apre la dialog box di Trova (Search | Find) F2 Salva il file nella finestra di Edit attiva (File | Save) F3 Apre la dialog box per aprire un file (File | Open) Ctrl - Ins Copia il testo selezionato nella Clipboard (Edit | Copy) Shift - Del Mette il testo selezionato nella Clipboard (Edit | Cut) Shift - Ins Incolla il testo nella finestra attiva dalla Clipboard (Edit | Paste) Window-Management Hot Keys Alt - 0 Mostra la lista delle finestre apert e (Window | List) Alt - F3 Chiude la finestra attiva (Window | Close) Alt - F4 Apre la finestra Inspector (Debug | Inspect) Alt - F5 Passa alla finestra User Screen (Window | User Screen) F5 Ingrandisce/Riduce la finestra attiva (Window | Zoom) F6 Scorre le finestre aperte (Window | Next) Ctrl - F5 Porta la finestra in stato di modifica e permette di

modificare la posizione tramite i tasti freccia e la dimensione premendo shift e tramite i tasti freccia

Online Help Hot Keys F1 Apre la finestra dell'Help Online (Help | Contents) F1 F1 Mostra l'ndice dell'Help (Help | Index) Alt - F1 Mostra il precedente schermo dell'Help (Help | Previous Topic) Ctrl - F1 Mostra l'Help specifico relativo al linguaggio (Help | Topic Search) Program-Management Hot Keys Alt - F7 Per accedere al precedente errore (Search | Previous Error) Alt - F8 Per accedere a prossimo errore (Search |Next Error) Alt - F9 Compile e crea il file .OBJ (Compile | Compile to OBJ) Ctrl - F2 Resetta l'esecuzione del programma (Run | Program Reset) Ctrl - F3 Per accedere allo stack delle chiamate (Debug | Call Stack) Ctrl - F4 Evaluates an expression (Debug | Evaluate/Modify) Ctrl - F7 Aggiunge a Watch Expression (Debug | Add Watch) Ctrl - F8 Sets/Clears Conditional Breakpoint (Debug | Toggle Breakpoint) Ctrl - F9 Esegue il programma (Run | Run) F4 Esegue il programma dalla posizione del cursore (Run | Go To Cursor) F7 Esegue il contenuto delle funzioni (Run | Trace Into) F8 Exegue evitando il contenuto delle funzioni (Run | Step Over) F9 Makes (compila/linka) il programma (Compile | Make EXE)


Configuriamo l'Editor tutti allo stesso modo: 1) attiviamo l'opzione: Options-> Full menus On 2) attiviamo le opzioni: Options-> Compiler facendole scorrere tutte nel modo seguente:


BLOCCO

FUNZIONI

- Elenco delle parole chiave definite dal C ANSI - auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while Le parole chiave unitamente alla sintassi formano il linguaggio di programmazione…

- Struttura generale di un programma C -

dichiarazioni globali main ( ) { variabili locali sequenza di istruzioni } f1( ) { variabili locali sequenza di istruzioni } f2 ( ) { variabili locali sequenza di istruzioni } . . . fN( ) { variabili locali sequenza di istruzioni }


- Per poter eseguire un programma C… - 1. Editazione del codice sorgente (editare) 2. Compilazione del programma (compilare) 3. Collegamento del programma con le funzioni di libreria (linkare) 4. Esecuzione del programma (eseguire)

- Identificatori in un programma C… - Sono definiti identificatori i nomi tramite i quali è possibile fare riferimento a: variabili, funzioni, etichette, e altri oggetti definibili dal programmatore. Un identificatore è costituito da più caratteri (di solito il primo deve essere una lettera o al più può essere un under-score il trattino di sottolineatura "_") non può essere una cifra. Affinché gli identificatori siano significativi si devono considerare i primi 6 caratteri per utilizzi esterni al file ed i primi 31 caratteri internamente al file (fare riferimento al manuale del compilatore in uso). Lettere MAIUSCOLE e minuscole vengono considerate distinte.

- Tipi di Dati -

Nel linguaggio C esistono cinque tipi di dati primari: descrizione Tipo bit occupati valori ammissibili carattere char 8 da 0 a 255 intero int 16 da -32.768 a 32.767 reale float 32 da 3,4E-38 a 3,4E+38 doppia precisione double 64 da 1,7E-308 a 1,7E+308 indefinito void indefinito --- Il linguaggio mette poi a disposizione dei modificatori di tipo che si possono applicare a tutti i tipi primari tranne che al tipo "particolare" void: 1. signed 2. unsigned 3. long 4. short Il linguaggio C permette poi di definire tipi di dati aggregati come: strutture, unioni, campi di bit, tipi enumerativi, tipi definiti dall'utente. 5. VALORI DI VERITA' In C non esiste il tipo di dati che in altri linguaggi è chiamato Boolean. Il linguaggio C utilizza la convenzione che: il valore ZERO rappresenta il valore FALSO, e il valore UNO rappresenta il valore VERO (estendendo i valori NON ZERO rappresentano il VERO, quindi qualsiasi valore DIVERSO DA ZERO rappresenta il VERO).


- printf e scanf -

printf Sends formatted output to stdout Syntax: int printf(const char *format [, argument,.]); Prototype in: stdio.h Remarks: printf formats a vari able number of arguments according to the format, sending the output to stdout. Returns the number of bytes output. In the event of error, it returns EOF.

Type character

Input argument Format of output

Numeric types d integer signed decimal int. i integer signed decimal int. o integer unsigned octal int. u integer unsigned decimal int. x integer unsigned hexadecimal int (with a, b, c,

d, e, f). X integer unsigned hexadecimal int (with A, B,

C, D, E, F). f floating pt signed value of the form

[-] dddd.dddd. e floating pt signed value of the form [-]d.dddd or

e[+/-]ddd. g floating pt signed value in either e or f form,

based on given value and precision. Trailing zeros and the decimal point are printed i f necessary.

E floating pt Same as e, but with E for exponent. G floating pt Same as g, but with E for exponent if

e format used. Character types

c character Single character. s string ptr Prints characters until a null-

terminator is pressed or precision is reached.

% none The % character is printed. Pointers

n ptr to int Stores (in the location pointed to by the input argument) a count of the chars written so far.

p pointer Prints the input argument as a pointer; format depends on which memory model was used. It will be either XXXX:YYYY or YYYY (offset only).


scanf Performs formatted input from stdin Syntax: int scanf(const char *format [, ...]); Prototype in: stdio.h ...scanf type characters The following table lists the ...scanf type characters, the type of input expected by each, and in what format the input ill be stored. The information in this table is based on the assumption that no optional characters, specifi ers, or modifiers (*, width, or size) were included in the format speci fi er.

Type character

Expected input Type of argument

Numerics d Decimal integer Pointer to int (int *arg) D Decimal integer Pointer to long (long *arg) o Octal integer Pointer to int (int *arg) O Octal integer Pointer to long (long *arg) i Decimal, octal, or

hexadecimal integer Pointer to int (int *arg)

I Decimal, octal, or hexadecimal integer

Pointer to long (long *arg)

u Unsigned decimal integer

Pointer to unsigned int (unsigned int *arg)

U Unsigned decimal integer

Pointer to unsigned long (unsigned long *arg)

x Hexadecimal integer Pointer to int (int *arg) X Hexadecimal integer Pointer to long (long *arg)

e, E Floating point Pointer to float (float *arg) f Floating point Pointer to float (float *arg)

g, G Floating point Pointer to float (float *arg) Characters

s Charact er string Pointer to array of characters(char arg[]) c Charact er Pointer to character (char *arg) i f a fi eld

width W is given along with the c-type character (such as %5c). Pointer to array of W characters (char arg[W])

% % character No conversion done; % is stored. Pointers

n Pointer to int (int *arg). The number of characters read success fully up to %n is stored in this int.

p Hexadecimal form YYYY:ZZZZ or ZZZZ

Pointer to an object (far* or near*)%p conversions default to the pointer size native to the memory model.


- scriviamo il nostro primo programma -

1) Scriviamo nella finestra di Edit: /* Questo e' il classico primo programma */

#include <stdio.h>

main(){

printf("\nCiao Mondo");

} 2) Una volta scritto il programma utilizziamo dal menu COMPILE -> COMPILE TO OBJ Facciamo attenzione alla finestra dei Messaggi di compilazione ad eventuali WARNINGS e/o ERRORS, se avete scritto bene avrete solo un warning. Se avete degli errors andate a correggere il programma... 3) dal menu COMPILE -> Link EXE File Facciamo attenzione alla finestra dei Messaggi se tutto è andato bene è stato creato il file eseguibile... 4) dal menu RUN -> RUN per eseguire il programma! Molto probabilmente non vederet nulla, infatti il programma ha generato il suo output cosi' velocemente che non ve ne siete accorti ed al termine della esecuzione è tornato all'ambiente di sviluppo... 5) abbiamo tre modi per vedere il prodotto del nostro programma

a - dal menù FILE -> DOS Shell si uscirà dall'ambiente di sviluppo entrando in una shell del sistema operativo dove si può vedere l'uotput del nostro programma. Per tornare all'ambiente di sviluppo scrivere EXIT e battere invio b - dal menù WINDOWS -> USER SCREEN (oppure ALT + F5) si vede la finestra della shell senza uscire dall'ambiente di sviluppo. Per tornare all'ambiente di sviluppo premere un tasto qualsiasi c - dal menù WINDOWS -> OUTPUT verrà aperta nell'ambiente di sviluppo una finestra in cui viene riportato il contenuto della shell, per vedere tutte le finestre aperte nell'ambiente di sviluppo scegliere WINDOWS -> TILE in questo modo tutte le finestre aperte verranno distribuite sullo schermo, io consiglio di lasciare sempre aperte le tre finestre EDIT, MESSAGE, OUTPUT... Per adesso!

6) sul vostro computer è stato creato un file .EXE in pratica un programma che se viene eseguito scrive sullo schermo la frase riportata tra virgolette, andate a cercarlo ed eseguitelo da una finestra di prompt dei comandi 7) è sempre buona cosa salvare i propri programmi soprattutto se sono lunghi e se vi servono per superare l'esame :-). Per salvare il file dal menù FILE -> SAVE.

Quando un file viene salvato nell'angolo in fondo a sinistra della finestra di EDIT scompare la rotellina dentata che sta ad indicare file non salvato!! Ad ogni modifica introdotta rispetto all'ultimo salvataggio la rotellina dentata riappare...


- riassumendo… -

Che cosa ci insegna il nostro primo programma in c…

codice sorgente osservazioni

/* Questo è il classicoprimo programma.*/

#include <stdio.h>

main (){printf("\nCiao Mondo!!!");

}

la direttiva #include <stdio.h> serveper includere nel programma leinformazioni relative alla libreriapredefinita del linguaggio C checontiene le funzioni di input/output

la funzione main () identifica sempreil programma principale e rappresental'inizio dell'esecuzione del programma

le parentesi graffe { } identificano unblocco

nel codice sorgente si possono/devonomettere i commenti racchiudendoli tra isimboli /* */

le stringhe di testo vengono delimitatedalle virgolette " "

è possibile mettere nelle stringhedelle sequenze che indicano caratterispeciali ad esempio \n indica ilcarattere New Line che fa si che iltesto che lo segue vada a capo

ogni istruzione deve essere conclusa

con il punto e virgola ;

codice sorgente osservazioni

int numero, fattoriale;

una variabile per poter essere usatadeve prima essere dichiarata, scrivendoil tipo seguito dal nome dellavariabile (o da un elenco di nomi divariabili di quel tipo) tipi di dati

primari: int char float doublevoid

numero = 400; l'istruzione di assegnamento si indica

con l'uguale =int numero = 600; è buona cosa che una variabile prima di

essere utilizzata venga inizializzata,ossia le venga assegnato un valorenoto. E' possibile farlo anche almomento della dichiarazione.


- Operatori ed espressioni in C -

l'insieme degli operatori del linguaggio permettono di costruire espressioni. Gli operatori all'interno delle espressioni hanno un ordine di precedenza.

operatori descrizioneARITMETICI

* + -

/ %

moltiplicazione addizione sottrazione divisione resto della divis ione

COMPARAZIONE< >

<= >=

== !=

minore maggiore minore o uguale maggiore o uguale uguale diverso (Fare attenzione un solo "=" è l'assegnamento)

LOGICI&& || !

AND OR NOT

INCREMENTO++ --

incremento decremento modificano il valore degli oggetti a cui vengono applicati, a secondo l'uso prefisso o postfisso restituiscono il valore prima o dopo la modifica esempio: num++ - restituisce num e poi lo incrementa ++num - incrementa num e lo restituisce incrementato

CONDIZIONALE<esp1>?<esp2>:<esp3>

restituisce <esp2> se <esp1> è vero altrimenti restituisce <esp3> esempio: (a>b)? a:b restituisce il massimo tra a e b

ASSEGNAMENTO=

il simbolo uguale = in C viene considerato un operatore e quindi restituisce anch'esso un valore esempio: a=b; memorizza in a il valore di b e restituisce b l'operatore di assegnamento è associativo a destra esempio: a=b=0; il valore 0 viene assegnato sia ad a che a ba+=b; assegna ad a il valore b sommato ad a


- Puntatori -

Permettono la gestione di strutture dinamiche (creat e e distrutte dall'utente). Un Puntatore è una variabile che contiene l'indirizzo di memoria di un'altra variabile. In C un puntatore si dichiara anteponendo al nome della variabile il simbolo *

operatori descrizione& applicato ad una variabile restituisce il puntatore ad

essa * applicato ad un puntatore restituisce la variabile

puntata

- Istruzioni di Controllo Condizionali -

Il costrutto if permette la gestione del flusso delle istruzioni. Altro costrutto condizionale è lo switch. Inoltre esiste l'operatore ?, già visto, che a volte è una alternativa ad if

sintassi costrutti descrizioneif <condizione> istruzione;else istruzione;

la clausola else è opzionale se la condizione vale VERO (cioè qualsiasi valore diverso da zero) viene eseguita l' istruzione (o il blocco) corrispondente all'if; nel caso di valore FALSO della condizione, se è presente il ramo else, sarà eseguita l'istruzione (o il blocco) corrispondente all'else

if <condizione>istruzione;

else if <condizione>istruzione;

else if <condizione>istruzione;

.

.

.else

istruzione;

è una struttura a scala dove vengono valutate le espressioni condizionali dall'alto verso il basso, quando si verifica una condizione viene eseguita l'istruzione corrispondente e viene abbandonata la catena di if se non è presente l'ultimo else, qualora non sia verificata nessuna delle condizioni, non viene eseguita nessuna istruzione della catena


sintassi costrutti descrizione

switch <variabile>{

case costante1:sequenza istruzionibreak;

case costante2:sequenza istruzionibreak;

.

.

.default:

sequenza istruzioni}

sebbene il costrutto if else if consenta di realizzare test multipli, a volte risulta poco leggibile l'istruzione migliore per il test multiplo e rappresentata dallo switch con questo costrutto si confronta il valore di una variabile con una lista di costanti che possono essere di tipo int o char quando si verifica una uguaglianza viene eseguito il blocco di istruzioni corrispondenti fino al break la parte default è opzionale, e se è presente viene eseguita nel caso in cui non si verifichi alcuna corrispondenza

NOTE 1. i test del costrutto switch possono solo verificare l'uguaglianza, a differenza di quelli if che possono verificare condizioni

di qualsiasi tipo 2. non possono esistere due case con lo stesso valore di costante nello stesso costrutto switch, possono invece avere lo

stesso valore due case che appartengono a due costrutti switch annidati 3. se nel costrutto switch vengono usate costanti di tipo char queste vengono automaticamente convertite nel

corrispondente valore int


- Istruzioni di Controllo Iterative -

I costrutti di loop consentono di eseguire un insieme di istruzioni fino a quando non si verifica una data condizione.

sintassi costrutti descrizione

for( inizializzazione;condizione;incremento )

istruzione;

nota: istruzione può essere una istruzione vuota, una istruzione singola oppure un blocco

l'inizializzazione è, nella sua forma più semplice, una istruzione di assegnamento con la quale si determina il valore iniziale della variabile di controllo del loop la condizione è una espressione relazionale usata per valutare la variabile di controllo al fine di determinare il momento dell'uscita dal loop l'esecuzione dell'istruzione prosegue sino a quando la condizione resta VERA, quando diviene FALSA l'esecuzione prosegue con l'istruzione successiva al for l'incremento definisce il modo in cui la variabile di controllo cambia il suo valore ad ogni ripetizione del loop

while(condizione)istruzione;

il loop viene eseguito fino a quando la condizione rimane VERA. Quando la condizione diviene FALSA l'esecuzione prosegue dall'istruzione subito dopo il loop la condizione può essere una qualsiasi espressione valida in C

do{istruzione;

}while (condizione)

a differenza del for e del while il do-while verifica la condizione alla fine del ciclo e non all'inizio!!!

istruzioni descrizione

break oltre che nello switch può essere messa in qualsiasi loop, e ne forza la terminazione, cioè fa in modo che l'istruzione successiva sia quella subito dopo il loop

continue forza una nuova iterazione del loop a partire dal suo inizio

exit provoca l'immediata terminazione dell'intero programma e ritorno al Sistema Operativo


- Direttive del Preprocessore -

lo standard ANSI ammette delle direttive che sono sempre precedute dal simbolo #

La direttiva #define consente di creare delle costanti simboliche che possono poi essere usate nel codice del programma

sintassi direttiva descrizione

#define identificatore stringa

la stringa vine sostituita all'dentificatore ogni volta che viene incontrata nel codice sorgente

La direttiva #include chiede al compilatore di includere un determinato file all'interno del codice sorgente

sintassi direttiva descrizione

#include nomefile

il nome del file può essere racchiuso tra parentesi angolari (esempio <stdio.h> ) o tra virgolette (esempio "stdio.h" ) se il nomefile è comprensivo del percorso completo di dove ricercare il file, la ricerca del file si limita al percorso indicato se non si specifica il percorso ed il nomefile è compreso tra doppi apici "" il file viene ricercato nella directory corrente se non si specifica il percorso ed il nomefile è compreso tra parentesi angolari <> il file viene ricercato nelle directory standard


/********************************************************//* Programma per vedere come introdurre e stampare dati *//********************************************************//**** ESERCIZIO NUMERO 1 - POLITECNICO DI MILANO sede CR*//********************************************************//* mettere degli watches sulle variabili e un break sull*//*ultimo printf e vedere con step come gira il programma*//********************************************************/

#include <stdio.h>

void main(void){/*dichiarazione di variabili e inizializzazione*/int dato1 = 0, dato2 = 0, dato3 = 0;

/*lettura valori da std-input*/printf("Introduci il primo valore:");scanf("%i", &dato1);printf("\nIntroduci il secondo valore:");scanf("%i", &dato2);printf("\nIntroduci il terzo valore:");scanf("%i", &dato3);

/*stampa dei valori letti su std-output*/printf("\nI tre valori introdotti sono %i,%i,%i",dato1, dato2, dato3);

} /********************************************************//* Programma per vedere come vengono assegnati i valori *//* alle variabili ed i tipi *//********************************************************//**** ESERCIZIO NUMERO 2 - POLITECNICO DI MILANO sede CR*//********************************************************/

#include <stdio.h>

char carattere;int numero_intero;float reale;

void main(void){/* richiesta all'utente di introdurre il valore */printf("\n*---------------------------------------------------*");printf("\n questo programma riceve dei valori e li assegna");printf("\n a quattro variabili.");printf("\n Mostra poi a video il valore assegnato alle variabili.\n");printf("\n*---------------------------------------------------*");printf("\n*---------------------------------------------------*");printf("\n(1) inserire un carattere:");scanf("%c", &carattere);printf("\n");printf("\n(2) inserire un numero intero -32.768< x <+32.767:");scanf("%d", &numero_intero);printf("\n");printf("\n(3) inserire un numero reale -3,4E-38< x <+3,4E+38:");scanf("%f", &reale);printf("\n");printf("\n*---------------------------------------------------*");printf("\nEcco i valori assegnati alle variabili:\n");printf("- variabile carattere= %c valore ASCII=%d \n", carattere, carattere);printf("- variabile intero= %d \n", numero_intero);printf("- variabile reale= %f \n", reale);printf("\n*---------------------------------------------------*");}


/********************************************************//* Programma per vedere stampata la tabellina ASCII *//* Impariamo ad usare lo stdout... il video!!! *//* E trattiamo i caratteri con il loro valore intero!!! *//********************************************************//**** ESERCIZIO NUMERO 3 - POLITECNICO DI MILANO sede CR*//********************************************************/

#include <stdio.h>

int numero_intero;

void main(void){

printf("\n*---------------------------------------------------*");printf("\n Questo programma stampa a video caratteri da 0 a 127");printf("\n*---------------------------------------------------*");printf("\n*---------------------------------------------------*\n");

for(numero_intero=0; numero_intero<=127; numero_intero=numero_intero+1){printf("%i - %c -", numero_intero, numero_intero);}printf("\n*---------------------------------------------------*");printf("\nFINE STAMPA TABELLINA ASCII\n");}

/*****************************************************************//* Migliorare l'output del programma in modo da ottenere un uso *//* dello schermo ottimale. Lo schermo del Computer contiene, in *//* modalita' carattere: 80 caratteri x 25 linee *//* Fare in modo di ottenere una tabellina ASCII che sia contenuta*//* ordinata per colonne in una schermata. *//*****************************************************************/


/********************************************************//* Programma per vedere stampata la tabellina ASCII *//* Con questo Esercizio prendiamo le misure al Video... *//********************************************************//*** ESERCIZIO NUMERO 3a - POLITECNICO DI MILANO sede CR*//********************************************************/#include <stdio.h>#define maxcolonne=79#define maxrighe=24int numero_intero, riga, colonna;

void main(void){printf("\n*-------------------------------------------------------------------------*");printf("\n Questo programma stampa a video caratteri da 0 a 127");printf("\n*-------------------------------------------------------------------------*");printf("\n*-----------------------------------------------------------------------*\n");/*stampo i primi nove caratteri ASCII ad una cifra*/for(numero_intero=0; numero_intero<=9; numero_intero=numero_intero+1){printf("00%i- %c -", numero_intero, numero_intero);}printf("\n");/*stampo gli ASCII a due cifre fino allo spazio*/for(numero_intero=10; numero_intero<=31; numero_intero=numero_intero+1){printf("0%i- %c -", numero_intero, numero_intero);}printf("\n");/*stampo gli ASCII a due cifre dallo spazio in poi*/for(numero_intero=32; numero_intero<=99; numero_intero=numero_intero+1){printf("0%i- %c -", numero_intero, numero_intero);}/*stampo gli ASCII a tre cifre*/for(numero_intero=100; numero_intero<=127; numero_intero=numero_intero+1){printf("%i- %c -", numero_intero, numero_intero);}printf("\n*-------------------------------------------------------------------------*");printf("\nFINE STAMPA TABELLINA ASCII\n");}/*Dov'e' che avvengono comportamenti strani? Dove il carattere ASCII corrisponde ad un *//*carattere di controllo. Individuate il carattere "A CAPO"? */


/********************************************************//* Programma per il calcolo del Fattoriale *//********************************************************//*** ESERCIZIO NUMERO 4 - POLITECNICO DI MILANO sede CR**//********************************************************/#include <stdio.h>

void main(void){/* dichiarazioni variabili */int numero, fattoriale;/*leggo i valori dallo standard input*/printf("Calcolo del fattoriale di:");scanf("%d",&numero);/* inizializzo il valore da calcolare*/fattoriale=1;/*elaborazione - calcolo*/while(numero>1)

{fattoriale = fattoriale * numero;numero = numero -1;}

/*stampa del risultato sullo standard output*/printf("Il Fattoriale risulta= %d \n", fattoriale);}

/*********************************************************//* Programma per il calcolo del Fattoriale *//* utilizziamo le forme compatte che sono meno leggibili!*//*******************************************************+*//** ESERCIZIO NUMERO 4a - POLITECNICO DI MILANO sede CR **//*********************************************************/#include <stdio.h>

void main(void){/* dichiarazioni variabili */int numero=0, fattoriale=1, i=0;

/*leggo i valori dallo standard input*/printf("Calcolo del fattoriale di:");scanf("%d",&numero);i = numero;

/*elaborazione - calcolo*/while(i>1)

{fattoriale *= i;i--;}

/*stampa del risultato sullo standard output*/printf("Il Fattoriale di %d risulta= %d \n", numero, fattoriale);}

OSSERVAZIONI: eseguire il programma con diversi input, cosa succede? Con quale limite ci scontriamo?


/********************************************************//* Programma che sceglie il maggiore di due numeri *//********************************************************//*** ESERCIZIO NUMERO 5 - POLITECNICO DI MILANO sede CR**//********************************************************/

#include <stdio.h>

void main(void){/* dichiarazioni variabili */int x,y;

/*leggo i valori dallo standard input*/printf("\nInserisci il Primo Numero X=");scanf("%d",&x);printf("\nInserisci il Secondo Numero Y=");scanf("%d", &y);

/*elaborazione e stampa del risultato*/if(x>y)

printf("Il Maggiore dei due Numeri e' X=%d", x);else

printf("Il Maggiore dei due Numeri e' Y=%d", y);}

/********************************************************//* Programma che sceglie il maggiore di due numeri *//* Usiamo le forme compatte(l'operatore condizionale"?")*//********************************************************//** ESERCIZIO NUMERO 5a - POLITECNICO DI MILANO sede CR**//********************************************************/#include <stdio.h>

void main(void){/* dichiarazioni variabili */int x,y;

/*leggo i valori dallo standard input*/printf("\nInserisci il Primo Numero X=");scanf("%d",&x);printf("\nInserisci il Secondo Numero Y=");scanf("%d", &y);

/*elaborazione e stampa del risultato*/(x>y) ? printf("Il Maggiore dei due Numeri e' X=%d", x)

: printf("Il Maggiore dei due Numeri e' Y=%d", y);}

/**************************************************************************************//* Eccone un'altra versione N.B. la scanf con doppio input*****************************//* void main(void) *//* { *//* int a,b; a=0; b=0; *//* printf("\n-------------------------------------------------------------"); *//* printf("\nQuesto programma restituisce il maggiore di due numeri interi"); *//* printf("\nInserire i numeri in questo formato\n <primo numero,secondo numero>:"); *//* scanf("%d,%d",&a,&b); *//*la scanf riceve due interi separati dal carattere virgola*//* printf("\n------------------------------------------------------------"); *//* printf("\nIl maggiore dei due numeri e':%d", (a>b)?a:b); *//*la printf stampa un intero restituito dell'espressione *//*l'espressione utilizza l'operatore condizionale ? *//* } *//**************************************************************************************/


/********************************************************//* Programma che esegue una operazione tra due numeri *//* operazione indicata dall'utente *//********************************************************//*** ESERCIZIO NUMERO 6 - POLITECNICO DI MILANO sede CR**//********************************************************/#include <stdio.h>

void main(void){/* dichiarazioni variabili */int x,y;char operazione;/*leggo i valori dallo standard input*/printf("\nOperazione su due numeri interi\n");printf("\nintrodurre l'operazione secondo lo schema\n");printf("X operazione Y\n");printf("\ndove Operazione puo' essere [+ - * /]\n");

scanf("%d %c %d",&x,&operazione,&y);printf("\nRisultato:\t");/* Elaborazione calcolo e stampa output*/switch (operazione)

{case '+':

printf("%d", x+y);break;

case '-':printf("%d", x-y);break;

case '*':printf("%d", x*y);break;

case '/':printf("%d con resto %d", x/y, x%y);break;

default:printf("Operazione non conosciuta");

}}/**********************************************//*Che cosa succede se si dimenticano i break? *//**********************************************/

/***********************************************************//* Programma che restituisce una stringa al contrario ARRAY*//***********************************************************//*** ESERCIZIO NUMERO 7 - POLITECNICO DI MILANO sede CR ***//***********************************************************/#include <stdio.h>void main(){

char parola[21]; /* posso mettere 20 char + fine stringa \0 */int i; i=0;

printf("\nInserire una parola (max 20 caratteri):\n");scanf("%s", parola);while ( parola[i] != '\0' && i<20){ i++;}/*uscendo dal ciclo ho lunghezza stringa+1*/i=i-1;for (i; i>=0; i=i-1)

printf("%c", parola[i]);}/* mettere break e watch per vedere i valori dell'array */

In informatica termine mutuato dalla linguistica, riferito all'operazione di dividere una frase in componenti elementari che possono essere analizzati. Si definisce parser un programma che ad esempio scompone il codice per poterlo trasformare in codice oggetto. La compilazione di un programma, ad esempio, comprende una fase di parsing del codice sorgente.

OSSERVAZIONI su questa condizione???


/******************************************************************//* Programma che utilizza istruzioni di controllo iterative *//* ---- for ---- while ---- do while ---- *//* il programma stampa a video i caratteri alfabetici *//* minuscoli e MAIUSCOLI utilizzando il loro valore int. *//* L'utente dopo l'avvio del programma puo' scegliere se stampare *//* le minuscole le MAIUSCOLE entrambe o uscire dal programma *//******************************************************************//****** ESERCIZIO NUMERO 8 - POLITECNICO DI MILANO sede CR ******//******************************************************************/#include <stdio.h>#include <conio.h>

void main(void){

/* con il ciclo do-while governo l'esecuzione del programma *//* leggo l'input da tastiera per conoscere la scelta dell'utente*//* 1 lettere minuscole *//* 2 lettere MAIUSCOLE *//* 3 lettere minuscole e MAIUSCOLE *//* 4 USCITA dal Programma *//* fino a quando l'utente non sceglie il 4 = USCITA */

do {

/*attendo l'input da tastiera della scelta dell'utente*/scanf("%d",&scelta);

/* se la scelta e' diversa da quella di USCITA *//* eseguo le operazioni richieste dall'utente */switch(scelta) {

case 1:

break;

/* se l'utente ha scelto 2 vuole solo le MAIUSCOLE*/case 2:

break;

/*se l'utente ha scelto 3 vuole entrambe*/case 3:

break;

/*se l'utente ha scelto 4 vuole uscire dal programma*/case 4:

/*se l'utente ha fatto una scelta non contemplata dal programma*/default:

}

} while (scelta!=4);

}

Andiamo a vederci con l'help in linea cosa c'è nella conio.h...


/***********************************************************//* Programma che utilizza istruzioni di controllo iterative*//* ---- for ---- while ---- do while ---- *//* il programma stampa a video i caratteri alfabetici *//* minuscoli e MAIUSCOLI utilizzando il loro valore int *//***********************************************************//*** ESERCIZIO NUMERO 8 - POLITECNICO DI MILANO sede CR ***//***********************************************************/

#include <stdio.h>#include <conio.h>

void main(void){int a=0, b=0, scelta=0; /* dichiarazione delle variabili e loro inizializzazione */

/* l'utente dopo l'avvio del programma puo' scegliere se stampare *//* le minuscole le MAIUSCOLE entrambe o uscire dal programma */

/* con il ciclo do-while governo l'esecuzione del programma *//* leggo l'input da tastiera per conoscere la scelta dell'utente *//* fino a quando l'utente non sceglie il 4 = USCITA */

do {/* pulisco lo schermo e visualizzo le istruzioni d'uso del programma */clrscr();for(a=0;a<=79;a++)printf("-");printf("Programma per la stampa a video dei caratteri alfabetici\n");for(a=0;a<=79;a++)printf("-");printf(" 1 - Stampa dei caratteri alfabetici minuscoli");printf("\n 2 - Stampa dei caratteri alfabetici MAIUSCOLI");printf("\n 3 - stampa dei caratteri minuscoli e MAIUSCOLI");printf("\n 4 - USCITA dal programma\n");for(a=0;a<=79;a++)printf("-");printf("\nScegliere l'operazione desiderata premendo \n");printf("il tasto corrispondente al numero ed Invio : ");

/*fine della visualizzazione del menu di scelta e delle istruzioni*/

/*attendo l'input da tastiera della scelta dell'utente*/scanf("%d",&scelta);

/* se la scelta e' diversa da quella di USCITA eseguo le operazioni richieste dall'utente */switch(scelta) {

/*se l'utente ha scelto 1 vuole solo le minuscole*/case 1:printf("\nHai scelto %d ecco le minuscole\n\n", scelta);

b=97; /*inizializzo alla prima lettera*/while(b<=122) {printf("%c ",b);b++;}printf("\n\nPremi un tasto per continuare");/*blocco esecuzione per vedere output*/getch();/*questa istruzione attende la pressione di un tasto*/break;

/* se l'utente ha scelto 2 vuole solo le MAIUSCOLE*/case 2:printf("\nHai Scelto %d ecco le MAIUSCOLE\n\n", scelta);

b=65; /*inizializzo alla prima lettera*/while(b<=90) {printf("%c ",b);b++;}printf("\n\nPremi un tasto per continuare");getch();break;

/*se l'utente ha scelto 3 vuole entrambe*/case 3:printf("\nHai Scelto %d ecco lettere minuscole e MAIUSCOLE\n\n", scelta);

b=65; /*inizializzo la prima lettera */while(b<=90) {printf(" %c %c -",b,b+32);b++;}printf("\n\nPremi un tasto per continuare");getch();break;

/*se l'utente ha scelto 4 vuole uscire dal programma*/case 4:printf("\nhai Scelto %d", scelta);

break;

/*se l'utente ha fatto una scelta non contemplata dal programma*/default: printf("\nScelta Errata. Scegliere 1 2 3 o 4 e battere INVIO\n");

printf("\n\nPremi un tasto per continuare");getch();

}} while (scelta!=4);

clrscr();printf("Grazie per avere usato questo programma!\n%c",7);printf("\n\nPremi un tasto per continuare");getch();}


#include <stdio.h> main() { float x1, y1, x2, y2, x3, y3; float distq12, distq13; printf("Coordinata x del punto 1: "); scanf("%f", &x1); printf("Coordinata y del punto 1: "); scanf("%f", &y1); printf("Coordinata x del punto 2: "); scanf("%f", &x2); printf("Coordinata y del punto 2: "); scanf("%f", &y2); printf("Coordinata x del punto 3: "); scanf("%f", &x3); printf("Coordinata y del punto 3: "); scanf("%f", &y3); distq12 = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2); distq13 = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3); if (distq12 == distq13){ printf("I punti 2 e 3 sono equidistanti da 1\n"); } else { printf("I punti 2 e 3 NON sono equidistanti da 1\n"); } }

Date le coordinate x ed y di 3 punti, verifica se i punti 2 e 3 sono equidistanti dal punto 1 (quindi se i punti 2 e 3 si trovano su una circonferenza con centro nel punto 1). La verif ica viene fatta controllando se i quadrati delle distanze 1-2 e 1-3 sono uguali. Input: coordinate x ed y dei 3 punti Output: messaggio che dice se i punti sono equidistanti o no


Come affrontare il problema?

So acquisire una stringa? SI scanf %sSo memorizzare una stringa? SI in un ARRAY di charSo memorizzare 10 stringhe? SI potrei fare 10 ARRAY o meglio un ARRAY bidimensionaleSo confrontare il contenuto di due stringhe? SI carattere per carattereSo stampare una stringa? SI printf %s

implementazione della soluzione:

#include <stdio.h>void main(){

}

Questa è la fase piu' complessa (ovviamente).

Ho le parole in memoria e devo confrontarle tra loro per valutarne l'ordine alfabetico, decido diaffrontare il problema prendendo le parole due a due confrontandole tra loro ed scambiandole diposto nell'ARRAY nel caso in cui non soddisfino l'ordine alfabetico.L U N E D I \0M A R T E D I \0M E R C O L E D I \0G I O V E D I \0V E N E R D I \0S A B A T O \0D O M E N I C A \0G E N N A I O \0D I C E M B R E \0S E T T I M A N A L E \0

int ordinato=0;/*assumo che valore 0 = FALSO*/

typedef char parola[21];/*devo fare un array di parole */

parola tutte[10];/*le parole sono numerate da 0 a 9*/

printf("\n Dammi 10 parole (max 20 char) da ordinare.\n");

for (i=0; i<=9; i=i+1)/*eseguo 10 scanf con %s*/{

printf("Dammi la parola n.%d:",i);scanf("%s",tutte[i]);

}

printf("\n Ecco le parole in ordine:\n");for (i=0; i<=9; i=i+1)

{printf("%s \n",tutte[i]);

}


Scorrero' le coppie di parole dell'ARRAY fino a quando non risultera' ordinato, non sapendo quantevolte devo scorrere le parole usero' un ciclo while

while (!ordinato){

/*scorro le parole*//*confronto il primo char la iesima con la successiva*//*se non in ordine scambio */

}

Per scorrere le parole usero' un ciclo for in quanto conosco esattamente il numero di parolenell'array = 10.

Per copiare la stringa in un array di scambio semplifico usando una funzione della libreriastring.h la funzione di copiatura della stringa e' strcpy(stringa destinazione, stringa sorgente).

char par1[21], par2[21]; /*variabili per lo scambio*/

Come prima azione scorro le parole carattere per carattere ad anche in questo caso posso usare unciclo for conoscendo la lunghezza massima 21 char compreso il char di fine stringa.

while (!ordinato) /*ciclo fino a che disordinato*/{

for (i=0;i<=9;i=i+1) /*scorro le parole*/{

strcpy(par1,tutte[i]); /*copio la parola nella var di scambio*/strcpy(par2,tutte[i+1]);/*copio la parola nella var di scambio*/

for (j=0;j<=20;j=j+1) /*scorro i caratteri delle parole */{

}/*fine ciclo for scorri caratteri*/

}/*fine ciclo for scorri parole*/

}/*fine ciclo while*/

confronto la lettera iniziale delle parole, se e' diversa ho gia' discriminatol'ordine alfabetico.

Per confrontare i caratteri uso una serie di if in cascata

if(par1[j]<par2[j]) /*se sono gia' in ordine*/{ ordinato = 1; /*sono in ordine*/

break; /*passo alla successiva esco dal ciclo for*/}else /*non sono in ordine o scambio o guardo altro char*/{

if(par1[j]!=par2[j]) /*se il char e' != le scambio*/{ strcpy(tutte[i],par2);strcpy(tutte[i+1],par1);ordinato = 1;i=-1; /*ricomincio a scorrere le parole*/break; /*passo alla parola successiva*/

}else /*il char e' lo stesso passo al prox*/{ ; /*non devo fare nulla torno all'inizio del for*/}

}/*fine blocco else*/

ESEMPIO DI COPIA STRINGA senza strcpy for (i=0; i< lungh_str; i=i+1){ str1[i]=str2[i];

}/*N.B. e lo \0????*/


/********************************************************//* Programma per vedere la complessita' del problema *//* dell'ordinamento di alcune stringhe *//********************************************************//**** ESERCIZIO NUMERO 9 - POLITECNICO DI MILANO sede CR*//********************************************************//* quante limitazioni abbiamo con gli strumenti fino ad *//* ora utilizzati!! Dovremo introdurre alcune cose... *//********************************************************/

#include <stdio.h>#include <string.h> /*libreria per la gestione delle stringhe*/

int i=0,j=0;/*variabili contatore*/

int ordinato=0; /*assumo che valore 0 = FALSO*/

typedef char parola[21]; /*devo fare un array di parole */

parola tutte[10];/*le parole sono numerate da 0 a 9*/

char par1[21], par2[21]; /*variabili per lo scambio*/

void main(){

/* fase di input ricevo le dieci parole da ordinare */printf("\n Dammi 10 parole (max 20 char) da ordinare.\n");

for (i=0; i<=9; i=i+1) /*eseguo le 10 scanf con %s*/{

printf("Dammi la parola n.%d:",i);scanf("%s",tutte[i]);

}

/*****************************************************//*fase di elaborazione metto in ordine le parole *//*confronto le parole in sequenza e se la flag non mi*//*dice che c'e' ordinamento continuo a confrontare *//*quando trovo due parole successive non in ordine le*//*scambio tra di loro di posizione *//*****************************************************/

continua nella pagina successiva


printf("\n Attendere sto ordinando .");

while (!ordinato) /*ciclo fino a che disordinato*/{

for (i=0;i<=9;i=i+1) /*scorro le parole*/{ /*confronto la iesima con la successiva*/

strcpy(par1,tutte[i]); /*copio la parola nella var di scambio*/strcpy(par2,tutte[i+1]);/*copio la parola nella var di scambio*/

for (j=0;j<=20;j=j+1) /*scorro i caratteri delle parole */{

if(par1[j]<par2[j]) /*se sono gia' in ordine*/{

ordinato = 1; /*sono in ordine*/break; /*passo alla successiva esco dal ciclo for*/

}

else /*non sono in ordine o scambio o guardo altro char*/{

if(par1[j]!=par2[j]) /*se il char e' diverso le scambio*/{strcpy(tutte[i],par2);strcpy(tutte[i+1],par1);ordinato = 1;i=-1; /*ricomincio a scorrere le parole*/break; /*passo alla parola successiva*/

}else /*il char e' lo stesso passo al prox*/{; /*torno all'inizio del ciclo for*/}

}/*fine blocco else*/

}/*fine ciclo for scorri caratteri*/printf(".");

}/*fine ciclo for scorri parole*/

}/*fine ciclo while*/

/*********************************************//*fase di output stampo il risultato prdinato*//*********************************************/printf("\n Ecco le parole in ordine:\n");for (i=0; i<=9; i=i+1)

{printf("%s \n",tutte[i]);

}}/*fine blocco main*/


/***********************************************************//* Programma che utilizza la printf *//* per stampe a video formattate *//***********************************************************//*** ESERCIZIO NUMERO 10 - POLITECNICO DI MILANO sede CR ***//***********************************************************/#include <stdio.h>

void main(void){

int x = 321; /*valore del numero da stampare*/printf("\n Usiamo la printf gestendo gli allineamenti di numeri:");printf("\n----------------------------------------------------------");printf("\n nota mettiamo il valore tra due asterischi");printf("\n----------------------------------------------------------\n");printf("Stampa senza formattazione *%d*\n\n",x);printf("Stampa a destra in campo largo 8: *%8d*\n",x);printf("Stampa a sinistra in campo largo 8: *%-8d*\n\n",x);printf("Stampa in campo troppo stretto (1): *%1d*\n",x);printf("Stampa in campo largo 8, con zeri: *%08d*\n",x);printf("Stampa un minimo di 6 cifre: *%.6d*\n\n",x);printf("Stampa un numero negativo: *%d*\n\n",-x);printf("Stampa con segno su numero positivo: *%+d*\n",x);printf("Stampa con segno su numero negativo: *%+d*\n\n",-x);printf("Spazio su numero positivo: *% d*\n",x);printf("Spazio su numero negativo: *% d*\n",-x);getch();

}

/****************************************************************************//* Si indica la larghezza del campo con (%Nd) dove N= larghezza *//* il numero viene naturalmente è allineato a destra con spazi sulla *//* sinistra se non riempie interamente il campo. *//* Se metto un meno tra % e larghezza del campo, il numero viene allineato *//* a sinistra (con spazi sulla destra). *//* Se il numero supera la larghezza del campo, viene comunque stampato *//* per intero!!!!! *//* Nel nostro esempio sono richieste 1 cifra, ma ne stampa comunque 3!!!!! *//* Posso mettere degli zeri non significativi negli spazi eccedenti prima *//* del numero, basta iniziare la larghezza del campo con uno zero. *//* Se non è indicata una larghezza, il numero minimo di cifre ha lo *//* stesso effetto che richiedere gli zeri iniziali. *//* *//* Un numero negativo viene naturalmente stampato col segno meno. *//* Per avere il segno + davanti ai numeri positivi, devo mettere + dopo il %*//* Ovviamente il + non cambia il segno meno dei numeri negativi!!!!!! *//* Uno spazio dopo il % lascia uno spazio davanti ai numeri positivi *//* e non altera il meno davanti ai negativi. *//****************************************************************************/

/***********************************************************//* Programma che utilizza i caratteri ascii oltre 127 *//* per stampare a video finestre con simboli grafici *//* N.B. libreria conio.h non standard ASCII ma MS DOS *//***********************************************************//*** ESERCIZIO NUMERO 11 - POLITECNICO DI MILANO sede CR ***//***********************************************************/ #include <stdio.h># include <conio.h>void main(){int c1=1,r1=1,c2=79,r2=24, a;/*disegno la riga superiore*/gotoxy(c1,r1);printf("┌"); for(a=0;a<=c2-c1-2;a++) printf("─"); printf("┐");/*disegno la riga inferiore*/gotoxy(c1,r2);

printf("└"); for(a=0;a<=c2-c1-2;a++) printf("┘"); printf("─");/*disegno la riga di destra*/for(a=0;a<=r2-r1-2;a++){ gotoxy(c1,r1+1+a); printf("│");}/*disegno la riga di sinistra*/

for(a=0;a<=r2-r1-2;a++){ gotoxy(c2,r1+1+a); printf("│");}}


Scrivere un programma che gestisce un menu di due scelte:1 disegna finestra coordinate della finestra decise dall'utente;2 uscita.

/***********************************************************//* Programma che utilizza i caratteri ascii oltre 127 *//* per stampare a video finestre con simboli grafici *//* N.B. libreria conio.h non standard ASCII ma MS DOS *//* consentire all'utente una scelta a menu e introdurre le *//* coordinate della finestra a scelta dell'utente *//***********************************************************//*** ESERCIZIO NUMERO 11a - POLITECNICO DI MILANO sede CR **//***********************************************************/


void main(){int c1,r1,c2,r2, a, scelta;

do {clrscr();printf("\n-----------------------------------------------------\n");printf("premere 1 ed invio per disegnare una finestra sul video\n");printf("premere 2 ed invio per uscire dal programma\n");printf("\n-----------------------------------------------------\n");

scanf("%d", &scelta);

switch(scelta){case 1: clrscr();

printf("Introdurre le coordinate della finestra\n");printf("nel formato riga,colonna [dimensioni 24x79]\n");printf("angolo superiore sinistro r,c: ");scanf("%d,%d",&r1,&c1);printf("\nangolo inferiore destro r,c: ");scanf("%d,%d",&r2,&c2);clrscr();

/*disegno la riga superiore*/gotoxy(c1,r1);printf("┌"); for(a=0;a<=c2-c1-2;a++) printf("─"); printf("┐");/*disegno la riga inferiore*/gotoxy(c1,r2);printf("└"); for(a=0;a<=c2-c1-2;a++) printf("─"); printf("┘");/*disegno la riga di destra*/for(a=0;a<=r2-r1-2;a++){ gotoxy(c1,r1+1+a); printf("│");}/*disegno la riga di sinistra*/

for(a=0;a<=r2-r1-2;a++){ gotoxy(c2,r1+1+a); printf("│");}getch();break;

case 2: clrscr();printf("\n grazie per avere usato questo programma");getch();break;

default: printf("\npremere 1 ed invio oppure 2 ed invio!!!");getch();

}/*chiudo switch*/

} while (scelta != 2);}


Le funzioni sono per il linguaggio C i blocchi fondamentali di ogni programma. Prima del main bisogna dichiararle (prototiparle o creare l'header della funzione) e poi devono essere implementate cioè scrivere la parte di codice della funzione. Il compilatore permette l'uso della funzione se ha già incontrato il suo header.

tipo_restituito nome_funzione(lista_argomenti)

dichiarazione degli argomenti{corpo della funzione

}

Il tipo restituito dichiara il tipo di valore che può essere restituito dalla funzione attraverso l'istruzione return . Il nome della funzione deve rispettare le regole degli indentifi catori C. La lista degli argomenti (può anche non essere presente, in tal caso si devono mettere le parent esi vuote) è formata dai parametri formali la lista deve essere speci ficata nel modo:(tipo nome_parametro, …, tipo nome_parametro)

Programma esempio:

#include <stdio.h>int Fattoriale(int a);int i,j;

void main(void){i=3;j=Fattoriale(i);}

int Fattoriale(int a){int risultato;risultato=1;

while (a>=1){risultato=risultato * a;a=a-1;}

return risultato;}la funzione copia nei parametri formali i parametri attuali ed utilizza i parametri formali nella sua implementazione, questo implica che i parametri attuali non vengono alterati dalla funzione. Questo tipo di passaggio di parametri è chiamato passaggio dei parametri per valore ed è l'unico modo usabile con il linguaggio C. Altri linguaggi permettono il passaggio di parametri per indirizzo.

l'istruzione return consente di forzare l'immediata terminazione dell'esecuzione della funzione e di restituire un valore al programma chiamante.

chiamata della funzione con parametri attuali in quantità e dello stesso tipo di quelli dichiarati.


/***********************************************************//* Programma che disegna finestre a video utilizzando *//* la libreria conio.h ed i simboli tabella ASCII oltre 128*//***********************************************************//** ESERCIZIO NUMERO 11b - POLITECNICO DI MILANO sede CR **//***********************************************************/#include <stdio.h>#include <conio.h>/********* dichiarazioni delle funzioni ******************************/int disegna_finestra(int c1, int r1, int c2, int r2, int colore, int sfondo);

/**********************************************************************//* Colori definiti nella libreria conio.h *//* BLACK 0, BLUE 1, GREEN 2, CYAN 3, RED 4, MAGENTA 5, BROWN 6, *//* LIGHTGRAY 7, DARKGRAY 8, LIGHTBLUE 9, LIGHTGREEN 10, LIGHTCYAN 11, *//* LIGHTRED 12, LIGHTMAGENTA 13, YELLOW 14, WHITE 15, BLINK 128. *//**********************************************************************/

void main(void){int i;clrscr();for(i=1; i<16; i++) disegna_finestra(0+i,1+i,4+i,6+i,i,16-i);getch(); clrscr();for (i=1; i<13; i++) disegna_finestra(0+i,0+i,80-i,25-i,i,16-i);getch(); clrscr();for (i=1; i<16;i=i+2) disegna_finestra(0+i,0+i,2*i,25,i,16-i);getch(); clrscr();for (i=1; i<12; i++) disegna_finestra(i,i+1,2*i,25-i,128,i);getch();

}

/***************************************************************************//*Funzione che disegna finestra sullo schermo *//* riceve come parametri: *//* - le coordinate degli angoli (angolo sup sin c1,r1 angolo inf des c2,r2 *//* - colore della cornice *//* - colore dello sfondo *//***************************************************************************/

int disegna_finestra(int c1, int r1, int c2, int r2, int colore, int sfondo){int a=0;textcolor(colore);textbackground(sfondo);if(c2-c1<80&&r2-r1<24){

/*disegno la riga superiore*/gotoxy(c1,r1);cprintf("┌"); for(a=0;a<=c2-c1-2;a++) cprintf("─"); cprintf("┐");/*disegno la riga inferiore*/gotoxy(c1,r2);cprintf("└"); for(a=0;a<=c2-c1-2;a++) cprintf("─"); cprintf("┘");

/*disegno la riga di destra*/for(a=0;a<=r2-r1-2;a++){ gotoxy(c1,r1+1+a); cprintf("│");}

/*disegno la riga di sinistra*/for(a=0;a<=r2-r1-2;a++){ gotoxy(c2,r1+1+a); cprintf("│");}return 1; /* restituisco VERO cioè ho disegnato la finestra */

}else

return 0; /* restituisco FALSO cioè non ho disegnato la finestra */}


/***************************************************************************************//* Programma che disegna finestre a video utilizzando la libreria conio.h ed i simboli *//* tabella ASCII oltre 128 *//***************************************************************************************//*** ESERCIZIO NUMERO 11c - POLITECNICO DI MILANO sede CR **//***************************************************************************************/#include <stdio.h>#include <conio.h>

/********* dichiarazioni delle funzioni ***********************/

int disegna_finestra(int c1, int r1, int c2, int r2);char leggi_tasto();void disegna_menu(void);void saluti(void);/**************************************************************/void main(void){/* dichiarazione delle variabili e loro inizializzazione */int a=0, b=0, c=0, d=0;char scelta='0';

/* con il ciclo do-while governo l'esecuzione del programma *//* leggo l'input da tastiera per conoscere la scelta dell'utente*//* fino a quando l'utente non sceglie il carattere '2' = USCITA */

do {/* visualizzo il menu le istruzioni d'uso del programma */

clrscr();disegna_menu();scelta = leggi_tasto();

/* se scelta e' diversa da quella di USCITA eseguo operazioni richieste dall'utente */switch(scelta) {

/*se l'utente ha scelto 1 vuole disegnare la finestra*/case '1':

printf("\nHai scelto %d\n\n", scelta);printf("dammi le coordinate");printf("\ncolonna da 1 a 79 riga da 1 a 24");printf("\nangolo in alto a sinistra <colonna,riga>:");scanf("%i,%i",&a,&b); /*acquisisco le coordinate*/if(a<1 || a>79)/*se non sono ammissibili*/{gotoxy(1,24);printf("la riga deve essere compresa tra 1 e 24!!");leggi_tasto();/*stanpo msg di errore e aspetto tasto*/break;}else if(b<1 || b>24)/*se non sono ammissibili*/{gotoxy(1,24);printf("la colonna deve essere compresa tra 1 e 79!!");leggi_tasto();/*stampo msg di errore e aspetto tasto*/break;}printf("\nangolo in basso a destra <colonna,riga>:");scanf("%d,%d",&c,&d);/*acquisisco le coordinate*/if(c<1 || c>79)/*se non sono ammissibili*/{gotoxy(1,24);printf("la riga deve essere compresa tra 1 e 24!!");leggi_tasto();/*stampo msg di errore e aspetto tasto*/break;}else if(d<1 || d>24)/*se non sono ammissibili*/{gotoxy(1,24);printf("la colonna deve essere compresa tra 1 e 79!!");leggi_tasto();/*stampo msg di errore e aspetto tasto*/break;}disegna_finestra(a,b,c,d);leggi_tasto();/*aspetto tasto*/

ESERCIZIO: fare un programma che richiede all'utente che finestra vuole disegnare. Mettere dei controlli sugli input in modo da rendere il programma robusto rispetto agli input errati.


break;

/*se l'utente ha scelto 2 vuole uscire dal programma*/case '2':

break;

/*se l'utente ha fatto una scelta non contemplata dal programma*/default:

gotoxy(1,24);/*mi posiziono in fondo allo schermo*/printf("\nScelta Errata. Scegliere 1 2 o 3 battere INVIO");leggi_tasto();/*stampo msg di errore e aspetto tasto*/

}

} while (scelta!='2'); /*esco solo se scelta == 2*/saluti();}

/************************************************************//*Funzione che disegna finestra sullo schermo *//* riceve come parametri: *//* - le coordinate degli angoli *//* angolo superiore sinistro c1,r1 *//* angolo inferiore destro c2,r2 *//************************************************************/int disegna_finestra(int c1, int r1, int c2, int r2){

}

/************************************************************//* Funzione che disegna il menu di scelta e le istruzioni *//************************************************************/void disegna_menu(void){gotoxy(1,1); /*mi posiziono all'inizio dello schermo*/printf("Programma per la stampa a video di finestre\n");printf(" 1 - Voglio disegnare una finestra");printf("\n 2 - USCITA dal programma\n");printf("\nScegliere l'operazione desiderata premendo \nil tasto corrispondente al numeroed Invio : ");/*fine della visualizzazione del menu di scelta e delle istruzioni*/}

/************************************************************//* Funzione che attende la pressione di un tasto *//* e restituisce il tasto premuto *//************************************************************/char leggi_tasto(void){char t;t= getche();return t;}

/************************************************************//* Funzione che scrive a video i saluti finali *//* e attende la pressione di un tasto per tornare al S.O. *//************************************************************/void saluti(void){clrscr();printf("Grazie per avere usato questo programma!\n%c",7);leggi_tasto();}


/***********************************************************//* Programma che scambia il valore del contenuto di due *//* variabili intere senza dichiararne altre. *//***********************************************************//*** ESERCIZIO NUMERO 12 - POLITECNICO DI MILANO sede CR ***//***********************************************************/#include <stdio.h>#include <conio.h>

void main(void){

int a,b; /*dichiaro e inizializzo le variabili*//*parte di input dei valori*/

clrscr();printf("\n Programma che scambia il valore di due variabili");printf("\n Introdurre la prima variabile intera:");scanf("%d", &a);printf("\n Introdurre la seconda variabile intera:");scanf("%d", &b);printf("\n Le variabili prima dello scambio valgono a=%d b=%d",a,b);

/*parte di elaborazione, scambio dei contenuti*/a=a+b; /*metto nella prima la somma della prima e della seconda*/b=a-b; /*metto nella seconda la differenza tra la somma e la seconda*/a=a-b; /*metto nella prima la differenza tra la somma e la prima*/

/*parte di output dei valori scambiati*/printf("\n Le variabili dopo lo scambio valgono a=%d b=%d",a,b);getch();

}/*********************DOMANDA**************************//*E' possibile fare una funzione che scambia il valore*//*delle due variabili, utilizzando lo stesso metodo? *//******************************************************/


/************************************************************************//* PROVA IN ITINERE DEL 14 NOVEMBRE 2001 ESERCIZIO N 1 *//************************************************************************//* Scrivere un programma C che legge da tastiera una sequenza di numeri *//* reali; la lettura termina quando la somma dei numeri immessi e' *//* maggiore di 50, e comunque non si possono immettere piu' di 100 *//* numeri (se anche dopo avere immesso 100 numeri la loro somma non *//* supera 50 la lettura termina comunque). Dopo avere letto tutti i *//* numeri, se l'utente ha inserito almeno 3 valori, cercare se esiste *//* una coppia di numeri tali che il loro rapporto (o il suo inverso) *//* sia uguale al primo numero immesso e, se esiste, stamparla. *//************************************************************************/#include <stdio.h>

typedef enum{false, true} bool;#define MAX_NUM 100 /* numero massimo dei dati inseribili*/#define MAX_SUM 50 /* valore massimo della somma dei dati */#define TOL 0.00000001/* tolleranza ammessa */

main(){

float dati[MAX_NUM], sum = 0, rapp, inv_rapp;int i, j, n_dati;bool trovata = false;

n_dati = 0;

do { /*ciclo di acquisizione dei dati*/printf("Inserisci numero: ");scanf("%f", &dati[n_dati]);fflush(stdin);sum += dati[n_dati];n_dati++;/*condizioni di fine acquisizione dei dati */

} while (sum <= MAX_SUM && n_dati < MAX_NUM);

if (n_dati >= 3) /*se ho acquisito almeno tre dati*/{

i = 1;while (!trovata && i<n_dati-1) /*scorro i dati inseriti*/{j = i+1;while (!trovata && j<n_dati)

{if (dati[i] == 0 || dati[j] == 0) /*rapporti con ZERO?!?!?*/{if (dati[0] == 0) /*se il primo valore e' ZERO*/{ /* non ho rapporti == ZERO !!*/

trovata = true;}

}else /* se non c'e' ZERO nel rapporto*/{

rapp = dati[i] / dati[j]; /*calcolo il rapporto*/inv_rapp = dati[j] / dati[i]; /*calcolo l'inverso*/if (rapp - dati[0] < TOL && rapp - dati[0] > -TOL ||

inv_rapp - dati[0] < TOL && inv_rapp - dati[0] > -TOL){

trovata = true;}

}if (trovata == true){printf("Il rapporto (o l'inverso) tra %f e %f vale %f\n", dati[i], dati[j], dati[0]);}j++;

}i++;

}}else /*se non sono stati inseriti almeno tre dati*/{ printf("Sono stati inseriti solo %d elementi\n", n_dati);}

}



Il programma deve ricevere in input la velocità del conta chilometri. Le velocità ammesse sono comprese tra -20 e 200 K/h

per velocità tra -20 e -1 Km/h multa per retromarcia in senso unico

per velocità 0 Km/h multa per sosta vietata

per velocità tra 1 e 40 Km/h multa per gomme usurate

per velocità tra 41 e 50 Km/h multa per intralcio al traffico

per velocità tra 51 e 90 Km/h multa per eccesso di velocità di oltre 10 Km/h

per velocità tra 91 e 150 Km/h multa per eccesso di velocità con calcolo della velocità oltre i 50 Km/h

per velocità tra 151 e 200 Km/h multa per eccesso di velocità con messaggio velocità Esageratamente Alta

/*******************************************************************//* Programma che utilizza le Costanti *//* L'utente deve dire a che velocita' procede la sua auto *//* il programma in base alla rispsta data dall'utente *//* applica l'opportuna sanzione prevista dal codice della *//* strada dando una risposta in output *//*******************************************************************//** ESERCIZIO NUMERO 13 - POLITECNICO DI MILANO sede CR ***//*******************************************************************//*******************************************************************//* Un valore definito con #define viene sostituito ogni volta che *//* la costante è usata nel programma. Per convenzione, le costanti *//* definite con #define o enum sono indicate in lettere maiuscole. */

#define INP_MIN -20 /*definisco i limiti di input consentiti*/#define INP_MAX 200 /* cioè velocita' minima -20 e max +200 *//*******************************************************************/

/********************************************************************//* nel caso seguente non importano i valori assegnati alle costanti,*//* basta che siano diversi tra loro. Il compilatore assegna comunque*//* zero alla prima, 1 alla seconda e 2 alla terza. Il trattino di *//* sottolineatura (underscore) si usa per migliorare la leggibilità,*//* e conta come una normale lettera. */

enum {INP_ERRATO, INP_NEGATIVO, INP_OK};/*prevedo 3 situazioni di input*//********************************************************************/

/*********************************************************************//* Qui ogni costante deve avere il suo valore. Avremmo anche potuto *//* usare const, ma le costanti definite con enum non occupano memoria*//* ed il programma gira più velocemente. */enum { FERMO = 0, /*fisso i valori dei limiti di velocita' */

BASSO = 40,LIMITE1 = 50,LIMITE2 = 90,ALTO = 150 };

/*********************************************************************/


/***********************************************************************//* Anche qui sarebbe stato utile enum, ma questo funziona solo con *//* gli int e non con i long. Abbiamo quindi usato una serie di #define,*//* che hanno lo svantaggio di non restare confinati alla funzione in *//* cui sono definiti (main, in questo caso). */#define M_RETRO 45000L /*definisco le sanzioni*/#define M_FERMO 75000L#define M_INTRALCIO 80000L#define M_LIMITE1 60000L#define M_LIMITE10 90000L#define M_LIMITE2 600000L#define M_ASSURDO 800500L#define M_GOMME 65000L

void main(){do {

do {clrscr();printf("\nChe velocità ha segnato il conta km dell'auto? ");

vabene=scanf("%d", &velocita);fflush(stdin);

} while (!vabene || input == INP_ERRATO)printf("\nSsecondo il CdS Lei è in contravvenzione perché\n");

printf("\nLa contravvenzione prevede il pagamento di %ld.", sanzione);

printf("\nPremi ESC per uscire o un altro tasto per continuare");

tasto = getch();} while (tasto != 27)

}

int input; /*input */ int vabene; /*ho ricevuto un valore ammesso */int velocita; /*velocità */ long sanzione; /*sanzione da pagare */char tasto;


/******************************************************************************************//* Programma che utilizza le Costanti - L'utente deve dire a che velocita' procede la sua*//* auto il programma in base alla rispsta data dall'utente applica l'opportuna sanzione *//* prevista dal codice della strada dando una risposta in output *//******************************************************************************************//** ESERCIZIO NUMERO 13 - POLITECNICO DI MILANO sede CR ***//******************************************************************************************/#include <stdio.h>/*******************************************************************//* Un valore definito con #define viene sostituito ogni volta che *//*la costante è usata nel programma. Per convenzione, le costanti *//*definite con #define o enum sono indicate in lettere maiuscole. */

#define INP_MIN -20 /*definisco i limiti di input consentiti*/#define INP_MAX 200 /* cioè velocita' minima -20 e max +200 *//*******************************************************************//***********************************************************************//* nel caso seguente non importano i valori assegnati alle costanti, *//* basta che siano diversi tra loro. Il compilatore assegna comunque *//* zero alla prima, 1 alla seconda e 2 alla terza. Il trattino di *//* sottolineatura (underscore) si usa per migliorare la leggibilit…, *//* e conta come una normale lettera. */enum {INP_ERRATO, INP_NEGATIVO, INP_OK};/*prevedo 3 situazioni di input*//********************************************************************//*********************************************************************//* Qui ogni costante deve avere il suo valore. Avremmo anche potuto *//* usare const, ma le costanti definite con enum non occupano memoria*//* ed il programma gira più velocemente. */enum { FERMO = 0, /*fisso i valori dei limiti di velocita' */

BASSO = 40, LIMITE1 = 50, LIMITE2 = 90, ALTO = 150 };/*********************************************************************//***********************************************************************//* Anche qui sarebbe stato utile enum, ma questo funziona solo con *//* gli int e non con i long. Abbiamo quindi usato una serie di #define,*//* che hanno lo svantaggio di non restare confinati alla funzione in *//* cui sono definiti (main, in questo caso). */#define M_RETRO 45000L /*definisco le sanzioni*/#define M_FERMO 75000L#define M_INTRALCIO 80000L#define M_LIMITE1 60000L#define M_LIMITE10 90000L#define M_LIMITE2 600000L#define M_ASSURDO 800500L#define M_GOMME 65000L

int input; /*input */ int vabene; /*ho ricevuto un valore ammesso */int velocita;/*velocità */ long sanzione; /*sanzione da pagare */ char tasto;/***************** M A I N ************************/void main() {do { /* ciclo in cui ripeto l'esecuzione del programma*/

do { /* ciclo in cui valuto se input va bene */clrscr();printf("\nChe velocità ha segnato il conta kilometri dell'auto? ");/* se la scanf riceve un valore ammissibile mette 1=VERO in vabene *//* se la scanf riceve un valore sbagliato mette 0=FALSO in vabene */vabene=scanf("%d", &velocita);/* la funzione fflush seguente evita problemi in caso di imput errato *//* per maggiori informazioni consultare l'help in linea */fflush(stdin);if (!vabene || velocita < -20 || velocita > 200){ input = INP_ERRATO;}else if (velocita <0 && velocita >= -20 ){ input = INP_NEGATIVO;}else{ input = INP_OK;

}

if (input == INP_ERRATO){ printf("\n- La velocita' deve essere compresa tra %d e %d.\n",

INP_MIN,INP_MAX);if(!vabene){ printf("\nLei porta degli occhiali non adatti alla guida:\n");printf("sul conta Kilometri ci sono numeri, non lettere o simboli!");

}getch();

}} while ((!vabene) || (input == INP_ERRATO));/*ripete la richiesta di input se non ok*/

printf("\nSpiacente ma secondo il Codice della Strada Lei è in contravvenzione perche'\n");if (input == INP_NEGATIVO){ printf("Lei ha fatto retromarcia in una strada a senso unico.");

sanzione = M_RETRO;}else{

if (velocita == FERMO){ printf("Lei e' in sosta vietata.");

sanzione = M_FERMO;}else if (velocita > FERMO && velocita <= BASSO){ printf("Lei sta intralciando il traffico.");

sanzione = M_INTRALCIO;}else if (velocita > BASSO && velocita <= LIMITE1){ printf("Lei ha i pneumatici con il battistrada sotto lo spessore minimo.");

sanzione = M_GOMME;}else if (velocita > LIMITE1 && velocita <= LIMITE1+10){ printf("Lei ha infranto il limite velocità.");

sanzione= M_LIMITE1;}else if (velocita > LIMITE1 +10 && velocita <= LIMITE2){ printf("Lei ha infranto il limite velocità di oltre 10 Km/h.");

sanzione = M_LIMITE10;}else if (velocita > LIMITE2 && velocita <= ALTO){ printf("Lei ha infranto il limite di velocità di %d km/h questa e' guida

pericolosa.", velocita-LIMITE1);sanzione = M_LIMITE2;

}else{ printf("non si rende conto che non sta guidando un AEREO!!!");

sanzione = M_ASSURDO;}

}printf("\nLa contravvenzione prevede il pagamento di %ld.", sanzione);printf("\nE stia più attento la prossima volta!\n");printf("\n----------------------------------------------------");printf("\nPremi ESC per uscire o un altro tasto per continuare");printf("\n----------------------------------------------------");tasto=getch();} while (tasto != 27); /* esce dal programma premuto ESC input*/

}


Funzione per generare sequenze Pseudo Casuali di Numeri contenuta nella libreria stdlib.h vedere Help in linea per la descrizione completa

La funzione restituisce un numero intero compreso tra 1 e 6 simula quindi ilcomportamento di un dado.

int lancia_dado(void){ int quanto=0;

srand((unsigned int)time(NULL));/*inizializzo casualita'*/quanto= 1+rand()%6;/*genero numero casuale da 1 a 6*/return quanto; /*grazie all'operatore resto int*/

}

void main(void){int tasto;int punti;clrscr();

do{

punti=lancia_dado();

} while (tasto!=0);}/*****************************************************//* Programma che simula il lancio di un dado *//* utilizzo di funzione di generazione di un numero *//* casuale *//*****************************************************//*ESERCIZIO NUMERO 14 - POLITECNICO DI MILANO sede CR*//*****************************************************/

#include <stdio.h>#include <stdlib.h>#include <time.h>

/************* PROTOTIPI * FUNZIONI ******************/int lancia_dado(void);/****************************************************/

void main(void){int tasto;int punti;clrscr();

do{printf("\nPremi un tasto ed INVIO per lanciare

il dado (0 per uscire)");scanf("%d",&tasto);

/* la funzione fflush seguente evita problemi in casodi imput errato per maggiori informazioni consultarel'help in linea */

fflush(stdin);if (tasto!=0)

{punti=lancia_dado();

}printf("\nIl lancio del dado ha totalizzato:

%d", punti);} while (tasto!=0);

}

/*****************************************************/

int lancia_dado(void){ int quanto=0;

srand((unsigned int)time(NULL));/*inizializzo casualita'*/quanto= 1+rand()%6;/*genero numero casuale da 1 a 6*//*grazie all'operatore resto int*/return quanto;

}


/****************************************************//* Programma che simula il lancio di un dado *//* utilizzo di funzione di generazione di un numero *//* casuale *//****************************************************//*ESERCIZIO NUMERO 15 POLITECNICO DI MILANO sede CR*//****************************************************/

#include <stdio.h>#include <stdlib.h>#include <time.h>

/************* PROTOTIPI * FUNZIONI *****************/void disegna_titolo(void);void disegna_dado(int valore);int lancia_dado(void);void finestra(int x,int y,int x1,int y1,int sfondo,inttesto);/****************************************************/

void main(void){int tasto;int quanto;clrscr();disegna_titolo();do{

if (tasto==13){

quanto=lancia_dado();disegna_dado(quanto);

}tasto=getch();

} while (tasto!=27);}

/*****************************************************//* I M P L E M E N T A Z I O N E DELLE FUNZIONI *//*****************************************************/

/********************************************//* Funzione che restituisce un intero *//* tra 1 e 6 generato casualmente *//********************************************/int lancia_dado(void){ int quanto=0;srand((unsigned int)time(NULL));

/*inizializzo casualita'*/quanto= 1+rand()%6;

/*genero numero casuale da 1 a 6*/return quanto;

/*grazie all'operatore resto int*/}

/********************************************//* Funzione che disegna in alto allo schermo*//* il titolo del programma e le istruzioni *//********************************************/void disegna_titolo(void){

finestra(1,1,80,6,1,14);gotoxy(1,1);cprintf(" ____ ____\r\n");cprintf("|* * |\\ |* |\\\r\n");cprintf("|*_*_|*\\ |___*|* \\\r\n");cprintf(" \\* * \\| \\*** \\ |\r\n");cprintf(" \\____\\ -----\r\n");finestra(20,1,80,6,1,15);gotoxy(1,1);cprintf("==================================");cprintf("Programma simulatore del lancio del

DADO\r\n\r\n");cprintf("- Premere ESC per Uscire dal

Programma\r\n");cprintf("- Premere INVIO per eseguire un nuovo

lancio\r\n");cprintf("==================================");

}

/********************************************//* Funzione che disegna sotto al titolo *//* la faccia del dado.Riceve come parametro *//* il valore della faccia da stampare. *//********************************************/void disegna_dado(int valore){

finestra(1,7,80,24,0,14);printf("\r\n \r\n");

switch (valore){case 1:

printf(" | | \r\n");printf(" | * | \r\n");printf(" | | \r\n");break;

case 2:printf(" | * | \r\n");printf(" | | \r\n");printf(" | * | \r\n");break;

case 3:printf(" | * | \r\n");printf(" | * | \r\n");printf(" | * | \r\n");break;

case 4:printf(" | * * | \r\n");printf(" | | \r\n");printf(" | * * | \r\n");break;

case 5:printf(" | * * | \r\n");printf(" | * | \r\n");printf(" | * * | \r\n");break;

case 6:printf(" | * * | \r\n");printf(" | * * | \r\n");printf(" | * * | \r\n");break;

default:printf("il dado ha al massimo 6facce!!!\r\n");break;

}printf(" \r\n");

}

/************************************************//* Funzione che permette di utilizzare solo *//* una porzione dello schermo e che permette *//* di definirne il colore di sfondo e del testo.*//* *//* I valori per i colori dello SFONDO sono: *//* BLACK 0, BLUE 1, GREEN 2, CYAN 3, RED 4, *//* MAGENTA 5, BROWN 6, LIGHTGRAY 7. *//* *//* I valori per i colori del TESTO sono: *//* BLACK 0, BLUE 1, GREEN 2, CYAN 3, RED 4, *//* MAGENTA 5, BROWN 6, LIGHTGRAY 7, DARKGRAY 8, *//* LIGHTBLUE 9, LIGHTGREEN 10, LIGHTCYAN 11, *//* LIGHTRED 12, LIGHTMAGENTA 13, YELLOW 14, *//* WHITE 15, BLINK 128. *//************************************************/void finestra(int x,int y,int x1,int y1,int sfondo,int testo){

window(x,y,x1,y1);textbackground(sfondo);textcolor(testo);clrscr();

}


/***********************************************************//* Programma indovina la parola. Dopo l'input della parola*//* viene richiesto di indovinare le lettere che la formano *//***********************************************************//** ESERCIZIO NUMERO 16 - POLITECNICO DI MILANO sede CR ***//***********************************************************/

#include <conio.h>#include <stdio.h>#include <ctype.h>

void main(void){

char carattere;char da_indov[10], da_stamp[10]; /* ARRAY per parola max 10 char */int i, max_parola, tentativi, da_indovinare, trovato;

/* fase di input della parola da indovinare */do{

if ( (carattere >= 'a' && carattere <= 'z') /*controllo dell'input*/|| (carattere >= 'A' && carattere <='Z')) /*accetto solo lettere*/

{carattere=tolower(carattere); /*le converto tutte in minuscole*/da_indov[i]=carattere; /* metto i char in ARRAY */i++;

}else if (carattere != '#') /* se input != da tappo o lettere */{

}} while(i<10 && carattere!='#');/*esco solo se ho max lettere o tappo*/

/*fase di elaborazione viene visualizzata la richiesta di indovinare*/max_parola=i;for(i=0; i<max_parola; i++) /*inizializzo l'ARRAY mascherato*/{

da_stamp[i]='@';}

clrscr();

da_indovinare=max_parola;tentativi=7; /* il max numero di tentativi sbagliati ammissibili*/

do{printf("Indovina la parola, hai %d tentativi.\n\t", tentativi);for(i=0; i<max_parola; i++) /*scorro i caratteri*/{

}

} while (tentativi!=0 && da_indovinare!=0);/*ripeto se ho ancora tentativi o ho ancora lettere da indovinare*/

if (tentativi == 0) /* messaggio di conclusione negativa */{

}else if (da_indovinare == 0)/*messaggio di conclusione positiva*/{

}getch(); /*attendo la pressione di un tasto*/}


/****************************************************//* Programma indovina la parola. *//* Dopo l'input della parola *//* viene richiesto di indovinare le lettere *//* che la formano *//****************************************************//* ESERCIZIO NUMERO 16 POLITECNICO DI MILANO sede CR*//****************************************************/#include <conio.h>#include <stdio.h>#include <ctype.h>

void main(void){

char carattere;char da_indov[10], da_stamp[10];

/* ARRAY per parola max 10 char */int i, max_parola, tentativi, da_indovinare, trovato;

/* fase di input della parola da indovinare */clrscr();i=0;printf("Inserisci la parola da indovinare, un

carattere alla volta(10 max).\n");printf("# per terminare\n");do{

printf("Inserisci il carattere:");scanf("%c", &carattere);

/* acquisisco il carattere */fflush(stdin);if ( (carattere >= 'a' && carattere <= 'z')

/*controllo dell'input*/|| (carattere >= 'A' && carattere

<='Z')) /*accetto solo lettere*/{

carattere=tolower(carattere);/*le converto tutte in minuscole*/

da_indov[i]=carattere;/* metto i char in ARRAY */

i++;}else if (carattere != '#')

/* se input != da tappo o lettere */{

printf("Devi inserire solo lettere!.");/*msg d'errore*/

}} while(i<10 && carattere!='#');

/*esco solo se ho max lettere o tappo*/

/*fase di elaborazione viene visualizzata la richiestadi indovinare*/

max_parola=i;for(i=0; i<max_parola; i++)

/*inizializzo l'ARRAY mascherato*/{

da_stamp[i]='@';}

clrscr();

da_indovinare=max_parola;tentativi=7;

/* il max numero di tentativi sbagliati ammissibili*/

do{printf("Indovina la parola, hai %d

tentativi.\n\t", tentativi);

for(i=0; i<max_parola; i++)/*scorro i caratteri*/

{printf("%c ", da_stamp[i]);

/*visualizzo la parola mascherata*/}printf("\n.Dammi una lettera: ");

/*chiedo l'input di una lettera*/scanf("%c", &carattere);fflush(stdin);if ( (carattere >= 'a' && carattere <= 'z')

|| (carattere >= 'A' && carattere<='Z'))

{carattere=tolower(carattere);

/*converto in minuscola*/trovato=0;for(i=0; i<max_parola; i++)

/*scorro tutti i caratteri*/{

if (carattere == da_indov[i])/*se trovo una corrispondenza*/

{da_stamp[i]=carattere;

/*aggiorno la parola mascherata*/da_indovinare--;trovato=1; /*metto a vero*/

}}

if (trovato == 0)/* se non c'e' corrispondenza */

{tentativi--;}/* decremento i tentativi restanti */

}else{printf("Devi darmi una lettera!");}

/*msg d'errore*/

} while (tentativi!=0 && da_indovinare!=0);/*ripeto se ho ancora tentativi o ho ancora

lettere da indovinare*/if (tentativi == 0)

/* messaggio di conclusione negativa */{

clrscr();printf("La parola da indovinare e':\n");for(i=0; i<max_parola; i++){

printf("%c ", da_indov[i]);}printf("\n. Mi dispiace, ma hai esaurito i

tentativi");}else if (da_indovinare == 0)

/*messaggio di conclusione positiva*/{

clrscr();printf("Bravo!!!. La parola è:\n");for(i=0; i<max_parola; i++){

printf("%c ", da_indov[i]);}

}getch(); /*attendo la pressione di un tasto*/

}


/************************************************************//* Programma QUIZ - sottopone delle domande valuta le *//* risposte ed assegna il punteggio. *//* Le domande e le risposte sono memorizzate in ARRAY. *//************************************************************//*** ESERCIZIO NUMERO 17 - POLITECNICO DI MILANO sede CR ***//************************************************************/

#include <stdio.h>#include <stdlib.h>#include <time.h>/************ PROTOTIPI FUNZIONI ************************/int chiedi(void);void disegna(int a);/********************************************************/void main(void){int i;int risposta;int finito;int punteggio=0;

clrscr();printf("Rispondi a 15 domande di letteratura\n");for (i=1;i<16;i++)

{printf("Domanda n.%d\n",i);risposta=chiedi();punteggio=punteggio + risposta;disegna(risposta);}

printf("\nHai ottenuto %d punti su 15!!!", punteggio);getch();}

int chiedi(void){ int x, quanto;char dimmi;typedef char frase[65];frase domanda[11]= {

"Manzoni ha scritto i Promessi Sposi? (s/n)",

};char risposte[11]= {'s','s','n','s','n','n','n','n','s','n','s'};srand((unsigned int)time(NULL)); /*inizializzo casualita'*/quanto= 1+rand()%10; /*genero numero casuale da 1 a 6*/printf("%s: ", domanda[quanto]); scanf("%c",&dimmi);if (dimmi==risposte[quanto]) return 1;else return 0;}


/*****************************************************//* Programma QUIZ sottopone delle domande valuta le *//* risposte ed assegna il punteggio. *//* Le domande e le risposte sono memorizzate in ARRAY*//*****************************************************//*ESERCIZIO NUMERO 17 POLITECNICO DI MILANO sede CR *//*****************************************************/#include <stdio.h>#include <stdlib.h>#include <time.h>

/************ PROTOTIPI FUNZIONI *********************/int chiedi(void);void disegna(int a);/***************************************************/

void main(void){int i;int risposta;int finito;int punteggio=0;

clrscr();printf("Rispondi a 15 domande di letteratura\n");for (i=1;i<16;i++)

{printf("Domanda n.%d\n",i);risposta=chiedi();punteggio=punteggio + risposta;disegna(risposta);

}printf("\nHai ottenuto %d punti su 15!!!", punteggio);getch();}

/************************************************//* Funzione che scrive a video la domanda *//* ad ogni domanda e' associata una risposta *//* se l'utente risponde esattamente restituisce *//* 1 altrimenti restituisce 0 *//************************************************/int chiedi(void){int x, quanto;char dimmi;

typedef char frase[65];frase domanda[11]= {"Manzoni ha scritto i Promessi Sposi? (s/n)","Salinger ha scritto il Giovane Holden?(s/n)","Dante ha scritto i Promessi Sposi? (s/n)","Silone ha scritto Fontamara? (s/n)","Petrarca ha scritto l'Eneide? (s/n)","Omero ha scritto l'Eneide?(s/n)","Virgilio ha scritto l'Odissea? (s/n)","Sciascia ha scrt Cristo si e' fermato a Eboli?(s/n)","Svevo ha scritto Senilita'? (s/n)","Leopardi ha scritto A Beatrice? (s/n)","Ungaretti ha scritto M'illumino d'immenso? (s/n)"};

char risposte[11]= {'s','s','n','s','n','n','n','n','s','n','s'

};

srand((unsigned int)time(NULL));/*inizializzo casualita'*/quanto= 1+rand()%10;/*genero numero casuale da 1 a 6*/

printf("%s: ", domanda[quanto]);scanf("%c",&dimmi);fflush(stdin);

if (dimmi==risposte[quanto])return 1;

elsereturn 0;

}

/********************************************//* Funzione che scrive a video giusto o *//* sbagliato a seconda del parametro che *//* riceve. Se il parametro e' 1 restituisce *//* giusto altrimenti restituisce sbagliato *//********************************************/void disegna(int a){if (a==1)

printf(" Giusto\n");else

printf(" Sbagliato\n");}


/***********************************************************//* Programma che riceve in input delle parole e stampa *//* in output le parole in ordine alfabetico *//***********************************************************/void main(void){typedef char parola[20];/*parola al max stringa di 20 caratteri*/parola tmp_parola;parola frase[6];

/*ARRAY di max 5 parole + spazio per tappo*/parola frase_ordinata[5];int max_parole,i,j;/*interi che usero' come contatori*/

/* fase di input della stringa */clrscr();printf("\nProgramma che ORDINA le parole");i=0;do{

gets(frase[i]); /* acquisizione della stringa */

} while(i<5 && strcmp(frase[i-1], ""));/* esco se ho inserito il n max di parole oppure *//* se è stato inserito un INVIO cioè = "" stringa vuota*/

/* fase di elaborazione - ordinamento */max_parole=i-1; /* comunque ho contato n parole+1 */for(i=1; i<max_parole; i++)/* scorro le parole */{ /* riconoscete l'algoritmo di ordinamento? */for(j=max_parole-1; j>=i; j--){if (strcmp(frase[j-1],frase[j])>0)/* confronto le parole */

{ strcpy(tmp_parola, frase[j-1]);/* scambio le parole */

strcpy(frase[j-1],frase[j]);strcpy(frase[j],tmp_parola);}

}}

/* fase di output delle parole */

getch();}


/***********************************************************//* Programma che riceve in input delle parole e stampa *//* in output le parole in ordine alfabetico *//***********************************************************//** ESERCIZIO NUMERO 18 - POLITECNICO DI MILANO sede CR ***//***********************************************************/

#include <stdio.h>#include <conio.h>#include <ctype.h>#include <string.h>

void main(void){typedef char parola[20]; /*parola al max stringa di 20 caratteri*/parola tmp_parola;parola frase[6]; /*ARRAY di max 5 parole + spazio per tappo*/parola frase_ordinata[5];int max_parole,i,j; /*interi che usero' come contatori*/

/* fase di input della stringa */clrscr();printf("\nProgramma che ORDINA le parole");i=0;do{

printf("\nIntrodurre 5 parole di max 20 caratteri) o solo INVIO per finire:\n");gets(frase[i]); /* acquisizione della stringa */if (strlen(frase[i]) > 20){

printf("Parola troppo lunga. Reinserire.");}else{

i++; /* se è stata introdotta una parola incremento conteggio */}

} while(i<5 && strcmp(frase[i-1], ""));/* esco dal do se ho inserito il n max di parole oppure *//* se è stato inserito un INVIO cioè = "" stringa vuota*/

/* fase di elaborazione - ordinamento */max_parole=i-1; /* comunque ho contato n parole+1 */for(i=1; i<max_parole; i++)/* scorro le parole */{ /* riconoscete l'algoritmo di ordinamento? */

for(j=max_parole-1; j>=i; j--){

if (strcmp(frase[j-1],frase[j])>0)/* confronto le parole */{

strcpy(tmp_parola, frase[j-1]); /* scambio le parole */strcpy(frase[j-1],frase[j]);strcpy(frase[j],tmp_parola);

}}

}

/* fase di output delle parole */printf("\nEcco le parole:\n");for (i=0;i<5;i++) /*scorro fino al n.max di parole*/{if(frase[i][0]!='')

{printf("(%d) %s ",i+1, frase[i]);

}else{ break;} /* uso non bellissimo del break !!! */

} /* conoscendo il numero di parole */getch(); /* sarebbe meglio usare un ciclo for*/} /* per il numero di cicli esatto, */

/* break e' usato solo per mostrarne*//* l'esistenza!!! */


Funzione che restituisce un carattere letto nello stdin contenuta nella libreria stdio.h vedere Help in linea per la descrizione completa


/********************* prototipi delle funzioni ************/char leggi_tasto(void);/***********************************************************/

void main(void){char t;clrscr();printf("Premi un tasto:");t=leggi_tasto();printf("\nHai premuto il tasto %c con valore ASCII %d",t,t);

}

/************************ leggi_tasto ************//* LEGGE UN TASTO RESTITUISCE IL CARATTERE LETTO */char leggi_tasto(void){char ch;ch = toupper(getch());return ch;}


la pressione di un tasto speciale genera due caratteri…il primo è sempre 0 il secondo indica quale tasto è statopremuto provare a cambiare il listato nel modo seguente

void main(void){char t,t1;t='a';t1='b';

clrscr();/*pulisco lo schermo*/

printf("\nPremi un tasto Funzione oppure due tasti:");/* notare la differenza di comportamento tra tasti F e tasti normali */

t =getch();t1=getch();/*se premo un tasto F non chiede altro input!!!*/

printf("\nHai premuto come primo tasto\n %c\ncon valore ASCII\n %d",t,t);

printf("\ne come secondo tasto lo stdin ha ricevuto anche\n %c\ncon valore ASCII\n %d",t1,t1);

getch();/*attendo la pressione di un tasto :-) per uscire*/}


void main(void){clrscr();gestione_menu();clrscr();}

void gestione_menu(void){char tasto; /* variabile che contiene il tasto premuto*/int conferma;/* variabile che conferma la scelta */int i; /* per contenere un intero */char c; /* per contenere un carattere */char s[20]; /* per contenere una stringa */conferma = 0;do {clrscr();

printf( "╔═══════════════════════════════════╗\n ""║ F1 - per scrivere le lettere ║\n ""║ F2 - per scrivere i numeri ║\n ""║ F3 - per ricevere un intero ║\n ""║ F4 - per ricevere un carattere ║\n ""║ F5 - per ricevere una stringa ║\n ""║ F10- per USCIRE dal programma ║\n ""╚═══════════════════════════════════╝");

tasto=leggi_tasto(); /*aspetto la pressione di un tasto */switch (tasto) {

case 68 :/*TASTO F10 PER USCIRE DAL PROGRAMMA*/clrscr();printf("Grazie di avere usato questo programma!");conferma=1; /*variabile che conferma l'uscita*/break;

case 59 :/* TASTO F1 scrivere delle lettere*/printf("\nEcco le lettere:\n");printf("ABCDEFGHILMNOPQRSTUVZ");printf("\n Premi un tasto per continuare");getch(); /*aspetto un tasto*/break;

case 60 :/* TASTO F2 scrivere dei numeri*/printf("\nEcco i numeri :\n");printf("01234567890");printf("\n Premi un tasto per continuare");getch(); /*aspetto un tasto*/break;

case 61 :/* TASTO F3 ricevere un intero */printf("\n Inserisci un intero:");scanf("%d",&i);printf("\n Ecco l'intero %d",i);getch(); /*aspetto un tasto*/break;

case 62 :/* TASTO F4 ricevere un carattere*/printf("\n Inserisci un carattere:");scanf("%c",&c);printf("\n Ecco il carattere %c",c);getch(); /*aspetto un tasto*/break;

case 63 :/* TASTO F5 PER ricevere una stringa */printf("\n Inserisci una stringa (max 20char):");scanf("%s",&s);printf("\n Ecco la stringa %s",s);getch(); /*aspetto un tasto*/break;

}} while ( conferma != 1 );}


/********************* leggi_tasto ***************************//* LEGGE UN TASTO O TASTO FUNZIONE E RESTITUISCE *//* IL CODICE DI TASTIERA *//*************************************************************/char leggi_tasto(void){char ch;ch = toupper(getch());if ( ch == 0 ){

ch = toupper(getch());}return ch;}/*---------------------------------------------------------*/

Permettono la gestione di strutture dinamiche (creat e e distrutte dall'utente). Un Puntatore è una variabile che contiene l'indirizzo di memoria di un'altra variabile. In C un puntatore si dichiara anteponendo al nome della variabile il simbolo *

operatori descrizione& applicato ad una variabile restituisce il puntatore ad

essa * applicato ad un puntatore restituisce la variabile

puntata

num = 1; p_num = &num; **pp_num = p_num; Tipo e Nome Variabile

Indirizzo della Cella di Memoria Contenuto della

Cella di Memoria int num DS:0000 1int * p_num DS:0001 DS:0000int ** pp_num DS:0002 DS:0001

definizione

/ assegnamento

** * var

var = ** = * = * = * = = & ** = * = ** =


/***********************************************************//* Programma che scambia il valore del contenuto di due *//* variabili intere senza dichiararne altre. *//* *//* Utilizzo di una funzione di scambio variabili. *//* *//* Parametri della funzione PUNTATORI!!!!!!!!!!!!!!!!! *//* *//* In questo esercizio vediamo come sia possibile variare *//* il valore di una variabile passando come parametro ad *//* una funzione il puntatore alla variabile *//***********************************************************//** ESERCIZIO NUMERO 21 - POLITECNICO DI MILANO sede CR ***//***********************************************************/


void scambia(int *x, int *y);

void main(void){

int a,b; /*dichiaro e inizializzo le variabili*/

int *punt_a, *punt_b;

/*fase di input dei due valori visualizzo a video i valori e gli indirizzi */

clrscr();printf("\n Programma che scambia il valore"" di due variabili");

printf("\n Introdurre la prima variabile intera:");scanf("%d", &a);punt_a = &a;

printf("\n Valore variabile a = %d ",a);printf("\n Valore indirizzo variabile a = %X",&a);printf("\n Valore punt_a = %X", punt_a);printf("\n Valore indirizzo di punt_a = %X", &punt_a);printf("\n Valore puntato da *punt_a = %d", *punt_a);getch(); /*attendo la pressione di un tasto*/

printf("\n Introdurre la seconda variabile intera:");scanf("%d", &b);punt_b = &b;

printf("\n Valore variabile b = %d ",b);printf("\n Valore indirizzo variabile b = %X",&b);printf("\n Valore punt_b = %X", punt_b);printf("\n Valore indirizzo di punt_b = %X", &punt_b);printf("\n Valore puntato da *punt_b = %d", *punt_b);getch();/*attendo la pressione di un tasto*/

printf("\n Le variabili prima dello"" scambio valgono a=%d b=%d",a,b);

/*fase di elaborazione, scambio le variabili*/

scambia(&a, &b); /*fase di output*/

Ricordate l'esercizio dello scambio di due variabili senza dichiararne una

terza???


printf("\n Le variabili dopo lo""scambio valgono a=%d b=%d",a,b);

getch();}/***********************************************//* funzione che scambia il contenuto di due *//* variabili. Per poter ottenere lo scambio la *//* funzione riceve come parametri i puntatori *//* alle variabili da scambiare *//***********************************************/

void scambia(int *x, int *y){

*x = *x + *y; /* lo scambio avviene utilizzando */*y = *x - *y; /* i valori contenuti agli indirizzi */*x = *x - *y; /* per cui si scambiano effettivamente */

}


/***********************************************************//* Programma che utilizza ARRAY di caratteri cioe' *//* STRINGHE DI CARATTERI!!! *//* copia concatena rendi minuscolo e maiuscolo *//***********************************************************//** ESERCIZIO NUMERO 22 - POLITECNICO DI MILANO sede CR ***//***********************************************************/#include <stdio.h>#include <conio.h>#include <ctype.h>#include <string.h>

void main(void){

char stringa1[80], stringa2[80]; /*dichiaro stringhe di 80 caratteri*/char stringaTOT[160];int i; /*variabile intera che usero' come indice*/

/* fase di input della stringa */clrscr();printf("\n Programma che utilizza STRINGHE DI CARATTERI");printf("\n Introdurre una stringa di caratteri MAIUSCOLI (max 80):\n");gets(stringa1);

/*fase di elaborazione*/for (i=0; stringa1[i]; i=i+1){stringa2[i]=stringa1[i]; /*copio una stringa nell'altra*/}stringa2[i]='\0';/* chiudo la seconda stringa */

for (i=0; stringa1[i]; i=i+1){

stringa1[i]=tolower(stringa1[i]); /*trasformo in minuscole*/}

/* fase di output delle stringhe */printf("\n\nEd ecco la stringa in formato minuscolo:");printf("\n%s", stringa1);

printf("\n\nEd ecco la stringa in formato maiuscolo:");printf("\n%s", stringa2);

printf("\n\nInfine ecco le stringhe concatenate:\n");strcpy(stringaTOT, stringa1); /* qui uso la funzione copia stringhe!!! */printf("\n%s",strncat(stringaTOT, stringa2, 160));/*N.B. vedere help di strncat per capire il terzo parametro*/getch();

}/******************************************************//* cosa accade se l'input e' diverso da quello atteso?*//******************************************************/


/***********************************************************//* Programma che utilizza ARRAY di caratteri cioe' *//* STRINGHE DI CARATTERI!!! *//* UTILIZZANDO I PUNTATORI A STRINGA *//* *//* Un puntatore a stringa contiene l'indirizzo del primo *//* carattere della stringa *//***********************************************************//** ESERCIZIO NUMERO 23 - POLITECNICO DI MILANO sede CR ***//***********************************************************/

#include <stdio.h>#include <conio.h>#include <ctype.h>#include <string.h>

void main(void){

char frase1[80], frase2[80]; /*stringhe di 80 caratteri*/char fraseTOT[160];char *p1; /*puntatore a stringa*/int i; /*intero che usero' come indice*/

/* fase di input della stringa */clrscr();printf("\nProgramma che utilizza STRINGHE DI CARATTERI");printf("\nIntrodurre una stringa di caratteri MAIUSCOLI (max 80):\n");gets(frase1);

/*fase di elaborazione*/p1 = frase1; /*faccio puntare p1 a stringa1*/i=0;while (*p1){frase2[i] = *p1; /*copio una stringa nell'altra*/*p1++;i++;}frase2[i]='\0';/*metto il terminatore della stringa*/

p1= frase1; /*faccio puntare p1 a stringa1*/

for (i=0; *p1; i=i+1){

*p1 = tolower(*p1);p1++;

}

/* fase di output delle stringhe */printf("\n\nEd ecco la stringa in formato minuscolo:");printf("\n%s", frase1);printf("\n\nEd ecco la stringa in formato maiuscolo:");printf("\n%s", frase2);printf("\n\nInfine ecco la somma delle due stringhe:");strcpy(fraseTOT, frase1);/*qui uso la funzione copia stringhe!!!*/printf("\n%s",strncat(fraseTOT, frase2, 160));getch();

}/****************************************************************//* Mettere dei break point e degli watch per verificare gli *//* assegnamenti e lo scorrere delle stringhe *//****************************************************************/


/************************************* Dato un carattere in ingresso, lo trasforma in un altro carattere, che si trova OFFSET posizioni piu' in la' nell'alfabeto (per esempio con OFFSET = 4, il carattere 'a' diventa 'e'). L'alfabeto considerato e': ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz Per esempio, con OFFSET = 4, la lettera 'X' diventa 'b'. La complessita' del programma sta tutta nel fatto che nella codifica ASCII le sequanze 'A'..'Z' e 'a'..'z' (viene prima la sequenza di caratteri maiuscoli) non sono consecutive, ma c'e' di mezzo un altro insieme di caratteri, per cui occorre spezzare il programmain 2 if. **************************************************************************************************/ #include <stdio.h> #define OFFSET 13; char parola[31]; /*array di 30 char + '\0' fine stringa*/ char convertita[31]; int i=0; void main() { char curr, new; printf("Inserisci la parola da convertire: "); scanf("%s", parola); /*scorro la parola e converto i singoli caratteri*/ while ( parola[i] != '\0' && i<30) { if (parola[i] >= 'A' && parola[i] <= 'Z') { new = parola[i] + OFFSET; if (new > 'Z') { new = 'a' + (new - 'Z'-1); } convertita[i]=new; } else if (parola[i] >= 'a' && curr <= 'z') { new = parola[i] + OFFSET; if (new > 'z') { new = 'A' + (new - 'z'-1); } convertita[i]=new; } else { printf("Nella parola, posizione: %d " "e' stato immesso un carattere non valido\n",i); } i=i+1; /*passo al char successivo dell'array parola*/ }/*fine blocco while*/ printf("la parola convertita e': %s", convertita); } Fare un programma decodifica parole nascoste cioe' deve ricevere in input una parola criptata e restituire il valore dell'offset (chiave di decodif ica) e la relativa decodif ica …

E' una buona scelta? Se assume valore >127?

Provare a mettere in input l'intero alfabeto minuscole e MAIUSCOLE... Applicare OFFSET diversi... Che cosa succede???


Riprendiamo l'ultimo esercizio e vediamo di superarene i limiti… La versione precedente funzionava solo con OFFSET non troppo elevati e non era stata sviluppata accuratamente. Vogliamo ora applicare l'algoritmo di criptazione in modo da poter impiegare qualsiasi valore di OFFSET e vogliamo poterlo utilizare con qualsiasi lettera dell'alfabeto sia maiuscola che minuscola. Quali sono tutti i casi possibili? Casi di OFFSET da 0 a 32.000 se considero tipo int. Di questi quanti sono significativi? l'OFFSET si ripete di 52 in 52 infatti se applico OFFSET 52 ad una lettera in pratica è come applicare OFFSET 0. 1) Devo quindi fare in modo che OFFSET > 52 vengano ricondotti ad un OFFSET compreso tra 0 e 51 ( 53==1; 54==2; 55==3 …) Una volta stabilito il RANGE degli OFFSET devo verificare i possibili casi e come gia' detto nell'esercizio precedente devo distinguere due casi: a) devo applicare OFFSET a lettere MAIUSCOLE b) devo applicare OFFSET a lettere minuscole Quali sottocasi mi si presentano? (new è la nuova lettera generata con OFFSET) a1) applicando l'OFFSET a lettere MAIUSCOLE posso: a1.1) generare altre lettere MAIUSCOLE. Caso semplice new = lettera + offset; a1.2) generare lettere oltre la lettera 'Z'. Se vado oltre devo fare in modo che la distanza da 'Z' venga riportata a partire dalla minuscola 'a'. Questa operazione è possibile con la formula: new = 'a'+ ((lettera + (offset)) - 'Z' -1);


a 1.2.1) generare lettere oltre la lettera 'Z' e che riportate sulle minuscole finiscono oltre la lettera 'z'. In tale caso devo riportare la distanza ancora a partire dalla MAIUSCOLA 'A'. Questa operazione è possibile con la formula: new1= 'A'+ (new -'z'-1); dove new è generata dalla formula precedente. b1) applicando l'OFFSET a lettere minuscole posso: b1.1) generare altre lettere minuscole. Caso semplice new = lettera + offset; b1.2) generare lettere oltre la lettera 'z'. Se vado oltre devo fare in modo che la distanza da 'z' venga riportata a partire dalla MAIUSCOLA 'A'. Questa operazione è possibile con la formula: new = 'A'+ parola[i] + (offset) -'z'-1; b1.3) generare lettere oltre la lettera 'z' e che riporate sulle MAIUSCOLE finiscono oltre la lettera 'Z'. In tale caso devo riportare la distanza ancora a partire dalla minuscola 'a'. Questa operazione è possibile con la formula: new1 = new + 6; dove new è generata dalla formula precedente e 6 è la distanza che separa le MAIUSCOLE dalle minuscole. /***********************************************************//* Il programma di criptazione che abbiamo visto *//* nell'esercizio precedente aveva dei limiti che vogliamo *//* superare. Con questa versione e' possibile usare *//* qualsiasi OFFSET *//***********************************************************//** ESERCIZIO NUMERO 25 - POLITECNICO DI MILANO sede CR ***//***********************************************************/

#include <stdio.h>#include <conio.h>#include <string.h>#include <ctype.h>

char parola[53]; /*array di 52 char + '\0' fine stringa*/char convertita[53];

int i=0, w=0;

int offset; /*OFF_SET di criptazione*/


int main(void){int new;/*provo a criptare l'intero alfabeto*/strcpy(parola,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");printf("\n - %s", parola);/*mostro a video l'alfabeto*/

for (w=0; w<=300; w++) /*con w scorro diversi valori di offset */{/*scorro la parola e converto i singoli caratteri*/

while ( parola[i] != '\0' && i < 52){if (w>52)offset = w%52;}/*prima considerazione l'OFF_SET e' ciclico di 52*/

else{offset=w;}/*a questo punto l'offset non e' mai piu' grande di 52*/if(offset>52) return 0; /*questa riga non verra' mai eseguita*/

if(parola[i]>='A' && parola[i]<='Z') /*se devo convertire MAIU*/{

}

if (parola[i]>='a' && parola[i]<='z') /*se devo convertire minu*/{

}

convertita[i] = new;/*a questo punto ho solo lettere ammissibili*/

if (! isalpha(convertita[i])){ printf("\nparola[i]= %c\n convertita[i]= %c\n offset = %d",

parola[i],convertita[i], offset);return 0;}/*per verifica se prog corretto non verra' mai eseguita*/i=i+1; /*passo al char successivo dell'array parola*/}/*fine blocco while*/

printf("\n%5d - %s", w, convertita);getch();/*aspetto la pressione di un tasto per procedere*/i=0; /*azzero il contatore che scorre la parola*/}/*fine blocco for*/

return 1;}/*fine blocco main*/


/***********************************************************//* Il programma di criptazione che abbiamo visto *//* nell'esercizio precedente aveva dei limiti che vogliamo *//* superare. Con questa versione e' possibile usare *//* qualsiasi OFFSET *//***********************************************************//** ESERCIZIO NUMERO 25 - POLITECNICO DI MILANO sede CR ***//***********************************************************/

#include <stdio.h>#include <conio.h>#include <string.h>#include <ctype.h>

char parola[53]; /*array di 52 char + '\0' fine stringa*/char convertita[53];

int i=0, w=0;int offset; /*OFF_SET di criptazione*/

int main(void){int new;/*attenzione tipo char da -128 a 127 int da ? a ? Cosa succedeva nell'ES precedente se ad un char */

/*aggiungevo un OFF-SET ed il risultato superava il valore 127 ??? */

/*provo a criptare l'intero alfabeto*/strcpy(parola,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");printf("\n - %s", parola);/*mostro a video l'alfabeto*/

for (w=0; w<=300; w++) /*con w scorro diversi valori di offset */

{/*scorro la parola e converto i singoli caratteri*/while ( parola[i] != '\0' && i < 52){

if (isalpha(parola[i]))/*in questo caso e' inutile ho passato */{ /*una stringa fissa fatta di sole lettere*/

if (w>52) /* viene solo messa per fare conoscere */{ /* questo tipo di funzione */

offset = w%52 ; /*prima considerazione l'OFF_SET e' ciclico di 52*/}else{ offset=w;}

/*a questo punto l'offset non e' mai piu' grande di 53*/if(offset>52) return 0; /*questa riga non verra' mai eseguita*/

if(parola[i]>='A' && parola[i]<='Z') /*se devo convertire MAIU*/{

if ((parola[i]+offset) >'Z'){ new = 'a'+ parola[i] + (offset) -'Z'-1;

/* con questa correzione salto il buco tra MAIU e minu */if (new >'z') { new = 'A'+ (new -'z'-1); }

}else { new = parola[i] + offset;/*applico codifica + OFF_SET*/ }

}

if (parola[i]>='a' && parola[i]<='z') /*se devo convertire minu*/{

if ((parola[i]+offset) >'z'){ new = 'A'+ parola[i] + (offset) -'z'-1;

if (new >'Z') { new = new + 6;}}

else {new = parola[i] + offset;}/* con questa correzione risalto il buco tra MAIU e minu */}

convertita[i] = new;/*a questo punto ho solo lettere ammissibili*/

if (! isalpha(convertita[i])){

printf("\nparola[i]= %c\n convertita[i]= %c\n offset = %d",parola[i],convertita[i], offset);return 0;}

/*metto questo per verifica se programma corretto non verra' mai eseguita */}

i=i+1; /*passo al char successivo dell'array parola*/}/*fine blocco while*/printf("\n%5d - %s", w, convertita);getch();/*aspetto la pressione di un tasto per procedere*/i=0; /*azzero il contatore che scorre la parola*/

}

return 1;}


realizzare un programma che tramite scelte da menu permetta di : • stampare a video il calendario dell'Anno 2003 (12 mesi) • stampare a video il calendario di ogni singolo mese dell'anno 2003 • calcolare quanti giorni mancano dalla data attuale ad una data scelta dall'utente nell'anno 2003

la rappresentazione del calendario può essere realizzata con complessità a piacere, ipotizzando limiti e strutture in modo da utilizzare i costrutti e le funzioni del linguaggio C apprese sino a questa parte del corso.

/***********************************************************//* Stampa del calendario anno 2003 *//* e calcolo della distanza tra due date in giorni *//* considerando anno di 360 giorni e mesi di 30 giorni *//***********************************************************//* N.B. questo esercizio serve puramente ad utilizzare il *//* linguaggio C usando quanto appreso in questa parte del *//* corso e serve a stimolare lo studente ad affrontare *//* problematiche apparentemente semplici, che una volta *//* tradotte in algoritmi mostrano la loro complessita'!!! *//***********************************************************//** ESERCIZIO NUMERO 26 - POLITECNICO DI MILANO sede CR ***//***********************************************************//* verificare in quali condizioni il programma non fornisce*//* risultati sensati e quali controlli di input mancano *//***********************************************************/


/***************** Dichiarazioni di tipi *******************/

typedef struct { int giorno;int mese;int anno;

} data;

/************* Dichiarazioni delle funzioni ****************/


void stampa_anno(void);void stampa_mese(int m);void calcola(data data1, data data2);/********************************************************/

void main(void){data d1, d2;int scelta=0;int x=0;

d1.giorno=1; d1.mese=1; d1.anno=1;d2.giorno=1; d2.mese=1; d2.anno=1;

clrscr();do{ /* il ciclo di permette di gestire il menu di scelta *//* parte di enunciazione delle scelte all'utente */printf("\nPremi 1 per stampare il calendario del 2003");printf("\nPremi 2 per stampare il calendario di un mese del 2003");printf("\nPremi 3 per calcolare la distanza tra due date");printf("\nPremi 0 per uscire dal programma\n");scanf("%d", &scelta); /*acquisizione della scelta dell'utente*/fflush(stdin);switch (scelta) { /* elaborazione della scelta dell'utente */case 1: /*Stampa del calendario dell'anno*/

clrscr();stampa_anno(); /*chiamata della funzione*/printf("\npremi un tasto qualsiasi per continuare.");getch(); /*attesa di un tasto*/window(1,1,80,24);/*ripristino della schermo*/textbackground(BLACK);textcolor(LIGHTGRAY);clrscr();break;

case 2: /*Stampa del calendario del singolo mese*/clrscr();/*richiesta di altro input all'utente*/printf("Quale mese vuoi stampare?\n");printf("1= gennaio, 2= febbraio... 12= dicembre\n");scanf("%i", &x); /*acquisizione della scelta dell'utente*/fflush(stdin);clrscr();stampa_mese(x-1);/*chiamata della funzione*/printf("\npremi un tasto qualsiasi per continuare.");getch();window(1,1,80,24);textbackground(BLACK);textcolor(LIGHTGRAY);clrscr();break;

case 3: /*Calcolo della distanza tra due date*/clrscr();/*richiesta di altro input all'utente*/

printf("\nInserisci la prima data\n""formato gg/mm/aaaa: " );

scanf("%2d/%2d/%4d", &d1.giorno, &d1.mese, &d1.anno);fflush(stdin); /*acquisizione della scelta dell'utente*/

printf("\nInserisci la seconda data\n""formato gg/mm/aaaa: " );

scanf("%2d/%2d/%4d", &d2.giorno, &d2.mese, &d2.anno);fflush(stdin); /*acquisizione della scelta dell'utente*/

clrscr();calcola(d1,d2);/*chiamata della funzione*/printf("\npremi un tasto qualsiasi per continuare.");getch();window(1,1,80,24);


textbackground(BLACK);textcolor(LIGHTGRAY);clrscr();break;

case 0: /*Uscita dal programma*/clrscr();break;

default:/*Gestione delle scelte errate*/clrscr();printf("Le scelte consentite sono 1 2 3 e 0 per Uscire");printf("\npremi un tasto qualsiasi per continuare.");getch();clrscr();break;

}

} while (scelta != 0);/*resto nel ciclo se scelta !=0*/printf("\nGrazie di avere usato questo programma.");}

/****************************************************//* Stampa Anno questa funzione utilizza la funzione *//* Stampa Mese ripetendola per ogni mese dell'anno *//****************************************************/void stampa_anno(void){int i;for (i=0; i<=11; i++)/*scorro i 12 mesi*/

{if (i==6){ /*metto in due videate 6 mesi e 6 mesi*/

printf("\n\npremi un tasto qualsiasi per continuare.");getch();clrscr();}

stampa_mese(i);}

}/*************************************************//* Stampa Mese *//* questa funzione stampa un mese dell'anno 2003 *//*************************************************/void stampa_mese(int m){

int d=0; /*contatore per ciclo*/

switch (m) /*gestore scelta del mese*/{/*ogni mese, cioe' ogni case si differenzia *//*dagli altri per: la differente porzione di *//*video utilizzata, la stampa dell'intestazione*//*gli spazi per identificare il primo giorno *//*della settimana, il valore di fine ciclo */

case 0: window(1,1,21,8); /* Gennaio 2003 */textbackground(WHITE);textcolor(BLUE); clrscr();cprintf(" G E N N A I O ");/*il primo giorno e' "me"*/cprintf("lu ma me gi ve sa dm "

" ");/*la porzione di video usata e' quella strettamente *//*indispensabile ed il testo va a capo automaticamente *//*in quanto esaurisce le colonne e passa alla riga *//*sottostante senza bisogno del carattere di controllo \n */for (d=1; d<=31; d++){

cprintf("%2i ",d);}break;


case 1: window(22,1,42,8); /* Febbraio 2003 */textbackground(BLUE);textcolor(WHITE);clrscr();cprintf(" F E B B R A I O ");cprintf("lu ma me gi ve sa dm "

" ");/*il primo giorno e' "sa"*/for (d=1; d<=28; d++){


case 2: window(43,1,63,8); /* Marzo 2003 */textbackground(WHITE);textcolor(BLUE); clrscr();cprintf(" M A R Z O ");cprintf("lu ma me gi ve sa dm "



case 3: window(1,9,21,17); /* Aprile 2003 */textbackground(BLUE);textcolor(WHITE); clrscr();cprintf(" A P R I L E ");cprintf("lu ma me gi ve sa dm ");/*il primo giorno e' "ma"*/

" ");for (d=1; d<=30; d++){


case 4: window(22,9,42,17); /* Maggio 2003 */textbackground(WHITE);textcolor(BLUE); clrscr();cprintf(" M A G G I O ");cprintf("lu ma me gi ve sa dm "

" ");/*il primo giorno e' "gi"*/for (d=1; d<=31; d++){


case 5: window(43,9,63,17); /* Giugno 2003 */textbackground(BLUE);textcolor(WHITE); clrscr();cprintf(" G I U G N O ");cprintf("lu ma me gi ve sa dm "

" ");/*il primo giorno e' "dm"*/for (d=1; d<=30; d++){


case 6: window(1,1,21,8); /* Luglio 2003 */textbackground(WHITE);textcolor(BLUE); clrscr();cprintf(" L U G L I O ");cprintf("lu ma me gi ve sa dm ");/*il primo giorno e' "ma"*/

" ");for (d=1; d<=31; d++){


case 7: window(22,1,42,8); /* Agosto 2003 */textbackground(BLUE);textcolor(WHITE); clrscr();cprintf(" A G O S T O ");


cprintf("lu ma me gi ve sa dm "" ");/*il primo giorno e' "ve"*/

for (d=1; d<=31; d++){


case 8: window(43,1,63,8); /* Settembre 2003 */textbackground(WHITE);textcolor(BLUE); clrscr();cprintf(" S E T T E M B R E ");cprintf("lu ma me gi ve sa dm ");/*il primo giorno e' "lu"*/for (d=1; d<=30; d++){


case 9: window(1,9,21,17); /* Ottobre 2003 */textbackground(BLUE);textcolor(WHITE); clrscr();cprintf(" O T T O B R E ");cprintf("lu ma me gi ve sa dm "

" ");/*il primo giorno e' "me"*/for (d=1; d<=31; d++){


case 10: window(22,9,42,17); /* Novembre 2003 */textbackground(WHITE);textcolor(BLUE); clrscr();cprintf(" N O V E M B R E ");cprintf("lu ma me gi ve sa dm "



case 11: window(43,9,63,17); /* Dicembre 2003 */textbackground(BLUE);textcolor(WHITE); clrscr();cprintf(" D I C E M B R E ");cprintf("lu ma me gi ve sa dm ");/*il primo giorno e' "lu"*/for (d=1; d<=31; d++){


default: break;}

}

/********************************************//* Calcola distanza in giorni tra due date. *//* Per semplificare il problema: *//* - Ogni mese viene considerato di 30 gg *//* - L'anno viene considerato di 360 giorni *//********************************************/void calcola(data data1, data data2){int diff_anno=0, diff_mese=0, diff_giorno=0, tot=0;int t_a=0,t_m=0,t_g=0;

/*controllo che le date siano consecutive*/if (data2.anno<data1.anno)

{ /*se non sono consecutive scambio le due date*/t_a=data1.anno; data1.anno =data2.anno; data2.anno =t_a;t_m=data1.mese; data1.mese =data2.mese; data2.mese =t_m;t_g=data1.giorno; data1.giorno=data2.giorno; data2.giorno=t_g;

}


if (data2.anno==data1.anno && data2.mese<data1.mese){ /* se anno e' lo stesso verifico siano consecutive */

/*se non sono consecutive le scambio */t_m=data1.mese; data1.mese=data2.mese; data2.mese=t_m;t_g=data1.giorno; data1.giorno=data2.giorno; data2.giorno=t_g;

}if (data2.anno==data1.anno &&

data2.mese==data1.mese &&data2.giorno<data1.giorno)

{ /*se anno e mese sono gli stessi verifico siano consecutive*//*se non sono consecutive le scambio */t_g=data1.giorno; data1.giorno=data2.giorno; data2.giorno=t_g;

}/* a questo punto le due date sono consecutive */

if (data2.anno==data1.anno){ diff_anno=0;}

else{

diff_anno = data2.anno - data1.anno;/* sono distanti oltre i 365 gg? Se no azzero diff_anno*/if (diff_anno==1 && data2.mese<data1.mese){diff_anno=0;}

}

if (data2.mese==data1.mese){ diff_mese=0;}

else{

diff_mese = data2.mese - data1.mese;/* sono distanti oltre 30 gg? se no azzero diff_mese*/

if (diff_mese==1 && data2.giorno<data1.giorno){diff_mese=0;}if (diff_mese<0){diff_mese=12+diff_mese;}

}

if (data2.giorno==data1.giorno){diff_giorno=0;}

else{diff_giorno = data2.giorno - data1.giorno;

if (diff_giorno<0){diff_giorno=30+diff_giorno;}}

/* calcolo la distanza in giorni tra le due date */tot= (diff_anno*360) + (diff_mese*30) + diff_giorno;

printf("\nla distanza tra le due date %2i/%2i/%4i - %2i/%2i/%4i \n""e' di %i + %i + %i giorni. totale:%i",data1.giorno, data1.mese, data1.anno,data2.giorno, data2.mese, data2.anno,diff_giorno, diff_mese*30, diff_anno*360, tot);

}


/******************************************************************//* USO DEL COSTRUTTORE DI TIPO STRUCT "RECORD" *//******************************************************************//******************************************************************//****** ESERCIZIO NUMERO 27 - POLITECNICO DI MILANO sede CR ******//******************************************************************//* una banale raccolta di dati di studenti, ci servira' per altri *//* esercizi piu' complessi *//******************************************************************/#include <stdio.h>#include <stdlib.h>#include <string.h>#include <conio.h>#define FALSO 0#define VERO 1/********* definizione tipi **********/typedef int boolean;typedef struct elem {

int voto; /* dato di tipo intero */char nome[20]; /* nome dello studente */int matricola; /* matricola dello studente */

} elemento_lista; /* elemento della lista */elemento_lista Dati[10];

void main(void){int scelta, i=0, tolgo=0, j=0;boolean continua = VERO;while (continua)

{/****** Menu delle scelte *******************************/printf("\n-------Scegliere una operazione-------\n");printf("1) Aggiungere un elemento alla lista\n");printf("2) Vedere il Primo elemento dell'ARRAY\n");printf("3) Togliere un elemento dall'ARRAY\n");printf("4) Verificare se l'ARRAY e' vuoto"\n);printf("5) Stampa l'ARRAY\n");printf("6) Stampa l'elenco degli ammessi all'orale\n");printf("7) Esci dal programma\n");printf("Scelta: "); scanf("%d", &scelta); fflush(stdin);clrscr();/****** Fine Menu delle scelte ***************************/switch (scelta){

/*Voglio inserire un elemento nell'ARRAY*/case 1: if (i<=9)

{printf("Matricola: ");scanf("%d", &Dati[i].matricola); fflush(stdin);printf("Nome: ");scanf("%s", Dati[i].nome); fflush(stdin);printf("Voto: ");scanf("%d", &Dati[i].voto); fflush(stdin);i=i+1; /*conto quanti elementi inserisco */}else {printf("\n Hai inserito tutti gli elementi SPAZIO finito");}break;

/*Voglio Visualizzare il Primo elemento della lista */case 2:

clrscr();printf("\n---\nmatricola -%d\nnome - %s\nvoto %d\n---",

Dati[1].matricola, Dati[1].nome, Dati[1].voto);break;

/*Voglio togliere un elemento dalla lista */case 3: clrscr();

printf("Quale elemento vuoi togliere[0-9]? ");scanf("%d", &tolgo);Dati[tolgo].matricola=0;strcpy(Dati[tolgo].nome,"");Dati[tolgo].voto=0;break;


/*Voglio verificare se l'ARRAY e' pieno oppure se e' vuoto */case 4: clrscr();

for (j=0;j<=9;j++){if (strcmp(Dati[j].nome,"")){printf("\nLa lista contiene elementi\n");break;

}}if (j==10) printf("\nLa lista e' vuota\n");break;

/*Voglio stampare il contenuto della lista */case 5: clrscr();

for (j=0;j<=9;j++){printf("\n--- matricola -%d nome - %s voto %d ---",

Dati[j].matricola, Dati[j].nome, Dati[j].voto);}break;

case 6: clrscr();/*stampo voti maggiori di 18*/for (j=0;j<=9;j++){if(Dati[j].voto>=18){printf("\n---matricola -%d nome - %s voto %d ---",

Dati[j].matricola, Dati[j].nome, Dati[j].voto);}

}break;

/*Voglio uscire dal programma*/case 7: continua=FALSO;

break;default:

break;}/*chiudo switch*/}/*chiudo while*/

}/*chiudo main*/


Il programma deve consentire di giocare una partita a Battaglia Navale contro il Computer. Come prima cosa il giocatore deve posizionare le sue navi (formate da pezzi) sulla griglia. Poi il computer posizionerà le sue navi in modo casuale sulla sua griglia. Dopo la fase di posizionamento delle navi, verrà chiesto al giocatore di sparare i suoi colpi che verranno alternati a colpi casuali sparati dal computer. Ogni due colpi, dopo che anche il computer ha sparato il suo colpo verranno mostrate su video le griglie con l'esito del colpo (mancato o colpito). Il programma termina se un giocatore ha colpito tutte le navi dell'avversario oppure se il giocatore vuole smettere, in tal caso il risultato della partita viene calcolato in base al numero di navi colpite.

mettete voi tutte le include necessarie…#include <dos.h> /*N.B. la portabilita' e' solo sui PC non e' ANSI!*/

/*ci serve per la funzione delay che attende... */#define D_OR 4 /* dimensione orizzontale della griglia */#define D_VE 4 /* dimensione verticale della griglia */#define PEZZI 4 /* pezzi di navi da disporre nella griglia*/

1 2 3 4 5 61 . . . . . .2 . . . . . .3 . . o o . .4 . . . o . .5 . . . o . .6 . . . . . .

/******************** Variabili globali ****************************/char matrice_pc[D_OR][D_VE]; /*per memorizzare i pezzi di navi*/char matrice[D_OR][D_VE]; /*per memorizzare i pezzi di navi*/

char matrice_colpi_pc[D_OR][D_VE]; /*per memorizzare i colpi sparati*/char matrice_colpi[D_OR][D_VE]; /*per memorizzare i colpi sparati*/

int colpite=0, colpite_pc=0; /*conto i pezzi di navi colpiti */

/**************** Prototipi delle funzioni *************************/void inizializza_matrice(char m[D_OR][D_VE]);void disegna_matrice(char m[D_OR][D_VE]);void metti_navi(char m[D_OR][D_VE], int chi);void spara(void);void spara_pc(void);

Nella grigliapossono esserci:

'.'= vuoto[prima sparo]

'o'= nave[prima sparo]

'X'= colpito[dopo]

'-'= mancato[dopo]


char leggi_tasto(void);void main(void){int basta=0; /* controlla prosecuzione del programma */clrscr();printf("----- BATTAGLIA NAVALE -----\n");

inizializza_matrice(matrice_pc); /* azzero la griglia PC */inizializza_matrice(matrice); /* azzero la griglia utente */inizializza_matrice(matrice_colpi); /* azzero griglia colpi PC */inizializza_matrice(matrice_colpi_pc);/* azzero griglia colpi utente*/

metti_navi(matrice, 1); /* input delle navi dell'utente*/metti_navi(matrice_pc, 2); /* input delle navi del PC */

do {disegna_matrice(matrice_colpi_pc);/* mostro i colpi del PC */printf(" COLPI PC\n");disegna_matrice(matrice_colpi); /* mostro i colpi utente */printf(" COLPI GIOCATORE\n");

spara(); /*input del colpo dell'utente*/spara_pc(); /*input del colpo del PC */

printf("\nPremi un tasto per continuare o ESC per uscire:");basta=leggi_tasto();

} while( (basta!=27) && (colpite!=PEZZI) && (colpite_pc!=PEZZI) );/* esco se e' stato premuto ESC oppure se qualcuno ha vinto */

printf("\nRISULTATO FINALE\n");disegna_matrice(matrice_colpi_pc); /* mostro i colpi del PC */printf(" COLPI PC\n");

disegna_matrice(matrice_colpi); /* mostro i colpi dell'utente */printf(" COLPI SPARATI \n");

if (colpite_pc==colpite) /*stampo il risultato della partita*/{printf("\n Partita terminata in PAREGGIO.");}

else {if (colpite_pc>colpite)

printf("\nIl vincitore e' il COMPUTER.");else

printf("\nIl COMPUTER ha perso, Complimenti!!!");}

}


/********** F U N Z I O N I *****************//*********************************************//* Inizializza la matrice con un valore char *//* metto '.'= [casella vuota] nella matrice *//*********************************************/void inizializza_matrice(char m[D_OR][D_VE]){int i,j; /*coordinate matrice*/for (i=0; i<=D_OR; i++)

{ for (j=0; j<=D_VE; j++)if (j==D_VE) m[i][j]='\0';else m[i][j]='.'; }

}/*******************************************//* funzione che riempie le matrici *//* con le navi (pezzi della battaglia) *//* il parametro "chi" indica: PC o utente *//*******************************************/void metti_navi(char m[D_OR][D_VE], int chi){int x,y; /*coordinate della matrice*/int i;int coordx, coordy;/*variabile per coordinate casuali*/switch(chi){case 1: /* e' l'utente */printf("devi inserire le tue navi \n"

"il campo di battaglia ha le\n""dimensioni %i x %i \n""inserisci %i pezzi di nave \n""indicando riga,colonna \n""coordinate da 0 a %d: \n",D_OR, D_VE, PEZZI, D_OR-1);

for (i=0; i<PEZZI; i++){ scanf("%d,%d",&x,&y);

fflush(stdin);if ( (x<D_OR && y<D_VE) && (m[x][y]!='O') )

{ m[x][y]='O';}else{

if (m[x][y]=='O'){printf("Coordinata gia' riempita!!!");i--;}else{printf("Coordinate errate!!!"); i--;}

}}break;case 2: /* e' il PC*/coordx=0; coordy=0;printf("\nGenerazione griglia PC attendere:");for (i=0; i<PEZZI; i++){srand((unsigned int)time(NULL));coordx= 0+rand()%D_OR;printf(".");delay(1739);/*attendo per generare nuovo casuale*/srand((unsigned int)time(NULL));coordy= 0+rand()%D_VE;printf("*");if (m[coordx][coordy]!='O')

/*se non c'è altra nave*/{m[coordx][coordy]='O';printf("%d",i);}

/*riempio griglia*/else /*se c'era altra nave faccio altro ciclo*/{i--;}

}printf("Generazione terminata.");break;default: /*Messaggio d'errore*/printf("Valore parametro non consentito.");

exit(0);break;}}

/***********************************************//* Funzione che genera due interi *//* tra 0 e D_OR-1 / D_VE-1 generati casualmente*//* e controlla se il PC ha colpito o mancato *//***********************************************//*L'algortimo e' da migliorare. Infatti lacasualita' genera spesso gli stessi numeri.Quando il PC ha già sparato molti colpi riesce afatica a trovare delle caselle in cui deve ancorasparare. Implementare un algoritmo aggiuntivo chetenga conto delle caselle in cui non ha giàsparato.************************************************/void spara_pc(void)

{int i;int coordx=0, coordy=0;/*variabili per coordinate casuali*/

int valido=0;/*controllo se colpo e' ammissibile*/

printf("\nGenerazione colpo del PC attendere :");

do {valido=0; /*inizializzo a colpo ammissibile*/srand((unsigned int)time(NULL));coordx= 0+rand()%D_OR;/*genero la coordinata tra 0 e D_OR-1 */printf(".");delay(1139);/*attendo per nuovo casuale*/srand((unsigned int)time(NULL));coordy= 0+rand()%D_VE;printf("(%d %d)",coordx, coordy);

if (matrice_colpi_pc[coordx][coordy]!='.'){ printf("- gia' sparato\n");valido=1;

/*se ho gia' sparato nella cella ripeto*/}

else {/*se non ho già sparato verifico se ho colpito*/

if (matrice[coordx][coordy]=='O'){matrice_colpi_pc[coordx][coordy]='X';colpite_pc=colpite_pc+1;} /* colpito */else{matrice_colpi_pc[coordx][coordy]='-';}/* mancato */

}} while (valido!=0);/*ripeto sino a quando non ho un colpo valido*/

printf("\nColpo Sparato dal PC: %d - %d\n",coordx, coordy);}


/***********************************************//* Funzione che chiede l'input del colpo *//* da parte dell'utente *//* e controlla se l'utente ha colpito o mancato*//***********************************************/void spara(void){int x=0,y=0; /*coordinate della matrice*/int i;int valido=0;/*controllo se colpo ammissibile*/

printf("\nIntroduci le coordinate tuo colpo:");

do {valido=0;scanf("%d,%d",&x,&y);fflush(stdin);if (x<D_OR && y<D_VE)/*se le coordinate sono ammissibili*/{

if (matrice_colpi[x][y]!='.')/*se non ho gia' sparato nella cella */{printf("\n Colpo gia' sparato!!\n Coord:");valido=1;}else{

if (matrice_pc[x][y]=='O'){matrice_colpi[x][y]='X';colpite=colpite+1;} /* colpito */else{matrice_colpi[x][y]='-';}/*mancato*/}

}else

{printf("Coordinate errate""(ammesse da 0 a %i)!",D_OR-1);}

} while (valido!=0);

printf("\nColpo Sparato dall'utente: %d - %d\n",x, y);}

/****************************************//* disegna a video il contenuto della *//* matrice passata *//****************************************/void disegna_matrice(char m[D_OR][D_VE]){int x,y;

printf("\n ");for(x=0; x<D_OR; x++){ printf(" %d",x);}/* stampo i numeri delle colonne */for (x=0; x<D_OR; x++)/* scorro le righe */{printf("\n%d ",x);/* stampo i numeri di riga*/for (y=0; y<D_VE; y++) /* scorro le colonne */{printf("%c ",m[x][y]);/*stampo la matrice*/

}}

}/******************************************//* Legge un tasto o un tasto funzione e *//* restituisce il suo valore *//******************************************/char leggi_tasto(void){char ch;ch = toupper(getch());if ( ch == 0 ){

ch = toupper(getch());}return ch;}

Il programma deve simulare il gioco delle tre carte contro il Computer, il Computer fa il mazziere e chi usa il programma deve indovinare dove si trova l'Asso. (Scrivere la descrizione dell'algoritmo prima di implementare il programma). Come prima cosa il computer rimescola le tre carte. Poi il giocatore effettua la scelta ed il computer comunica il risultato, viene incrementata una classifica delle vincite e viene richiesto al giocatore se desidera giocare ancora. Il programma termina quando il giocatore non vuole più scoprire la carta. main{mostra_carte(); printf("Istruzioni del gioco...");do { mescola_carte(); /*il PC ricalcola la posizione*/

scegli_carta(); /*l'utente deve indicare una carta*/

mostra_carte(); /*il PC mostra le carte*/

mostra_risultato(); /*il PC mostra il risultato*/

} while (ancora!=0)}/*dovete usare questo main*/

A ♠

A

2 ♦ ♦

2

4 ♣ ♣ ♣ ♣

4


/******************************************************************//* Il Gioco delle Tre Carte *//******************************************************************//* Il computer e' il mazziere che mescola le tre carte *//* solo una delle tre carte vince e il giocatore deve indovinare *//* dove si trova l'Asso *//******************************************************************//******************************************************************//****** ESERCIZIO NUMERO 29 - POLITECNICO DI MILANO sede CR ******//******************************************************************/

#include <stdio.h>#include <conio.h>#include <time.h>#include <stdlib.h>

#include <dos.h> /*N.B. la portabilita' e' solo sui PC non e' ANSI!*//*ci serve per la funzione delay che attende... */

/******************** variabili globali ****************************/char trecarte[3]; /*ARRAY Mazzo di tre carte*/

/*Asso, quattro, tre */

int scelta;/*carta scelta dal giocatore*/

int puntiPC=0,puntiGiocatore=0;

/**************** Prototipi delle funzioni *************************/void mescola_carte(void);void mostra_carte(void);void scegli_carta(void);void mostra_risultato(void);char leggi_tasto(void);/*************************************************************/

void main(void){clrscr();printf("Istruzioni del gioco... \n"

"il computer mescola le tre carte\n""puntare dove si trova l'Asso \n"" 1 2 o 3... \n""--------------------------------\n""oppure premere 0 per terminare \n");

trecarte[0]='A';trecarte[1]='3';trecarte[2]='4';trecarte[3]='\0';/*NB le posizioni nell'ARRAY partono da 0 */mostra_carte();do { mescola_carte(); /*il PC ricalcola la posizione*/

scegli_carta(); /*l'utente deve indicare una carta*/mostra_carte();mostra_risultato(); /*il PC mostra il risultato*/

} while (scelta!=0);}


/****************** F U N Z I O N I ***************************/void mescola_carte(void){int asso, tre, quattro;/*posizioni delle 3 carte*/

printf("Attendere sto mescolando le carte....");/*SCELGO DOVE METTERE L'ASSO */srand((unsigned int)time(NULL));delay(1739);/*attendo per generare nuovo casuale*/srand((unsigned int)time(NULL));asso= rand()%3; /*ho scelto la posizione dell'ASSO*/

/*SCELGO DOVE METTERE IL TRE ED IL QUATTRO*//*LI POSIZIONO SENZA PROBLEMI IL GIOCO NON*//*VIENE INFLUENZATO DA QUESTA SCELTA */switch(asso)

{case 0: tre=1; quattro=2; break;case 1: tre=2; quattro=0; break;case 2: tre=0; quattro=1; break;default: printf("\nERRORE quale!!!");exit(0);}

trecarte[asso]='A';trecarte[tre]='3';trecarte[quattro]='4';printf("\nScegli la carta...\n");}

/***************************/void mostra_carte(void){printf("\n----- ----- -----\n"

"| | | | | |\n""| %c | | %c | | %c |\n""| | | | | |\n""----- ----- -----\n"" 1 2 3 \n",trecarte[0],trecarte[1],trecarte[2]);

}/**********************/void scegli_carta(void){do {

scanf("%d", &scelta);fflush(stdin);} while (scelta!=1 && scelta !=2 && scelta !=3 && scelta !=0);

}

/*******************************************/void mostra_risultato(void){if(trecarte[scelta-1]=='A')/*ARRAY parte da 0 => -1 */

{ printf("HAI VINTO!!!\n"); puntiGiocatore ++; }else{ printf("Spiacente hai perso!!!\n");puntiPC ++; }

printf("\nPC %d - Giocatore %d\n", puntiPC, puntiGiocatore);}


Programma con funzioni per la gestione di una lista di numeri interi. La lista, implementata in questo programma, può essere vista come una coda di tipo LIFO Last-In First-Out (chiamate anche stack), immaginate come se i dati fossero una pila di piatti, l'ultimo inserito sulla pila è anche il primo che potete togliere.

In pratica andremo ad implementare un programma che definisce un tipo: struttura che contiene il DATO (in questo caso di tipo INTERO) e contiene anche il puntatore al prossimo elemento NEXT. Nel programma creeremo delle funzioni per la gestione della lista: Inizia_lista Crea una lista vuota Inserisci Aggiunge un elemento alla lista Primo Mostra il primo elemento della lista Vuota Verifica se la lista è vuota o piena Stampa Mostra il contenuto di tutta lista Toglie Elimina il primo elemento della lista e creeremo un piccolo menu di scelte per utilizzare la lista: -------Scegliere una operazione------- 1) Aggiungere un elemento alla lista 2) Vedere il Primo elemento della lista 3) Togliere un elemento alla lista 4) La lista e' Vuota ? 5) Stampa la lista 6) Esci dal programma

/***********************************************//* OPERAZIONI CON LE LISTE *//***********************************************/#include <stdio.h>#include <stdlib.h>#include <conio.h>

#define FALSO 0#define VERO 1#define ERRORE 0#define GIUSTO 1

/********* definizione tipi **********/typedef int boolean;typedef int tipo_elemento;typedef struct elem *p_lista;

typedef struct elem {/*la lista e' formata da un */int dato; /*dato di tipo intero e da */p_lista next /*un puntatore al prossimo */

} elemento_lista; /* elemento della lista */

/********** prototipi funzioni ***********/p_lista inizia(void);/*restituisce la lista vuota */

int vuota(p_lista pl);/*verifica se lista e' vuota*/

int inserisci(p_lista *pl, tipo_elemento e);/* aggiunge un elemento in testa */

void stp_primo(p_lista pl);/*stampa il primo elemento della lista */

void toglie(p_lista *pl);/* toglie il primo elemento della lista */

void stampa (p_lista pl);/* stampa tutta la lista */

void main(void){int scelta;boolean continua = VERO;tipo_elemento e;p_lista l;

l= inizia(); /*inizializzo la lista la facciopuntare a NULL*/while (continua){/************* Menu delle scelte ****************/printf("-------Scegliere una operazione-------\n");printf("1) Aggiungere un elemento alla lista\n");printf("2) Vedere il Primo elemento dellalista\n");printf("3) Togliere un elemento alla lista\n");printf("4) La lista e' Vuota ?\n");printf("5) Stampa la lista\n");printf("6) Esci dal programma\n");printf("Scelta: "); scanf("%d", &scelta);fflush(stdin);clrscr();/****** Fine Menu delle scelte *******************/switch (scelta){

/*Voglio inserire un elemento nella lista*/case 1: printf("Elemento:");

scanf("%d", &e);fflush(stdin);


if (inserisci (&l, e)== ERRORE)printf("\nErrore!!!\n");

else printf("\nInserito!!!\n");break;

/*Voglio Visualizzare il Primo element della lista*/case 2: if (vuota(l))

printf("\nLa lista e' vuota!!!\n");else {printf("\nIl Primo Elemento e': ");stp_primo(l);}break;

/*Voglio togliere un elemento dalla lista */case 3: if (vuota(l))

printf("\nLa lista e' Vuota!!!!\n");else toglie(&l);break;

/*Voglio verificare se lista e' piena o e' vuota */case 4: if (vuota(l))

printf("\nLa lista e' Vuota!!!!\n");else printf("\nLa lista e' Piena!!!\n");break;

/*Voglio stampare il contenuto della lista */case 5: stampa(l);

break;/*Voglio uscire dal programma*/

case 6: continua=FALSO;break;

default:break;}

}}

/***********************************************//******** implementazione delle funzioni *******/

p_lista inizia() /* inizializzo la lista */{ /* faccio puntare a NULL*/p_lista temp; /* il primo elemento */temp=NULL;return temp;

}

/**********************************************/int vuota(p_lista pl) /* verifico se lista e'*/{ /* piena oppure vuota */if (pl==NULL) return (VERO);else return (FALSO);

}

/**********************************************/int inserisci(p_lista *pl, tipo_elemento e)/*inserisco un elemento*/{p_lista temp;temp= (p_lista) malloc (sizeof(elemento_lista));/*alloco spazio. A cosa punta next? indefinito */if (temp==NULL) return ERRORE;

/*se non riesco al allocare restituisco ERRORE*/temp->dato = e; /* inserisco il dato */temp->next = *pl; /* punto al prossimo elemento */*pl = temp; /* punto all'elemento inserito */return GIUSTO;

}

/**************************************/void stp_primo(p_lista pl)

{printf("%d\n", pl->dato);

/*stampo il primo elemento*/}

/********************************/void toglie(p_lista *pl){p_lista temp;if (vuota(*pl)) return;

/* se e' vuota non faccio nulla */temp=*pl; /* entrambe puntano alla lista */*pl= temp->next; /* la lista punta al successivo */free (temp); /* dealloco temp */

}

/*************************/

void stampa(p_lista pl){printf("[");/* stampo una quadra per inizio lista */while (pl!=NULL)/* fino a quando non punta a NULL */

{printf("(");/*metto ogni elemento tra due tonde*/printf("%d", pl->dato);/* stampo elemento */printf(")");/* chiudo le tonde */pl=pl->next;/* punto al successivo */

}printf("]\n");/* stampo una quadra per fine lista */

}


Realizzare un programma che permetta la gestione di una semplice RUBRICA strutturata a lista che permetta di inserire i dati di una persona quali ad esempio COGNOME, NOME, TELEFONO. Strutturare le funzioni di inserimento, e cancellazione degli elementi della lista; implementare poi anche una funzione per la ricerca di una o piu' occorrenze all'interno della lista. Ad esempio deve essere possibile poter visualizzare tutti gli elementi della lista con: COGNOME == "ROSSI".


/******************************************************************//* RUBRICA - OPERAZIONI CON LE LISTE *//******************************************************************//* il programma utilizza delle funzioni per gestire una lista di *//* indirizzi (rubrica), tramite delle funzioni: *//* inizia, vuota, inserisci, primo, toglie, stampa *//******************************************************************//* l'implementazione utilizzata in questo esempio e' di *//* tipo procedurale... e' possibile usarne anche una funzionale...*//******************************************************************//****** ESERCIZIO NUMERO 31 - POLITECNICO DI MILANO sede CR ******//******************************************************************/

#include <stdio.h>#include <conio.h>#include <stdlib.h>#include <string.h>

#define GIUSTO 1#define ERRORE 0#define VERO 1#define FALSO 0

/*********** definizioni tipi di dati ****************/typedef int boolean;typedef struct elem *p_lista;

typedef struct { char nome[20]; /* il tipo persona */char cognome[20]; /* e' composto da */char n_telefono[20]; /* tre stringhe */

} persona;

typedef persona tipo_elemento;

typedef struct elem { /* la lista e' formata da un */persona dato; /* dato di tipo persona e da */p_lista next; /* un puntatore al prossimo */} elemento_lista;/* elemento della lista */

/******************** prototipi funzioni ********************/

int inserisci_dati(p_lista *pl,tipo_elemento e);/*aggiunge un elemento alla lista*/

void cancella_dati(p_lista *pl);/* cancella il primo elemento della lista*//* provate a cancellare un elemento a scelta dell'utente!*/

void stampa_rubrica(p_lista pl);/*stampa il contenuto della lista*/

p_lista inizia(void);/*restituisce la lista vuota*/

int vuota(p_lista pl);/*verifica se la lista e' vuota*/

void ricerca(p_lista pl);/*ricerca una stringa all'interno della lista*/

int menu(void);/*stampa il menu di scelta e restitusce la scelta*/


/*********** main main main ******************/void main(void){ int scelta;

boolean esci=VERO;tipo_elemento e;p_lista l;l=inizia();/*inizializzo la testa della lista a NULL*/do{ scelta = menu(); /*stampo il menu e acquisisco la scelta*/

switch (scelta){

case 1: /*Voglio inserire un elemento nella lista*/printf("Inserisci il nome:");scanf("%s",&e.nome); fflush(stdin);printf("\nInserisci il cognome:");scanf("%s",&e.cognome); fflush(stdin);printf("\nInserisci il numero di telefono:");scanf("%s",&e.n_telefono); fflush(stdin);if(inserisci_dati(&l,e)==ERRORE)

printf("\nErrore!!!!\n");else

printf("\nInserito\n");break;

case 2:/*Voglio togliere il primo elemento dalla lista */if(vuota(l))

printf("\nLa lista e' vuota!");else

cancella_dati(&l);break;

case 3:/*Voglio stampare il contenuto della lista */stampa_rubrica(l);break;

case 4:ricerca(l);break;

case 5:/*Voglio cercare una stringa nella lista */esci=FALSO;break;

default:break;}

}while(esci!=FALSO);}/********** implementazione funzioni **********/p_lista inizia() /* inizializzo la lista */{ /* faccio puntare a NULL*/p_lista temp; /* il primo elemento */temp=NULL;return temp;}/***********************************************************************/int inserisci_dati(p_lista *pl, tipo_elemento e)/*inserisco un elemento*/{p_lista temp;temp= (p_lista) malloc (sizeof(elemento_lista)); /*alloco spazio*/if (temp==NULL) return ERRORE; /*se non riesco ad allocare restituisco ERRORE */temp->dato = e; /* inserisco il dato */temp->next = *pl; /* punto al prossimo elemento */*pl = temp; /* punto all'elemento inserito */return GIUSTO;}/***********************************************/void cancella_dati(p_lista *pl){ p_lista temp;if (vuota(*pl)) return; /* se e' vuota non faccio nulla */temp=*pl; /* entrambe puntano alla lista */*pl= temp->next; /* la lista punta al successivo */free (temp); /* dealloco temp */


}/***********************************************/void stampa_rubrica(p_lista pl){

printf("[");/* stampo una quadra per inizio lista */while(pl!=NULL)/*fino a quando non punta a NULL */

{printf("("); /*metto ogni elemento tra due tonde */printf(" %s ",pl->dato.nome); /* stampo nome */printf("%s ",pl->dato.cognome); /* stampo cognome */printf("%s ",pl->dato.n_telefono);/* stampo telefono*/printf(")"); /*chiudo le tonde */pl=pl->next; /*punto al succesivo */

}printf("]\n");/*stampo una quadra per fine lista */}/***************************************************/int vuota(p_lista pl)/*verifico se e' piena o vuota*/{

if(pl==NULL) return (VERO);else return (FALSO);

}/*********************************************************/void ricerca(p_lista pl) /*cerco una stringa nella lista */{

int trovato=0;/*variabile di controllo dell'esito ricerca*/char ric[20];printf("\nStringa da ricercare:");scanf("%s",&ric); fflush(stdin);

while (pl!=NULL) /*scorrola lista*/{if( 0==strcmp(pl->dato.cognome, ric) || /*controllo tutti*/

0==strcmp(pl->dato.nome, ric) || /*gli elementi */0==strcmp(pl->dato.n_telefono, ric) )/*della lista */

{trovato=1; /*ho trovato una occorrenza*/printf("(");/*stampo una tonda per delimitare l'elemento*/printf(" %s ",pl->dato.nome); /*stampo il nome */printf(" %s ",pl->dato.cognome); /*stampo il cognome */printf(" %s ",pl->dato.n_telefono); /*stampo il telefono*/printf(")");/*stampo la tonda per chiudere l'elemento */

}pl=pl->next;/*punto al prossimo elemento*/

}if(!trovato) printf("\nStringa non trovata.\n");/*se non ho trovato*/

}/***********************************************/int menu(void){int sc;printf("\n------------- RUBRICA --------------\n");printf("-------Scegli una operazione--------\n");printf("1) Inserisci Nuovo elemento\n");printf("2) Cancella Elemento\n");printf("3) Stampa archivio\n");printf("4) Ricerca dato\n");printf("5) Esci\n");printf("------------------------------------\n");printf("Scelta:");scanf("%d",&sc);fflush(stdin);clrscr();return sc;}


Con questo esercizio vediamo come utilizzare i file.Le funzioni di I/O con i file basilari sono: fopen e fclose .L'esercizio è molto semplice, legge il contenuto di un file di tipo testo, e nemostra il contenuto. Il file rappresenta una "Rubrica" contenente i dati: NomeCognome e telefono di alcune persone.

Perché il programma funzioni dobbiamo prima creare un file (di tipo testo!)e salvarlo nella stessa directory dove verrà eseguito il programma con in nomeDATI.DAT.

Il file deve essere strutturato nel modo seguente:

• Ogni persona occupa una riga terminata con un <A CAPO>• Esempio di riga: NOME,COGNOME,TELEFONO<A CAPO>• Ogni persona è formata da tre Campi scritti con tutte

lettere MAISCOLE• I campi sono separati da una ','virgola (senza spazi)

Nell'esempio c'è anche una funzione che permette di ricercare una stringa nellarubrica. La funzione tiene conto di come sono stati organizzati i dati in Record(righe) e dei campi (Nome, Cognome, Telefono) separati da una virgola.

/***********************************************************//* Programma OPERAZIONI BASE CON I FILE *//* e funzione di ricerca di una stringa *//* *//* Il programma apre un file in formato testo che deve *//* chiamarsi DATI.DAT e che deve trovarsi nella directory *//* dove viene eseguito il programma. *//* Viene mostrato il contenuto del file, e viene data la *//* possibilita' di cercare una stringa all'interno del file*//***********************************************************//** ESERCIZIO NUMERO 32 - POLITECNICO DI MILANO sede CR ***//***********************************************************/

#include <stdio.h>#include <stdlib.h>#include <conio.h>#include <string.h>#include <ctype.h>

/******* prototipi delle funzioni ************/void inserisci(void);void leggi_dati(void);void visualizza_dati(void);void cerca_dati(void);void cerca_dato(char *g);

/*********** variabili globali ***************/

char file_dati [2048];/* array che contiene il file DATI.DAT */

int lungo_file_dati;/* numero di char contenuti nel file DATI.DAT */

/***************** m a i n *******************/void main(void){char tasto;

clrscr();leggi_dati();/*leggo il contenuto del file DATI.DAT */

visualizza_dati();/*mostro il contenuto del file DATI.DAT*/

do{cerca_dati();/*chiamo la funzione di ricerca*/

printf("\n Premi un tasto per continuare"" Q per uscire\n");

tasto = toupper(getch());/* il tasto premuto viene reso maiuscolo */

clrscr();}while(tasto!='Q');/*esco se ho premuto'q' oppure 'Q'*/

}

/***********IMPLEMENTAZIONE FUNZIONI*********//****************************************************************//*Perchè il prog. funzioni è necessario che esista il file nella*//* stessa directory dove viene eseguito il programma. *//* Il file deve chiamarsi DATI.DAT e deve essere strutturato nel*//* modo seguente: NOME,COGNOME,TELEFONO<A CAPO> *//****************************************************************/

void leggi_dati(void){FILE *fdati;char ch;int i;

/* DATI.DAT deve essere nella directory attuale */

if((fdati=fopen("DATI.DAT","r")) == NULL)/* apro il file in lettura */

{printf("\n Impossibile eseguire");printf(" il file: %s \n","DATI.DAT");printf("non e' nella directory corrente.\n");fclose(fdati); /* chiudo lo stream == file */

exit(1); /* esco dal programma */

}

i=0; /* scorro il file e determino la dimensione in char*/

while((ch=fgetc(fdati))!=EOF){ file_dati[i]=(char)ch;

i=i+1;}

fclose(fdati); /* chiudo lo stream == file */

lungo_file_dati=i;}

/*************** visualizza DATI*************/void visualizza_dati(void){int i;

for (i=0;i<lungo_file_dati;i++){if (file_dati[i]=='\n')/*se c'è a capo nel file */

{printf("\r\n");}/*la printf manda a capo con \n*/

else {printf("%c", file_dati[i]);}}

}

E S E M P I O

AMEDEO,ROSSI,0372-567700MASSIMILIANO,BIANCHI,0372-567701AMEDEO,VERDI,030-45678GIUSEPPE,NERI,0375-745766MASSIMILIANO,ALTI,0373-763484AMEDEO,BASSI,0372-832727

GIUSEPPE,ALTI,030-765321


/************ cerca DATI ********************/void cerca_dati(void){int scelta;char dato[20];

printf("\n Digitare il DATO da cercare""e premere INVIO: ");

scanf("%s", &dato);fflush(stdin);cerca_dato(dato);

}

/*********************** cerca dato **************************//* I DATI letti nel file sono: NOME,COGNOME,TELEFONO<A CAPO> *//* e la stringa passata viene cercata in tutti i campi *//*************************************************************/void cerca_dato(char *g){char nome[20], cognome[20], telefono[20];/*campi della riga attuale*/

char riga[64];/*riga attuale. Quanti char occupa al massimo?*/

int i,j,k; /*contatori di: file, parola, riga*/

int v; /*conto le virgole per separare i campi*/

int trovato;/*quale campo ho trovato? 0==non trovato*/

/***** inizializzo contatori e variabili *****/

i=0;/* contatore dei char dei dati totali */

j=0;/* contatore dei char dei singoli campi */

k=0;/* contatore dei char della riga attuale */

v=0;/* contatore delle virgole (separatore di campo)*/

trovato=0;

for (i=0;i<lungo_file_dati;i++) /*scandisco i dati*/

{/* memorizzo la riga attuale */

if (file_dati[i]!='\n' && file_dati[i]!=EOF){

riga[k]=file_dati[i];k++;/*incremento la posizione del char nella riga*/

}/* memorizzo i campi della riga */

if (file_dati[i]!=','&& file_dati[i]!='\n'){

switch (v){ /* a seconda delle virgole contate */

case 0: /*riconosco quale campo sto leggendo*/

nome[j]=file_dati[i];break;

case 1:cognome[j]=file_dati[i];break;

case 2:telefono[j]=file_dati[i];break;

default:break;

}j++;/*incremento contatore dei char nel campo*/

}

if (file_dati[i]==','|| file_dati[i]=='\n'){/*chiudo le stringhe dei campi*/

switch (v){case 0: nome[j] ='\0'; break;case 1: cognome[j] ='\0'; break;case 2: telefono[j]='\0'; break;default: break;}

v++;/*incremento numero delle virgole*/

j=0;/*azzero contatore dei char del campo*/

}

if (file_dati[i]=='\n'|| file_dati[i]==EOF){riga[k]='\0';/*chiudo la stringa della riga*/

k=0;/*azzero contatore dei char della riga*/

v=0;/*azzero contatore delle virgole*/

j=0;/*azzero contatore dei char del campo*/

/* se ho letto tutta una riga procedo al confronto */

if(!strcmp(nome,g))/*confronto con la parola cercata*/

{trovato=1;}else if (!strcmp(cognome,g)){trovato=2;}

else if (!strcmp(telefono,g)){trovato=3;}

else{trovato=0;}

if(trovato!=0){ /* stampo la riga completa */

printf("\n\nLa parola %s ", g);printf(" Compare come ");

switch (trovato){

case 1:cprintf("NOME");break;case 2:cprintf("COGNOME");break;case 3:cprintf("TELEFONO");break;

}printf("\nNella riga: ");printf("%s",riga);trovato=0;

}/* chiusura if (trovato!=0) */

}/* chiusura if(file_dati[i]=='\n'|| file_dati[i]==EOF) */

}/* chiusura ciclo for */

}/* chiusura funzione *//*********************************************************************/

Alcune Osservazioni: Nel linguaggio C un file è una sequenza di Byte, ogni dispositivo fisico viene visto come un file. Funzioni per la gestione dei file in ANSI C fopen, fclose getc, putc fgets, fputs fprintf, fscanf fread, fwrite fseek, fsetpos ftell, fgetpos


Utilizzando gli ultimi esempi fatti sull'uso delle Liste e l'esercizioprecedente, realizzare una Rubrica che viene salvata su file percontenere i dati di una persona (Cognome, Nome, Telefono)

/*****************************************************//* RUBRICA SALVATA SU FILE *//*****************************************************//* ESERCIZIO NUMERO 33-POLITECNICO DI MILANO sede CR *//*****************************************************//* usando il programma dovresti notare unparticolare... La lista è di tipo stack... E il file?Usato in questo modo??! Provare a salvare eriutilizzare piu' volte...******************************************************//* Sviluppare da soli: la funzione di Cancellazione diun elemento, la funzione di ordinamento alfabetico deidati ...******************************************************/

#include <stdio.h>#include <conio.h>#include <stdlib.h>#include <string.h>#include <ctype.h>


/******* definizioni tipi di dati ********************/typedef int boolean;typedef struct elem *p_lista;

typedef struct{char nome[20]; /* il tipo persona */char cognome[20]; /* e' composto da */char n_telefono[20]; /* tre stringhe */} persona;

typedef persona tipo_elemento;

typedef struct elem{ /* la lista e' formata da un */persona dato; /* dato di tipo persona e da */p_lista next; /* un puntatore al prossimo */} elemento_lista;/* elemento della lista */

/*********** prototipi funzioni ********************/int inserisci_dati(p_lista *pl,tipo_elemento e);/*aggiunge un elemento alla lista*/void stampa_rubrica(p_lista pl);/*stampa il contenuto della lista*/p_lista inizia(void);/*restituisce la lista vuota*/int vuota(p_lista pl);/*verifica se la lista e' vuota*/void ricerca(p_lista pl);/*ricerca una stringa all'interno della lista*/int menu(void);/*stampa il menu di scelta e restitusce la scelta*/void usa_rubrica(p_lista *pl);/*crea una lista dal file letto*/int apri_file(char n[13]);int chiudi_file(void);int salva_file(p_lista pl);

/**************** variabili globali ***********/char file_dati [2048]; /* array che contiene il file DATI.DAT */

int lungo_file_dati;/*numero di char contenuti nel file DATI.DAT*/

FILE *fp; /* puntatore a file */

/*********************************************//*********** main main main ******************//*********************************************/void main(void){

int scelta;boolean esci=VERO, aperto=FALSO;tipo_elemento e;p_lista l;

l=inizia();/*inizializzo la testa lista a NULL*/clrscr();do{ scelta = menu();

/*stampo il menu e acquisisco la scelta*/switch (scelta){case 0: /* voglio aprire il file */

if (aperto==FALSO){ if (!( apri_file("DATI.DAT") ))

{ printf("File non trovato!");}printf("File Aperto!\n");usa_rubrica(&l);aperto=VERO;

}else {printf("File gia' aperto!");}break;

case 1:/*Voglio inserire un elemento in lista*/printf("Inserisci il nome:");scanf("%s",&e.nome); fflush(stdin);printf("\nInserisci il cognome:");scanf("%s",&e.cognome); fflush(stdin);printf("\nInserisci il numero di tel:");scanf("%s",&e.n_telefono);fflush(stdin);if(inserisci_dati(&l,e)==ERRORE)

printf("\nErrore!!!!\n");else

printf("\nInserito\n");break;

case 2:/*Voglio salvare la rubrica su file */apri_file("DATI.DAT");salva_file(l);chiudi_file();break;

case 3:/*Voglio stampare il contenuto della lista */

stampa_rubrica(l);break;

case 4:/*Voglio cercare una stringa nella lista */

ricerca(l);break;

case 5:/*Voglio uscire dal programma */esci=FALSO;break;

default:break;}

}while(esci!=FALSO);clrscr();printf("\nEsecuzione terminata.\n");}


/********** implementazione funzioni ***************/int apri_file(char n[13]) /* apro il file di testo */{ /* DATI.DAT */char risp;if (!(fp=fopen(n,"r+"))) /* se non riesco ad aprirlo */

{printf("Il file non puo' essere aperto!\n");printf("vuoi crearne uno nuovo S/N? ");scanf("%c", &risp);if (toupper(risp)=='S')

{if (!(fp=fopen(n,"w"))) /* creo un nuovo file */

{printf("Il file non puo' essere aperto!\n");exit(1);

}else

{return 1; /* ok ho creato un nuovo file */}

}}else{return 1; /* ok ho aperto il file preesistente */}

}/*****************************************************/int chiudi_file() /*chiudo il file*/{fclose(fp);return 1;

}/****************************************************/int salva_file(p_lista pl) /* salvo la lista su file */

{/*scorro tutta la lista */

while(pl!=NULL)/*fino a quando non punta a NULL */{fputs(pl->dato.nome, fp); /* salvo nome */fputs(",", fp); /* salvo la virgola*/fputs(pl->dato.cognome, fp); /* salvo cognome */fputs(",", fp); /* salvo la virgola*/fputs(pl->dato.n_telefono, fp);/* salvo telefono */fputs("\n", fp); /* salvo a capo */pl=pl->next; /*punto al succesivo */}

}/*****************************************************/void usa_rubrica(p_lista *pl){ /* metto in file sottoforma di lista */char ch;int i=0, v=0;char temp[20];tipo_elemento e;while((ch=fgetc(fp))!=EOF) /*scorro il file*/

{ if(ch=='\n'){ /*se leggo a capo chiudo la stringa */

/* (1) inserisco in lista *//* (2) azzero tutti i contatori *//* (3) passo al Char successivo */if (v==2){ e.n_telefono[i]='\0';i=0;}

/*(1)*/ inserisci_dati(pl, e);/*(2)*/ v=0;i=0;/*(3)*/ ch=fgetc(fp);

}if(ch==','){

/*se leggo virgola: (1) chiudo la stringa *//*(2) azzero il conattore del campo *//*(3) scorro al carattere successivo *//*(4) incremento il contatore delle virgole*/

/*(1)*/ if (v==0){ e.nome[i]='\0';/*(2)*/i=0;}if (v==1){ e.cognome[i]='\0'; i=0;}

/*(3)*/ ch=fgetc(fp);/*(4)*/ v=v++;

}/*se ho contato 0 virgole e' nome*/if(v==0){ e.nome[i]=(char)ch; i=i+1;}/* se ho contato 1 virgola e' cognome */if(v==1) { e.cognome[i]=(char)ch; i=i+1;}/*se ho contato 2 virgole e' telefono*/if(v==2) { e.n_telefono[i]=(char)ch; i=i+1;}

}chiudi_file(); /* chiudo lo stream == file */

}/*****************************************************/p_lista inizia() /* inizializzo la lista */{ /* faccio puntare a NULL*/p_lista temp; /* il primo elemento */temp=NULL;return temp;

}/****************************************************/int inserisci_dati(p_lista *pl, tipo_elemento e)/*inserisco un elemento*/{ p_lista temp;temp= (p_lista) malloc (sizeof(elemento_lista));

/*alloco spazio*/if (temp==NULL) return ERRORE;

/*se non riesco ad allocare *//* restituisco ERRORE */

temp->dato = e; /* inserisco il dato */temp->next = *pl; /* punto al prossimo elemento */*pl = temp; /* punto all'elemento inserito */return GIUSTO;

}/*****************************************************/void stampa_rubrica(p_lista pl){ printf("[");/* stampo una quadra per inizio lista */

while(pl!=NULL)/*fino a quando non punta a NULL */{printf("("); /*metto ogni elemento tra due tonde */printf(" %s ",pl->dato.nome); /* stampo nome */printf("%s ",pl->dato.cognome);/* stampo cognome */printf("%s ",pl->dato.n_telefono);/* stampo tel */printf(")"); /*chiudo le tonde */pl=pl->next; /*punto al succesivo */}

printf("]\n");/*stampo una quadra per fine lista */}/***************************************************/int vuota(p_lista pl)/*verifico se e' piena o vuota*/{ if(pl==NULL) return (VERO);

else return (FALSO);}/****************************************************/void ricerca(p_lista pl) /*cerco una stringa nella lista */

{int trovato=0; /*var di controllo dell'esito ricerca*/char ric[20];printf("\nStringa da ricercare:");scanf("%s",&ric); fflush(stdin);while (pl!=NULL) /*scorro la lista*/

{if(0==strcmp(pl->dato.cognome, ric) ||

0==strcmp(pl->dato.nome, ric) ||0==strcmp(pl->dato.n_telefono, ric) )

/*controllo tutti gli elementi della lista */{ trovato=1; /*ho trovato una occorrenza*/

printf("("); /*stampo ( per aprire l'elemento*/printf(" %s ",pl->dato.nome);/*stampo nome */printf(" %s ",pl->dato.cognome);/*stmp cogn*/printf(" %s ",pl->dato.n_telefono);/*stmp tel*/printf(")");/*stampo ) per chiudere l'elemento*/

}pl=pl->next;/*punto al prossimo elemento*/}if(!trovato) printf("\nStringa non trovata.\n");

}/****************************************************/int menu(void){ int sc;printf("\n------------- RUBRICA --------------\n");printf("-------Scegli una operazione--------\n");printf("0) Aprire un file Rubrica\n");printf("1) Inserisci Nuovo elemento\n");printf("2) Salvare la Rubrica su File\n");printf("3) Stampa archivio\n");printf("4) Ricerca dato\n");printf("5) Esci\n");printf("------------------------------------\n");printf("Scelta:"); scanf("%d",&sc); fflush(stdin);clrscr();return sc;

}


L'esercizio mostra come rendere modulare un programma C, nell'esempioandremo a scomporre il file dell'esercizio 33 in tre parti:Un File Header LIB-LIS.H la sua implementazione LIB-LIS.C ed ilprogramma della Rubrica su file ESER-34.C

/******************************************************************//* RUBRICA SALVATA SU FILE - CON MODULI DI PROGRAMMA *//******************************************************************//******************************************************************//****** ESERCIZIO NUMERO 34 - POLITECNICO DI MILANO sede CR ******//******************************************************************//******************************************************************/#include <stdio.h>#include <conio.h>#include <stdlib.h>#include <string.h>#include <ctype.h>

/* per includere i moduli liste.c e liste.h bisogna dare *//* il giusto percorso completo nel formato MSDOS 8.3 *//* oppure bisogna mettere i due file nella directory *//* predefinita per le librerie, visibile nel menu Options*//* sottomenu directories... */

#include <c:\docume~1\dispen~1\eserci~1\lib-lis.h>#include <c:\docume~1\dispen~1\eserci~1\lib-lis.c>

/*********** definizioni tipi di dati *********************/typedef int boolean;

/******************** prototipi funzioni ********************/int menu(void);/*stampa il menu di scelta e rest. la scelta*/void usa_rubrica(p_lista *pl);/*crea una lista dal file letto*/int apri_file(char n[13]);int chiudi_file(void);int salva_file(p_lista pl);

LIB_LIS.H LIB-LIS.C/*****************************************************//*RUBRICA SALVATA SU FILE - CON MODULI DI PROGRAMMA *//*****************************************************//*****************************************************//*ESERCIZIO NUMERO 34 POLITECNICO DI MILANO sede CR*//*****************************************************//*questo file unitamente a LIB-LIS.C viene usato conl'esercizio 34******************************************************/#ifndef LISTE_H#define LISTE_Htypedef struct elem *p_lista;typedef struct {char nome[20]; /* il tipo persona */char cognome[20]; /* e' composto da */char n_telefono[20]; /* tre stringhe */} persona;typedef persona tipo_elemento;typedef struct elem {/* la lista e' formata da un */persona dato; /* dato di tipo persona e da */p_lista next; /* un puntatore al prossimo */} elemento_lista;/* elemento della lista *//*********** prototipi funzioni ********************/p_lista inizia(void);int inserisci_dati(p_lista *pl,tipo_elemento e);void stampa_rubrica(p_lista pl);int vuota(p_lista pl);void ricerca(p_lista pl);#endif

/*****************************************************//*RUBRICA SALVATA SU FILE - CON MODULI DI PROGRAMMA *//*****************************************************//*****************************************************//*ESERCIZIO NUMERO 34 POLITECNICO DI MILANO sede CR *//*****************************************************//*questo file unitamente a LIB-LIs.H viene usato conl'esercizio 34******************************************************//* per includere il modulo liste.h bisogna dare *//* il giusto percorso completo nel formato MSDOS 8.3 *//* oppure bisogna mettere i due file nella directory *//* predefinita per le librerie, visibile nel menu *//* Options- sottomenu directories... */#include "c:\...\liste.h"


/****RIPORTARE LE IMPLEMENTAZIONI DELLE FUNZIONI*****/p_lista inizia(){...}int inserisci_dati(p_lista *pl, tipo_elemento e) {...}void stampa_rubrica(p_lista pl) {...}int vuota(p_lista pl) {...}void ricerca(p_lista pl) {...}

completare con il giusto percorso

Esempi di percorsi. Da sostituire opportunamente con quelli esistenti sul vostro PC


ALLEGATI: 1) pagina web della Community Borland sul Turbo C++ version 1.01 2) programma del corso


Welcome gianluca attolini

www.borland.com

AppServer C++ CORBA Delphi & Kylix InterBase Java Linux TeamSource DSP

Borland Dev eloper Network Home >C++> Tools

Antique Software: Turbo C++ version 1.01 - by David Intersimone

Abstract:Turbo C++ version 1 was our first compiler that supported the C++ language. The C++ compiler conformed to AT&T's 2.0 specification for the C++ language.

In the Museum: Turbo C++ version 1.01 Ship date: 28-February-1991

Turbo C++ version 1 was our first compiler that supported the C++ language. The C++ compiler conformed to AT&T's 2.0 specification for the C++ language. The development environment and command line tools ran under DOS. Turbo C++ v1 came in two forms: Turbo C++ and Turbo C++ Professional. The Professional version included Turbo Assembler, Turbo Debugger, and Turbo Profile. Version 1.01 was a maintenance release of the original Turbo C++ version 1 software.

How to Download and Install Turbo C++ version 1.01

Click on Turbo C++ version 1.01 to download the software (2.7mb). When you are finished downloading the software, use your favorite zip utility (like PKZIP or WinZip) to decompress the zip file to a folder on your hard drive. Turbo C++ version 1.01 shipped on 4 floppy disks. The zip file contains all the files that were on the 4 floppy disk images.

To install the software, unzip the files onto your hard drive. Run the Install.exe program and follow the installation instructions to install the software.

These historical files are provided to the Borland community free of charge. They may be downloaded and used "as is" for personal use only. No developer support is provided. Each individual product contains copyright notices that are still in force. These files may not be made available via the Internet or any hard copy media (e.g. diskette, CDROM). We make no claims about Year 2000 compatibility for our antique software. If you have technical questions, you should ask the questions on the threaded conversions for this antique software or ask our Internet newsgroups (there may be someone who remembers these old tools).

Turbo C++ Advertisements

Below is a bitmap of the Turbo C++ Professional box. Click on the bitmap of the Turbo C++ Professional box to display a larger image of the Turbo C++ advertisement. Click on the comparison chart bitmap to display a larger image of the ad that compared Turbo C++ to Microsoft C Compiler version 6.


Turbo C++ Version 1.01 Readme File

The following is the Readme file that came with Turbo C++ version 1.01. Please notice that any mention of support, references to phone numbers or addresses are here for historical purposes. Since this is antique software, there is no developer support for this product. If you have questions, you should ask them on our Internet newsgroups. You might find an old timer who still remembers using this version of Turbo C++. Welcome to Turbo C ++

---------------------

This README file contains important information about Turbo C++.For the latest information about Turbo C++, the accompanyingprograms, and the manuals, read this file in its entirety.

TABLE OF CONTENTS-----------------1. How to Get Help2. Installation3. Features4. Important Information5. Testing Your Expanded Memory6. Corrections to the Documents7. TCTOUR


1. HOW TO GET HELP-------------------

If you have any problems, please read this file, the HELPME!.DOCfile, and the Turbo C++ manuals first. If you still have a questionand need assistance, help is available from the following sources:

1. Type GO BPROGB on the CompuServe bulletin board system forinstant access to the Borland forums with their libraries oftechnical information and answers to common questions.

If you are not a member of CompuServe, see the enclosed specialoffer, and write for full details on how to receive a freeIntroPak containing a $15 credit toward your first month's on-line charges.

2. Check with your local software dealer or users' group.

3. Write to us at the following address:

Borland InternationalTurbo C Technical Support1800 Green Hills RoadP.O. Box 660001Scotts Valley, CA 95066-0001

Please remember to include your serial number or we will beunable to process your letter.

4. If you have an urgent problem that cannot wait and you have sentin the license agreement that came with the package, you maycall the Borland Technical Support Department at (408) 438-5300.Please have the following information ready before calling:

a. Product name and serial number on your original distributiondisk. Please have your serial number ready or we will beunable to process your call.

b. Product version number. The version number for Turbo C++can be displayed by pressing Alt-Space/A.

c. Computer brand, model, and the brands and model numbers ofany additional hardware.

d. Operating system and version number. (The version number canbe determined by typing VER at the MSDOS prompt.)

e. Contents of your AUTOEXEC.BAT file.

f. Contents of your CONFIG.SYS file.

2. INSTALLATION---------------

You MUST use the INSTALL program to install Turbo C++.The files on the distribution disks are all archived andhave to be properly assembled. You cannot do this byhand!

To start the installation, change your current drive to the onethat has the install program on it and type INSTALL. You willbe given instructions in a box at the bottom of the screen foreach prompt. For example, if you will be installing from driveA:, type:


A:INSTALL

You should read the rest of this README file to get furtherinformation about this release before you do the installation.

3. FEATURES-----------

- C++! Turbo C++ offers you the full power of C++ programming,implementing the entire C++ 2.0 language as defined by the AT&Tspecification. To help you get started, we're also includingC++ class libraries.

- ANSI C! A 100% implementation of the ANSI C standard.

- Borland's Programmer's Platform. The Programmer's Platform belongsto the next generation of user interfaces; it goes beyond the oldintegrated environment (IDE) to provide access to the full range ofprograms and tools on your computer. It includes:

-- mouse support

-- multiple overlapping windows

-- a multi-file editor

-- user-configurable menu entries to run other programswithout leaving Turbo C++

- VROOMM (overlay manager): VROOMM lets you overlay your codewithout complexity. You select the code segments foroverlaying; VROOMM takes care of the rest, doing the workneeded to fit your code into 640K.

- An online tour of the Programmer's Platform.

- Online hypertext help, with copy-and-paste program examplesfor practically every function.

- Many indispensable library functions, including heap checkingfunctions and a complete set of complex and BCD math functions.

- Note: The list of files is now contained in a separate filecalled FILELIST.DOC, which will appear in the targetdirectory you specify during installation.

4. IMPORTANT INFORMATION------------------------

C++ STREAM I/O

The standard libraries have all the functions needed forthe IOSTREAM libraries defined in the AT&T 2.0 spec. Ifyou have code that uses the STREAM libraries from the 1.0spec, you must link with the appropriate OLDSTRMx.LIBfile, where 'x' is replaced by the letter for theappropriate memory model:

oldstrms.lib -- small modeloldstrmc.lib -- compact modeloldstrmm.lib -- medium modeloldstrml.lib -- large modeloldstrmh.lib -- huge model

EXAMPLE PROGRAMS


When you are running any example programs that come with.PRJ files, if you didn't use the standard directories whenyou installed Turbo C++ you will have to change the .PRJ fileto reflect your actual directory setup. Do this from inside theTurbo C++ IDE with Alt-O|D.

Included in this release is source code to the GREP2MSG andTASM2MSG filter programs (in EXAMPLES), which give an example ofhow to write your own custom filter programs to use with theTransfer Menu.

COMPILER AVAILABLE MEMORY

To achieve better capacity and flexibility, Turbo C++ uses VROOMM,which means that the reported "available memory" number (both withthe standalone compiler and in the integrated development environment)reflects the actual amount of RAM available to VROOMM for the entirecompiler. What this means is that even when the reported availablememory approaches or is equal to zero, much larger files can stillbe compiled at the expense of compilation speed. In the Programmer'sPlatform, when memory available for VROOMM reaches zero, the compilebox will show "Swapping ...." as the amount of available memory; thestandalone compiler will merely report "Available memory 0" in this case.

OVERLAYS AND ASSEMBLY LANGUAGE

Just as all "C" modules to be linked into an overlaid executable mustbe compiled with the -Y compiler switch, all assembly language modulesneed to be assembled with the -O TASM switch. If an assembly file isthe result of a TCC compilation, TCC automatically passes -O to theassembler whenever -Y is used. Modules written entirely in assemblylanguage must be assembled with the -O switch (using TASM version 2.0or newer) if they are to be linked into an overlaid executable. Failureto follow these rules may result in the overlaid program failingunpredictably when run.

LINKING C++ WITH C

Linking C++ modules with C modules requires the use of a linkagespecification. Prototypes for C functions within C++ modules mustbe in one of the following forms:extern "C" declarationextern "C" { declarations }

For example, if a C module contains functions "char *SCopy(char*, char*);"and "void ClearScreen(void)", they must be declared in a C++ module inone of the following ways:extern "C" char *SCopy(char*, char*);extern "C" void ClearScreen(void);

orextern "C" {

char *SCopy(char*, char*)void ClearScreen(void);

}Failure to do so will result in "Undefined symbol" errors during link.For further examples, see the standard header files. There's also a morein-depth explanation in the Programmer's Guide.

IMPORTANT NOTES

- If you use inline assembler in C++, TASM 1.0 may not be ableto assemble the generated code. If you run into this problem,you will need to update to version 2.0 of TASM.

- Functions that return structures now take a hiddenparameter that contains the address where the returnedstructure is to be placed. If you are writing assembler


code to link with C code you must be sure to allow forthis extra parameter.

- When debugging a mouse application the Options|Debugging|DisplaySwapping option should be set to "Always" for best results.

- When running under DOS versions 2.0 or 2.1, you should not renameTC, TCC, or TLINK. They need to know their names to be able toload their overlays.

- TEMC will not allow a macro to contain multiple commands that returnexit codes.

- If you have selected Save Desktop in the Turbo C++ Programmer'sPlatform, everything that you put into the clipboard will be savedas part of the desktop. After several sessions this may makestarting the Programmer's Platform take longer. If this happensto you (you will see the message "Loading Desktop" while theProgrammer's Platform is loading), you can speed things up bydeleting unneeded things from the clipboard. Just select Alt-E|Sto show the clipboard, and start deleting.

- In some rather unusual situations when stepping througha program in the IDE you may get a message saying "Linetoo complex". This means that the Programmer's Platformcan't step past the line it is currently on. To continuestepping, you should move the cursor to the next line inthe program and press F4 (Go to Cursor). If the line wherethis message occurs is the last line in a function, usethe Call Stack (Ctrl-F3 or Alt-D|C) to see where the functionwas called from, select the calling function (by moving thehighlight to it and pressing Enter), move the cursor to thenext line, and press F4.

- If you change your keyboard settings using the Editor Commandschoice in TCINST, you may lose some key assignments. To avoidthis, use the following procedure:

1) don't save the modifications to the EXE; instead invokeTCINST with the name of your configuration file, by defaultTCCONFIG.TC.

2) create a file containing the following line:Tab: SmartTab;

and invoke TEMC with the name of that file and the nameof your configuration file as arguments.

As an example, you can follow these exact steps:CD TCBINTCINST TCCONFIG.TC<make changes, save, and exit TCINST>COPY CON TEMP.TEMTab: SmartTab;<Ctrl-Z>TEMC TEMP.TEM TCCONFIG.TC

- If a directory contains only one project file, invoking Turbo C++ withoutany parameters will open that project. If this behavior is notdesired, a second 'dummy' project file must be placed in thatdirectory or the current project file must be removed.

- Using the 'registerbgidriver' function may result in the followinglink error: "Segment _TEXT exceeds 64K". In order to avoid this,it is recommended that the 'registerfarbgidriver' function be usedinstead. Please see UTIL.DOC for a more complete discussion of thissubject.

5. Testing Your Expanded Memory: EMSTEST.COM--------------------------------------------


Included with Turbo C++ is a program to test your Expanded Memoryhardware and software. If you have problems using Turbo C++ withyour EMS, type EMSTEST at the DOS prompt and follow the instructions.

6. Corrections to the Documents--------------------------------

There are no corrections needed currently.

7. TCTOUR---------

TCTOUR is a visual introduction to the Programmer's Platform.Since the Programmer's Platform is Borland's newest interface,taking the tour is time well spent even if you are already familiarwith other Borland products.

To start the tour, type "TCTOUR" from the DOS prompt.

- TCTOUR remembers what lessons a user has completed, and ifyou quit a lesson before completing it, what screen # you last saw.This information is stored in a .USR file, and can be recalled bystarting TCTOUR again and typing your user name at the prompt justafter the color rainbow.

Lessons that a user has completed should show up without shadingon the main TCTOUR menu. Only new users (no .USR file) get theexcursion through "Using Tour."

- The Navigator can be pulled up within any lesson file and within"Using TCTOUR", but nowhere else. It is pulled up by pressing theControl key, which allows you to move forward, backward, to thebeginning of a lesson, to the end of a lesson, to the lesson summary,to the main menu, to get a reminder, to quit. Ctrl-B (backwards) isdisabled when you are on the first slide of a lesson.

- Hints (or Reminders) pop up in any lesson files and in "Using TCTOUR".They pop up if:

1) you wait 30 - 60 seconds before doing any action2) you press Ctrl-R3) you make an incorrect action

Add or View comments on this article

Article ID: 21751 Publish Date: April 14, 2000 Last Modified: June 13, 2001 Made in Borland® Copyright© 1994-2002 Borland Software Corporation. All rights reserved. Legal Notices, Privacy Policy


Informatica 1 codice 060012 - 7.5 crediti

Proff. C. Bolchini, G. Buonanno, Breveglieri, V. Caglioti, C. Ghezzi, G. Gini, D. Mandrioli, L. Mezzalira, R. Morpurgo, M. Negri

Allievi Corsi di Laurea in Ingegneria dell'Automazione, Elettronica, Informatica, delle Telecomunicazioni Obiettivi Presentare allo studente gli aspetti fondamentali dell'informatica (algoritmi, programmi, struttura di massima dei calcolatori e dei sistemi informatici). Impartire nozioni basilari sulla programmazione dei calcolatori (linguaggi di programmazione, tecniche di astrazione, tipi di dati fondamentali e strutture di controllo, sottoprogrammi e ricorsione, cenni sulle strutture dati dinamiche, cenni sulla programmazione modulare) approfondendone in egual misura gli aspetti concettuali e sperimentali. Distribuzione indicativa dell'attività didattica Sede Leonardo: 32 ore di lezione, 32 ore di esercitazione, 20 ore di laboratorio Sede Cremona: 32 ore di lezione, 24 ore di esercitazione, 40 ore di laboratorio Programma delle lezioni e delle esercitazioni 1. Concetti introduttivi: Algoritmi, programmi e linguaggi - Struttura di massima di un calcolatore e di un sistema informatico (hardware, software, Sistema Operativo, reti) - Catena di programmazione. 2. Logica e codifica binaria dell'informazione (logica proposizionale, operatori logici AND, OR, NOT, leggi di De Morgan, rappresentazione dei numeri interi in forma binaria ed esadecimale, codifica dei numeri reali, codifica dei caratteri). 3. Aspetti fondamentali della programmazione (con riferimento al linguaggio C): il linguaggio di programmazione e le esigenze di astrazione, la sintassi dei linguaggi, struttura di un programma monomodulo, astrazione sui dati (concetto di tipo e tipi base del linguaggio, operatori e compatibilità, i costruttori di tipo array, struct, puntatori), astrazione sul controllo dell'esecuzione (strutture di controllo condizionali, di selezione, iterative). 4. Sottoprogrammi e ricorsione: programmazione in piccolo e in grande, sottoprogrammi come astrazione sul controllo a livello di unità, passaggio dei parametri, dati locali, regole di visibilità, sviluppo top down per raffinamento, ricorsione, record di attivazione, pila, cenni ai moduli. 5. Strutture dati dinamiche, liste collegate a puntatori. 6. Strutture dati persistenti: i file (concetti, operazioni, organizzazione logica), integrazione tra strutture dati in memoria centrale e su file. Attività di laboratorio L'attività del laboratorio ha lo scopo di rendere familiare allo studente sia l'utilizzo pratico del calcolatore sia i metodi e le tecniche utilizzate nella programmazione dei calcolatori. Ogni studente svolgerà 20 ore di laboratorio suddivise in 2 sessioni introduttive di quattro ore ciascuna e in 6 sessioni di lavoro di due ore ciascuna. Gli studenti di ogni sezione saranno divisi in quattro classi che svolgono lo stesso lavoro in aule o orari diversi, con uno studente per terminale nelle sessioni di lavoro. La valutazione dallo studente viene effettuata sul complesso del lavoro svolto e deriva dalla frequente interazione informale docente/discente. Ogni sessione di laboratorio costituisce pertanto un momento congiunto di didattica e di valutazione. La frequenza al laboratorio assume quindi una particolare importanza. Bibliografia consigliata Testo di riferimento: Ceri, Mandrioli, Sbattella: Informatica: programmazione, McGraw-Hill, 2000. Altro materiale didattico Testi aggiuntivi e altro materiale relativo alle lezioni e per approfondimenti potrà essere reso disponibile dai docenti durante lo svolgimento del corso. Prerequisiti Nozioni di base sulle caratteristiche e l'uso del personal computer: componenti della macchina, interfaccia utente Windows 95 o Windows NT, Internet (uso del browser), posta elettronica, applicativi Office (Word+Excel base). Modalità di svolgimento delle prove di verifica L'esame assegna 32 punti che corrispondono al voto massimo di 30 e lode, suddividendoli tra due prove in itinere e il laboratorio. La valutazione del laboratorio avviene durante lo svolgimento dell'attività ed è considerata sufficiente se assegna un punteggio compreso tra i 2 e gli 8 punti; non è previsto il recupero del laboratorio, pertanto in caso di valutazione insufficiente lo studente dovrà ripetere il corso nell'anno accademico successivo e le eventuali prove in itinere sostenute saranno annullate. Le due prove in itinere constano di una verifica scritta con eventuale discussione orale su richiesta del docente e ad ognuna di esse si assegna un massimo di 12 punti. Le singole prove in itinere non sono superate e devono quindi essere recuperate se valutate rispettivamente meno di 5 punti (la prima) e meno di 6 punti (la seconda). Inoltre le prove superate sono ritenute complessivamente sufficienti se la somma dei due punteggi raggiunge i 14 punti e il punteggio totale, incluso laboratorio, raggiunge i 18 punti; in caso contrario lo studente deve ripetere almeno una delle prove per ottenere il risultato richiesto. Alle prove di recupero sono ammessi tutti gli studenti che non hanno superato l'esame oppure che vogliono migliorare il proprio voto. Nel primo recupero è possibile ripetere una delle due prove in itinere o entrambe. Ai recuperi di settembre è invece ammesso solo il recupero completo di entrambe le prove. Il voto complessivo dell'esame è ottenuto, indicativamente, sommando i punteggi di tutte le prove effettuate e del laboratorio. Le date delle singole prove saranno comunicate con un congruo anticipo in aula e mediante affissione di un avviso alla bacheca del Dipartimento di Elettronica e Informazione a Milano e presso la sede di Cremona. In ogni caso le modalità d'esame saranno coerenti con quanto deliberato a tale proposito dalla V Facoltà.