Scarica esempi linguaggio c- programmazione e più Appunti in PDF di Programmazione C solo su Docsity!
Alcuni esercizi di programmazione in linguaggio C
- Alcuni esercizi di programmazione in linguaggio C Indice degli argomenti
- Indice degli argomenti
- Premessa
- Dati strutturati
- Strutture di controllo
- Uso di if condizionale
- Ciclo for per gestire una matrice
- Cicli equivalenti
- Vettori e puntatori
- Ricerca di una stringa in un vettore di stringhe (vers. 1)
- Ricerca di una stringa in un vettore di stringhe (vers. 2 della sola funzione)
- Strutture pila e coda (statiche) realizzate con un vettore
- Passaggio di parametri al main
- Visibilità e funzioni
- Visibilità delle variabili in blocchi annidati............................................................................
- Potenza..................................................................................................................................
- Calcolo delle radici di un’equazione di 2° grado
- Scambio dei valori di due variabili (ver. 1)
- Scambio dei valori di due variabili (ver. 2)
- Dati strutturati
- Ricorsività
- Massimo Comun Divisore
- Media ricorsiva
- Polinomio
- Algoritmi vari
- Ricerca binaria
- Operazioni diverse su strighe di caratteri
- Strutture dinamiche
- Liste
- Pile e code (strutturate come lista)
- Alberi
- Input Output
- Esempio di scrittura, lettura e aggiornamento di un file
Premessa
Quanto avete sotto gli occhi non è un manuale di linguaggio C, non serve per imparare a
programmare, non è nemmeno un eserciziario completo ma è semplicemente un insieme scelto e
annotato di esempi tratti dalle esercitazioni o proposti nei temi d’esame del corso di Informatica A
di Ingegneria Gestionale. Si sono cercati di evidenziare i punti che presentano le maggiori difficoltà
e sono causa di errori ricorrenti per gli studenti, le cui osservazioni e domande, anche se talvolta a
loro insaputa, hanno consentito la raccolta. Si ringraziano anticipatamente quanti vorranno
contribuire a migliorarla.
Gli esercizi, suddivisi in base all’argomento, sono riportati in forma completa, ad esempio nel caso
di una funzione viene inclusa anche la codifica del modulo che la richiama. Così se da un lato non si
evita una certa ripetitività e monotonia, dall’altro si facilita l’estrazione del singolo esercizio e
quindi la modifica e il test. La suddivisione è in parte arbitraria in quanto lo stesso esempio
potrebbe spesso trovarsi in capitoli diversi. Alle soluzioni compatte ed eleganti sono state preferite
quelle più facilmente leggibili.
Per la codifica si è usato il formato di carattere courier new, siete invitati ad usarla come punto
di partenza per le vostre variazioni e sperimentazioni: ogni linguaggio, naturale o artificiale che sia,
si apprende infatti soprattutto con la pratica. È opinione di chi scrive che lo studio di un linguaggio
di programmazione (nella fattispecie il C) abbia anche un valore formativo nell’apprendimento di
un metodo per affrontare i problemi che si presentano nella realtà lavorativa.
Concludendo questo lavoro ha un duplice scopo: di fornire una serie di programmi completi come
input per esperimenti di laboratorio e di offrire alla vista un insieme di codifiche che sono più facili
da leggersi da un foglio (o dallo schermo di un computer) che dalla lavagna durante le esercitazioni.
Dati strutturati
Uso di typedef
Il modo, a mio parere più chiaro, per definire un tipo di dato fornito di struttura è quello di usare le
parole chiave typedef struct. Il programma che segue definisce (nel file .h) alcuni tipi di
dati e alcune funzioni, che si possono pensare come modelli informatici di note entità ed operatori
della geometria elementare del piano. Si spera che la rappresentazione di un mondo geometrico che
tutti conoscono aiuti ad eliminare anche nella sua corrispondenza informatica ogni residua
ambiguità.
Per illustrare le due possibili modalità di chiamata, le funzioni che richiedono in input un triangolo
sono state implementate in modo differente e cioè ad AreaT viene passato come parametro il
“puntatore” alla variabile “triangolo”, a Baricentro invece, viene passato il valore. Perché le
funzioni possano ritornare al chiamante non solo un numero ma anche un punto bisogna che questo
sia stato definito come un tipo dato.
Chi legge è invitato ad accrescere questa “libreria” di funzioni a suo piacimento, si consiglia per
esempio di programmare il calcolo del punto di intersezione fra due rette che presenta qualche
interesse anche dal punto di vista informatico a causa dei diversi casi particolari che si possono
presentare.
Il file .c, esempio di come si può costruire un programma di test della codifica di una funzione,
merita qualche commento, in quanto ha una struttura che ritroveremo in seguito. Esso è composto
da un ciclo while che si interrompe quando viene fornita la risposta ‘0’, le altre risposte fanno
prendere al processo diversi rami alternativi (comando switch case), ciascuno dei quali
corrisponde all’esecuzione di una diversa funzione.
punto_b.y = (tri.p1.y + tri.p2.y + tri.p3.y) / 3.0; return (punto_b); } /* stampa delle coordinate di un punto */ void StampaP (punto P) { if ((P.x != NULL) && (P.y != NULL)) printf("\n x: %5.2f y: %5.2f\n", P.x, P.y); else printf("\n punto invalido o inesistente\n"); }
file: piano.c
#include <stdio.h> #include "piano.h" void main() { punto punto1, punto2, punto3, punto4; segmento segmento1; triangolo triangolo1; boolean allineamento; int scelta = - 1; while(scelta != 0) { printf("\n 0: per finire, 1: allineamento, 2: punto medio,\n 3: area triangolo, 4: baricentro\n"); scanf("%d", &scelta); switch(scelta) { case 1: printf("\nAscissa e ordinata del primo punto: "); scanf("%f %f", &punto1.x, &punto1.y); printf("\nAscissa e ordinata del secondo punto: "); scanf("%f %f", &punto2.x, &punto2.y); printf("\nAscissa e ordinata del terzo punto: "); scanf("%f %f", &punto3.x, &punto3.y); allineamento = Ver_All(punto1, punto2, punto3); if(allineamento == vero) printf("\ni punti sono allineati"); else printf("\ni punti non sono allineati"); break; case 2: printf("\nAscissa e ordinata del primo punto: "); scanf("%f %f", &segmento1.p1.x, &segmento1.p1.y); printf("\nAscissa e ordinata del secondo punto: "); scanf("%f %f", &segmento1.p2.x, &segmento1.p2.y); punto4 = PuntoM(segmento1); StampaP(punto4); break; case 3: printf("\nAscissa e ordinata del primo punto: "); scanf("%f %f", &triangolo1.p1.x, &triangolo1.p1.y); printf("\nAscissa e ordinata del secondo punto: "); scanf("%f %f", &triangolo1.p2.x, &triangolo1.p2.y); printf("\nAscissa e ordinata del terzo punto: "); scanf("%f %f", &triangolo1.p3.x, &triangolo1.p3.y);
printf("\n area del triangolo: %5.2f", AreaT(&triangolo1)); break; case 4: printf("\nAscissa e ordinata del primo punto: "); scanf("%f %f", &triangolo1.p1.x, &triangolo1.p1.y); printf("\nAscissa e ordinata del secondo punto: "); scanf("%f %f", &triangolo1.p2.x, &triangolo1.p2.y); printf("\nAscissa e ordinata del terzo punto: "); scanf("%f %f", &triangolo1.p3.x, &triangolo1.p3.y); punto4 = Baricentro(triangolo1); StampaP(punto4); break; } } }
Strutture di controllo
Uso di if condizionale
Il programma usoif illustra la condizione if, in esso l’istruzione scanf ritorna nella variabile
cc il numero di dati letti correttamente, basta perciò inserire un valore che non sia intero per uscire
dal ciclo e terminare così il ciclo di esecuzione del programma.
file: usoif.c
/* ordinamento di tre numeri (esempio di if) */ #include<stdio.h> void main() { int a, b, c, cc; printf("\nfornisci i tre interi da ordinare): "); cc = scanf("%d %d %d", &a, &b, &c); while(cc == 3) { if((a <= b) && (b <= c)) printf("\n %d %d %d", a, b, c); else if((a <= c) && (c <= b)) printf("\n %d %d %d", a, c, b); else if((b <= a) && (a <= c)) printf("\n %d %d %d", b, a, c); else if((b <= c) && (c <= a)) printf("\n %d %d %d", b, c, a); else if((c <= a) && (a <= b)) printf("\n %d %d %d", c, a, b); else printf("\n %d %d %d", c, b, a); printf("\nfornisci i tre interi da ordinare): "); cc = scanf("%d %d %d", &a, &b, &c); } }
Cicli equivalenti
Si possono costruire strutture logiche equivalenti con cicli for, while e do-while, la scelta
dipende dalla convenienza e dal gusto personale. Nell’esempio che segue viene riscritto in tre modi
l’algoritmo di calcolo della potenza di un numero (con esponente intero).
(prima di ogni insieme di istruzioni dovranno trovarsi le seguenti dichiarazioni e istruzioni:
float base, ris; int espon; if(espon < 0) { espon = - espon; base = 1.0 / base;
/* (1) ciclo for / for(ris = 1.0; espon > 0; espon--) ris = ris * base; / fine ciclo for / / (2) ciclo while / ris = 1.0; while(espon > 0) { ris = ris * base; espon--; } / fine ciclo while / / (3) ciclo do while / ris = 1.0; if (espon) { do { ris = ris * base; espon--; } while(espon > 0); } / fine ciclo do while */
Vettori e puntatori
Un puntatore è un insieme di celle di memoria usate per contenere l’indirizzo di un dato di un
particolare tipo, la sua definizione deve fare riferimento anche al tipo di dato.
Questo è un punto molto importante da cui deriva la possibilità di un’ algebra dei puntatori.
Allora (vedi il programma che segue):
char *p2; definisce p2 come indirizzo di una variabile carattere,
char *p1 = “ABC”; definisce p1 come indirizzo di una variabile carattere che viene
inizializzato con l’indirizzo della stringa di caratteri “ABC”.
#include <stdio.h> void main() { char *p1 = "ABC"; char *p2;
p2 = p1; p1 = 'X'; printf("p2: %s \n", p2); / viene stampata la stringa XBC */ }
Ricerca di una stringa in un vettore di stringhe (vers. 1)
Il programma contiene il vettore di puntatori char *nomi[ ] inizializzato con indirizzi di
stringhe già definite, l’ultimo indirizzo contiene NULL per segnalare la fine del vettore degli
indirizzi. La funzione find_name ricerca una stringa passata fra quelle puntate.
Nella seconda versione la funzione è identica ma ha una forma diversa, invece di eseguire la somma
direttamente sul puntatore, viene utilizzato un indice.
file: ricerca.c
** Programma che ricerca la prima occorrenza di una specificata ** stringa di caratteri in un array di stringhe. versione 1 *****************************************************************/ #include <stdio.h> #include <stdlib.h> #include <string.h> #define SIZE 20 char * find_name(char **, char *); int main(void) { char nomi[ ] = { "Priamo", "Achille", "Ettore", "Andromaca", NULL }; / nomi: doppio puntatore a carattere ** ** nomi[ ]: vettore di puntatori a carattere ** ** nomi[0][0]: contiene 'P' ** ** nomi[1][1]: contiene 'c' ** ** nomi[3][0]: contiene 'A' ** ** (ogni stringa ha lunghezza diversa) */ char nuovo_nome[SIZE], nome_punt; printf("inserisci il nome da cercare.\n"); scanf("%s", nuovo_nome); nome_punt = find_name(nomi, nuovo_nome); printf("nome: %s\n",nome_punt); printf("nome %s%strovato\n", nuovo_nome, (nome_punt == NULL)? " non " : " "); return (0); } / End of main */ /**************************************************************** ** Funzione find_name. Questa funzione ricerca in un array di ** nomi un dato nome. ** Ritorna il puntatore al nome trovato o NULL se non e' stato ** trovato. ** array e' il puntatore al vettore di puntatori ai nomi ** esistenti ** stringa e' il puntatore alla stringa fornita (nuovo nome) ***************************************************************/
int Info[MAX_SZ]; int numelem; int first; } Coda; int InserInPila(Pila *p, int elm) { int ret = NULL; if (p->numelem < MAX_SZ) { p->Info[p->numelem++] = elm; ret = 1; } return (ret); } int TogliDaPila(Pila *p) { int ret = NULL; if (p->numelem > 0) ret = p->Info[--(p->numelem)]; return (ret); } void StampaPila(Pila *p) { int i; printf("Pila: "); for(i = 0; i < p->numelem; i++) printf("%4d", p->Info[i]); printf("\n"); } int InserInCoda(Coda *c, int elm) { int i, ret = NULL; if(c->numelem < MAX_SZ) { if(c->numelem == 0) c->first = 0; i = (c->first + c->numelem++) % MAX_SZ; c->Info[i] = elm; ret = 1; } return (ret); } int TogliDaCoda(Coda *c) { int reso = NULL; if(c->numelem != 0) { reso = c->Info[c->first]; c->numelem--; c->first = (c->first + 1) % MAX_SZ; } return (reso); } void StampaCoda(Coda *c) { int i,k; printf("Coda: "); for(i = 0;i < c->numelem; i++) { k = (c->first + i) % MAX_SZ; printf("%4d", c->Info[k]); } printf("\n"); } void main() { Pila pila1;
Coda coda1; pila1.numelem = 0; coda1.numelem = 0; InserInPila(&pila1,1); StampaPila(&pila1); InserInPila(&pila1,2); StampaPila(&pila1); InserInPila(&pila1,3); StampaPila(&pila1); printf("%4d\n",TogliDaPila(&pila1)); StampaPila(&pila1); printf("\n"); InserInCoda(&coda1,10); StampaCoda(&coda1); InserInCoda(&coda1,11); StampaCoda(&coda1); InserInCoda(&coda1,12); StampaCoda(&coda1); printf("\n"); printf("%4d\n",TogliDaCoda(&coda1)); printf("\n"); StampaCoda(&coda1); printf("\n"); printf("%4d\n",TogliDaCoda(&coda1)); printf("\n"); StampaCoda(&coda1); printf("\n"); InserInCoda(&coda1,20); InserInCoda(&coda1,21); InserInCoda(&coda1,22); InserInCoda(&coda1,23); StampaCoda(&coda1); printf("\n"); printf("%4d\n",TogliDaCoda(&coda1)); printf("\n"); printf("%4d\n",TogliDaCoda(&coda1)); printf("\n"); StampaCoda(&coda1); }
Output della esecuzione di pilacoda:
Pila: 1 Pila: 1 2 Pila: 1 2 3 3 Pila: 1 2 Coda: 10 Coda: 10 11 Coda: 10 11 12 10 Coda: 11 12 11 Coda: 12
51.00 Celsius: 123.80 Fahrenheit
- 17.00 Celsius: 1.40 Fahrenheit
Visibilità e funzioni
Visibilità delle variabili in blocchi annidati
Le variabili definite in un blocco (insieme di comandi racchiusi da { }) sono visibili solo all’interno
di quel blocco perciò, se in un blocco annidato in un altro viene definita una variabile con un nome
già usato, questa è una nuova variabile , accessibile solo all’interno di quest’ultimo. Il programma
seguente mostra tale situazione. Attenzione quindi ai nomi delle variabili e a dove sono posizionate!
file: visib.c
#include <stdio.h> int i = 1; /* i definita al livello di file / int main() { printf("%d\n", i); / stampa 1 / { int i = 2, j = 3; / i e j definite a livello di blocco / printf("%d\n%d\n", i, j); / stampa 2, 3 / { int i = 0; / i ridefinita in un blocco interno / / le definizioni precedenti di i sono nascoste / printf("%d\n%d\n", i, j); / stampa 0, 3 / } printf("%d\n", i); / stampa 2 / } printf("%d\n", i); / stampa 1 */ return 0; }
Potenza
Ogni funzione “vede” le variabili che appartengono al suo ambiente locale cioè quelle dichiarate
nella sua testata e nella sua parte dichiarativa e, quando rende il controllo al programma chiamante
(nella maggior parte dei casi il main), può “ritornare” un valore mediante l’istruzione
return(..).
Perciò, se la funzione è di tipo algebrico e calcola un risultato dipendente da una serie di variabili
esterne, queste ultime sono generalmente passate come valori alla funzione che ottiene la soluzione
e la ritorna.
La funzione potenza calcola la potenza (intera) di un numero attraverso un ciclo for:
file: potenza.c
/* potenza di un numero */ #include<stdio.h>
float potenza(float base, int espon){ float ris; if(espon < 0) { espon = - espon; base = 1.0 / base; } ris = 1.0; for(; espon > 0; espon--) ris = ris * base; return(ris); } void main() { float base; int espon; printf("\nfornisci base (un numero negativo termina il programma): "); scanf("%f", &base); while(base > 0) { printf("\nfornisci esponente (numero intero): "); scanf("%d", &espon); printf("\nrisultato : %f", potenza(base,espon)); printf("\nfornisci base (un numero negativo termina il programma): "); scanf("%f", &base); } }
Calcolo delle radici di un’equazione di 2° grado
Eccone ora una funzione nota: calcolo delle radici di un’equazione di 2° grado noti i coefficienti. Le
radici sono generalmente 2 e la funzione è di tipo void, non ritorna alcun valore al programma
chiamante ma stampa direttamente i risultati.
file: equaz2do.c
#include<stdio.h> #include<math.h> void EquazioneSecondoGrado(double a, double b, double c) { double x1,x2,Disc; if (a==0) printf("\n errore: equazione di primo grado"); else { Disc=bb-4ac; if (Disc < 0) printf("\n errore: radice complessa "); else { x1 = (-b+sqrt(Disc)) / (2.0a); x2 = (-b-sqrt(Disc)) / (2.0*a); printf("\n x1 = %g", x1); printf("\n x2 = %g", x2); } }
void scambiacx(complex *pt1, complex *pt2) { complex tmp; tmp = *pt1; *pt1 = *pt2; *pt2 = tmp; }
file: scambia.c
/* programma di prova della funzione scambia */ #include<stdio.h> #include"scambia.h" void main() { int unoi = 1, duei = 2; char ac = 'a', bc = 'b'; float fla = 1.0100, flb = 2.0200; double dba = 10.0030, dbb = 23.9950; complex cx1, cx2; cx1.realp = 1.2; cx1.imgp = 2.1; cx2.realp = 91.2; cx2.imgp = 92.1; printf("\n uno: %i due: %i ", unoi, duei); scambiain(&unoi,&duei); printf("\n uno: %i due: %i ", unoi, duei); printf("\n a: %c b: %c ", ac, bc); scambiach(&ac,&bc); printf("\n a: %c b: %c ", ac, bc); printf("\n fla: %f flb: %f ", fla, flb); scambiafl(&fla,&flb); printf("\n fla: %f flb: %f ", fla, flb); printf("\n dba: %lf dbb: %lf ", dba, dbb); scambiadb(&dba,&dbb); printf("\n dba: %lf dbb: %lf ", dba, dbb); printf("\n cx1: %lf %lf cx2: %lf %lf", cx1.realp, cx1.imgp, cx2.realp, cx2.imgp); scambiacx(&cx1,&cx2); printf("\n cx1: %lf %lf cx2: %lf %lf", cx1.realp, cx1.imgp, cx2.realp, cx2.imgp); }
Output della esecuzione di scambia:
uno: 1 due: 2 uno: 2 due: 1 a: a b: b a: b b: a fla: 1.010000 flb: 2. fla: 2.020000 flb: 1. dba: 10.003000 dbb: 23.9 95000 dba: 23.995000 dbb: 10. cx1: 1.200000 2.100000 cx2: 91.200000 92. cx1: 91.200000 92.100000 cx2: 1.200000 2.
Scambio dei valori di due variabili (ver. 2)
Se si vuole costruire una funzione di scambio che operi su diversi tipi di dato bisogna passare ad
essa anche il tipo di dato interessato, in questo caso i puntatori passati devono essere modificati
attraverso l’operatore di “casting”. I puntatori infatti sono puntatori a un particolare tipo di dato.
Ecco allora la rielaborazione del programma precedente, in cui il primo parametro passato alla
funzione è un carattere che viene interpretato come il tipo del dato su cui operare. In questa
implementazione viene usato il costrutto di controllo switch - case.
file: scambiab.c
/* programma di prova della funzione scambia / #include<stdio.h> / definizione del tipo numero complesso / typedef struct { double realp, imgp; } complex; / funzione di scambio fra due variabili */ void scambia(char tipo, void *pt1, void *pt2) { char tmpch; int tmpin; double tmpfl; complex tmpcx; switch (tipo) { case 'c': tmpch = * (char *)pt1;
- (char *)pt1 = * (char *)pt2;
- (char *)pt2 = tmpch; break; case 'i': tmpin = * (int *)pt1;
- (int *)pt1 = * (int *)pt2;
- (int *)pt2 = tmpin; break; case 'f': tmpfl = * (double *)pt1;
- (double *)pt1 = * (double *)pt2;
- (double *)pt2 = tmpfl; break; case 'x': tmpcx = * (complex *)pt1;
- (complex *)pt1 = * (complex *)pt2;
- (complex *)pt2 = tmpcx; break; default: puts("tipo sconosciuto"); } } void main() { int unoi = 111, duei = 222; double unof = 10.10002, duef = 20.20001; char ac = 'Y', bc = 'Z'; void *pt1, *pt2; complex cx1, cx2; cx1.realp = 1.2; cx1.imgp = 9.3; cx2.realp = 8.2; cx2.imgp = 8.3; printf("\n uno: %i due: %i ", unoi, duei); pt1 = &unoi; pt2 = &duei; scambia('i',pt1,pt2);
#include<stdio.h> /* codifica ricorsiva / int MCDric(int a, int b) { int differenza, minore; if(a == b) return (b); else { differenza = a>b? a-b : b-a; minore = a>b? b : a; return (MCDric(differenza,minore)); }; } / codifica iterativa */ int MCDite(int a, int b) { while (a != b) { if (a > b) a = a - b; else b = b - a; } return (b); } void main () { int x, y; printf("introdurre due numeri interi\n"); scanf("%d %d", &x, &y); printf("Il Massimo Comun Divisore fra %d e %d e' %d\n", x, y, MCDric(x,y)); printf("Il Massimo Comun Divisore fra %d e %d e' %d\n", x, y, MCDite(x,y)); }
altra forma della funzione MCDite :
int MCDite(int a, int b) { while ((a != 0) && (b != 0)) { if (a > b) a = a % b; else b = b % a; } return ((a>b)? a : b); }
altra forma della funzione MCDric :
int MCDric(int a, int b) { return (b? MCDric(b, a % b) : a); }
Media ricorsiva
Anche la media può essere ottenuta ricorsivamente osservando che:
1 1 ,^ ^1 , 0 ^0
i X
i
X X
X i Xi i i
file: mediar.c
#include <stdio.h> float Media(float elementi[], int num_elementi) /* funzione di calcolo della media in modo ricorsivo ** bisogna fornire l'indirizzo del vettore che contiene i valori ** e la sua lunghezza / { float med,med1; if(num_elementi == 1) med=elementi; else { med1=Media(elementi + 1, num_elementi - 1); med=med1 + ((*elementi - med1) / num_elementi); } return med; } void main() { int cont, num_elem; float media, elementi[50]; printf("inserisci il numero di elementi dei quali vuoi fare la media: "); scanf("\n%d", &num_elem); for(cont=0; cont<num_elem; cont++) { printf("Inserisci numero: \n"); scanf("%f",&elementi[cont]); } media = Media(elementi, num_elem); printf ("\nLa media e`: %f", media); }
Polinomio
Per un polinomio di grado n nella variabile x di coefficienti ci , vale la seguente eguaglianza:
Pn ( x ) cnxn cn 1 xn ^1 c 1 x^1 c 0 c 0 x ( c 1 x ( c 2 x cn ))
codificata nella funzione ricorsiva Poli, come appare qui di seguito.
file: poli.c
/* calcolo ricorsivo di un polinomio / #include <stdio.h> #define MAX_SZ 10 / i parametri passati sono: il valore della variabile x, il vettore
