Isbn6821-0 SoluzioneDegliEsercizi

Linguaggio C, Una guida alla programmazione con elementi di Objective-C 5/ed
A.Bellini, A.Guidi,
Copyright © 2013 - McGraw-Hill Education Italy srl
Soluzioni degli esercizi (Applica le abilità)
Capitolo 2
1.
a) Linux ls /home/Gabriele/oro
MS/DOS o Windows dir \home\Gabriele\oro
b) Linux ls /home/Gabriele
MS/DOS o Windows dir \home\Gabriele
c) Linux ls /bin
MS/DOS o Windows dir \bin
d) Linux ls /home/Gabriele/oro/gioielli
MS/DOS o Windows dir \home\Gabriele\oro\gioielli
e) Linux ls /home/Gabriele/oro/a*
MS/DOS o Windows dir \home\Gabriele\oro\a*
f) Linux ls /bin/l*
MS/DOS o Windows dir \bin\l*
2.
a) Linux ls
MS/DOS o Windows dir
b) Linux ls ..
MS/DOS o Windows dir ..
c) Linux ls ../../ ../bin
MS/DOS o Windows dir ..\..\ ..\bin
d) Linux ls gioielli
MS/DOS o Windows dir gioielli
e) Linux ls a*
MS/DOS o Windows dir a*
f) Linux ls ../../../bin/l*
MS/DOS o Windows dir ..\..\..\bin\l*
3.
La figura a cui si fa riferimento nell’esercizio è Figura 2.3 (e non la 2.9 come erroneamente indicato).
a) Linux cd /etc
MS/DOS o Windowscd \etc
b) Linux cd /home/pluto
MS/DOS o Windowscd \home\pluto
c) Linux cd /home
MS/DOS o Windows cd \home
d) Linux cd /
MS/DOS o Windows cd \
e) Linux cd /bin
ls
cd /home/nora
MS/DOS o Windows cd \bin
dir
cd \home\nora
A.Bellini, A.Guidi,
4.
a) Linux cd ../../etc
MS/DOS o Windows cd ..\../etc
b) Linux cd ../pluto
MS/DOS o Windows cd ..\pluto
c) Linux cd ..
MS/DOS o Windows cd ..
d) Linux cd ../..
MS/DOS o Windows cd ..\..
e) Linux cd ../../bin
ls
cd ../home/nora
MS/DOS o Windows cd ..\..\bin
dir
cd ..\home\nora
5.
a) Linux cd /home/Gabriele
MS/DOS o Windows cd \home\Gabriele
b) Linux cd ../Gabriele
MS/DOS o Windows cd ..\Gabriele
c) Linux mkdir /home/Gabriele/programmi
MS/DOS o Windows mkdir \home\Gabriele\programmi
d) Se la directory corrente è ancora nora:
Linux mkdir ../Gabriele/programmi
MS/DOS o Windows mk dir ..\Gabriele\programmi
Se invece con i comandi indicati nei punti precedenti la directory corrente è ora Gabriele:
Linux mkdir programmi
MS/DOS o Windows mkdir programmi
e) Se la directory corrente è ancora nora:
Linux rmdir ../Gabriele/programmi
MS/DOS o Windows rmdir ..\Gabriele\programmi
Se invece, con i comandi indicati nei punti precedenti, la directory corrente è ora Gabriele:
Linux rmdir programmi
MS/DOS o Windows rmdir programmi
6.
L’esercizio presenta una difficoltà in quanto il nome del file contiene un carattere spazio al suo interno, C02
2008.DOC, se al posto dello spazio ci fosse un carattere di sottolineatura, C02_2008.DOC, le soluzioni sarebbero le
seguenti:
a) Linux cp C02_2008.DOC C02BACKUP.DOC
MS/DOS o Windows copy C02_2008.DOC C02BACKUP.DOC
b) Linux cp C02_2008.DOC ../C02COPIA.DOC
MS/DOS o Windows copy C02_2008.DOC ..\C02COPIA.DOC
c) Linux rm C02_2008.DOC
MS/DOS o Windows del C02_2008.DOC
Per porter considerare lo spazio si deve porre il nome tra doppi apici:
a) MS/DOS o Windows copy "C02 2008.DOC" C02BACKUP.DOC
b) MS/DOS o Windows copy "C02 2008.DOC" ..\C02COPIA.DOC
c) MS/DOS o Windows del "C02 2008.DOC"
7.
a) Linux mkdir filePrecedenti
MS/DOS o Windows mkdir filePrecedenti
b) Linux cp * filePrecedenti
MS/DOS o Windows copy *.* filePrecedenti
A.Bellini, A.Guidi,
c) Linux rm *.DOC
MS/DOS o Windows del *.DOC
8.
a) Linux mkdir T08/filePrecedenti
MS/DOS o Windows mkdir T08\filePrecedenti
b) Linux cp T08/* T08/filePrecedenti
MS/DOS o Windows copy T08\*.* T08\filePrecedenti
c) Linux rm T08/*.DOC
MS/DOS o Windows del T08\*.DOC
A.Bellini, A.Guidi,
Capitolo 3
1
Si suppone che il cellulare utilizzato sia in grado di effettuare la ricerca di un nome digitandone in sequenza le lettere.
a. Premi sul cellulare il tasto che attiva la rubrica
b. premi la prima lettera del nome ricercato
c. fintantoché non appare sullo schermo l’intero nome ricercato oppure il messaggio “nessuna corrispondenza” premi
la successiva lettera del nome
d. Se è apparso sullo schermo l’intero nome ricercato premere il tasto di avvio chiamata telefonica.
d. fine
2
a. Scrivi 1
b. fintantoché il numero scritto è diverso da 100, scrivi il numero precedente + 1
c. fine
3
a. Scrivi 1
b. fintantoché il numero scritto è diverso da 99, scrivi il numero precedente + 2
c. fine
4
a. Scrivi 2
b. fintantoché il numero scritto è diverso da 50, scrivi il numero precedente 2
c. fine
5
a. Scrivi 150
b. addiziona 1 al numero precedente
c. se il resto della divisione intera del numero ottenuto per 4 è diverso da zero scrivi il numero
d. fintantoché il numero ottenuto è diverso da 4 vai all’istruzione b
e. fine
6
a. Suddividi le carte in 4 mazzi, ognuno dei quali costituito da carte dello stesso seme
b. per ogni seme ordina le carte dall’asso al re
c. prendi il mazzo di cuori, quadri, fiori e picche
La descrizione può avere un maggior dettaglio, per esempio:
a. Suddividi le carte in 4 mazzi, ognuno dei quali costituito da carte dello stesso seme
b. per ogni seme prendi l’asso, prendi il due, prendi il tre.. prendi il re
c. prendi il mazzo di cuori, quadri, fiori e picche
7
Alla prima mossa si devono lasciare all’avversario 9 oggetti (4i + 1, i = 2)
a. Raccogli 2 oggetti
b. il secondo giocatore raccoglie m oggetti (1  m  3)
c. finché ci sono ancora oggetti sul tavolo: raccogli 4 m oggetti e vai all’istruzione b
d. fine (il secondo giocatore gioca sempre per ultimo e il primo giocatore vince sempre)
8
a. Il primo giocatore raccoglie m oggetti (m può essere 1 o 3)
b. raccogli m oggetti
c. il primo giocatore raccoglie m oggetti (1  m  3)
d. finché ci sono ancora oggetti sul tavolo: raccogli 4 m oggetti e vai all’istruzione c
e. fine (il primo giocatore gioca sempre per ultimo e il secondo giocatore vince sempre)
A.Bellini, A.Guidi,
9
Non è possibile scrivere un algoritmo vincente quando gli oggetti sono n = 4i + 1, per esempio 9, 13, 17, 21 ecc. In tali
circostanze il primo giocatore non può lasciare al secondo un numero di oggetti della forma 4i + 1. Negli altri casi (n
diverso da 4i + 1) l’algoritmo è il seguente.
a. Raccogli j oggetti, dove j = 2 se r = 3 (r è il resto della divisione intera di n per 4), j = 1 se r = 2, j = 3 se r = 0
b. il secondo giocatore raccoglie m oggetti (1  m  3)
c. finché ci sono ancora oggetti sul tavolo: raccogli 4 m oggetti e vai all’istruzione b
d. fine (il secondo giocatore gioca sempre per ultimo e il primo giocatore vince sempre)
10
a. Prendi i coefficienti a, b e c
b. calcola  = b2 4ac
c. se  < 0 non esistono radici reali, altrimenti
se  = 0 allora x1 = x2 = b/2a, altrimenti
x1 = (b +√2ax2 = (b √2a
12
a. Scrivi 1
b. considera il primo numero naturale
c. addiziona al numero scritto il successivo numero naturale
d. fintantoché il numero ottenuto è minore di 1000 scrivi il numero e vai all’istruzione b
e. fine
13
a. Considera il primo numero naturale
b. scrivi il numero naturale considerato moltiplicato due volte per se stesso
c. fintantoché il numero ottenuto è minore di 10000 considera il successivo numero naturale e vai all’istruzione b
d. fine
A.Bellini, A.Guidi,
Capitolo 4
2
numero = 1;
while(numero<101) {
scrivi numero;
numero = numero + 1;
}
o, tra le tante alternative:
numero = 0;
do {
scrivi numero;
}
while (numero!=100);
3
numero = 1;
while(numero<100) {
scrivi numero;
}
5
numero = 150;
while(numero<0) {
if(numero%4!=0) scrivi numero;
}
7
n è la variabile che contiene il numero di oggetti con cui si gioca, mentre m è la variabile che contiene il numero di
oggetti che preleva il secondo giocatore. Si dà per scontato che il secondo giocatore raccolga 1, 2 o 3 oggetti, per cui
l’istruzione
prendi m;
assegnerà a m un valore intero compreso tra 1 e 3. In realtà questi valori andrebbero controllati.
n = 11;
n = n 2;
while(n>4) {
prendi m;
n = n m;
n = n (4m);
}
scrivi "Tocca al secondo giocatore,
e il primo ha vinto"
Naturalmente avremmo potuto scrivere al posto delle ultime due istruzioni n=nm(4m).
8
Nota: si dà per scontato che il primo giocatore raccolga 1 o 3 oggetti al primo giro e 1, 2 o 3 oggetti ai giri successivi. In
realtà questi valori andrebbero controllati.
n = 11;
A.Bellini, A.Guidi,
prendi m;
n = n m;
while(n>4) {
prendi m;
n = n m;
n = n (4m);
}
scrivi "Tocca al primo giocatore,
9
Non è possibile scrivere un algoritmo vincente quando gli oggetti sono n = 4i + 1, per esempio 9, 13, 17, 21 ecc. In tali
circostanze il primo giocatore non può lasciare al secondo un numero di oggetti della forma 4i + 1. Negli altri casi (n
diverso da 4i+1) l’algoritmo è il seguente.
prendi n;
r = n % 4;
if(r=3) j=2;
if(r=2) j=1;
if(r=0) j=3);
n = n j;
while(n>4) {
prendi m;
n = n m;
n = n (4m);
}
scrivi "tocca al secondo giocatore,
Abbiamo utilizzato una sequenza di tre if per determinare il valore di j; avremmo potuto utilizzare una cascata di if
(vedi Capitolo 7):
if(r=3) j=2; else
if(r=2) j=1; else j=3;
Dato che nel nostro caso i valori ammissibili del resto della divisione intera di n per 4 possono essere solo 0, 2, 3 (1 non
può essere, altrimenti n sarebbe della forma 4i + 1) possiamo evitare l’ultima if: if(r=0) e mettere direttamente
l’else.
13
numero = 1;
naturale = 2;
while(numero<1000) {
scrivi numero;
numero = numero + naturale;
naturale = naturale + 1;
}
14
numero = 1;
while(numero*numero*numero<10000) {
scrivi numero*numero*numero;
}
A.Bellini, A.Guidi,
Capitolo 5
5
#include <stdio.h>
#include <stdlib.h>
#define ZERO 0
#define TOP 1000
int main(void)
{
int a, b, c, x, y;
printf("Valore di x: ");
scanf("%d", &x);
printf("Valore di y: ");
scanf("%d", &y);
a = ZEROabs(x);
b = TOPabs(y);
c = a*b;
printf("Valore di a: %d\n", a);
printf("Valore di b: %d\n", b);
printf("Valore di c: %d\n", c);
}
 SUGGERIMENTI DI PROGRAMMAZIONE Non si riescono a leggere i risultati nella finestra di

esecuzione del programma
Se eseguendo i programmi non si riescono a leggere i risultati, la causa potrebbe essere la chiusura immediata della
finestra d’esecuzione che non lascia il tempo per osservare l’output del programma sul video. Per ovviare
all’inconveniente, si può utilizzare il seguente artifizio facile da interpretare, ma che comunque verrà spiegato nel
proseguo dello studio.
Inserire la dichiarazione della variabile carattere pausa:
char pausa;
Aggiungere come ultime due istruzioni del programma:
scanf("%c", &pausa);
che mettono in attesa il programma in esecuzione della pressione di un tasto da parte dell’utente.
Sarebbe meglio farle precedere da un messaggio esplicativo.
printf("Un tasto qualsiasi per continuare\n");

11
Visualizza 222.
12
Visualizzano 48, -60, 6 e 2.
13
Visualizzano 24, -84, -6 e 2.
A.Bellini, A.Guidi,
14
Visualizzano 37, -48, 5 e 2.
A.Bellini, A.Guidi,
Capitolo 6
4
______
______2_
_545
2545
2545
______
______2_
_545__547
______
______2_
_5451090
______
______2_
_545__1092
______
______2_
_545__
__1188100
5
#include <stdio.h>
#define A 2
#define B 545
char pausa;
int main(void)
{
printf("%7d%4d\n", A, B);
printf("%7d%4d%4d\n", A, B, A+B);
printf("%7d%4d%4d\n", A, B, A*B);
printf("%7d%4d%5d\n", A, B, A*B+A);
printf("%7d%4d%9d\n", A, B, A*A*B*B);
}
6
#include <stdio.h>
char pausa;
int main(void)
{
char c1, c2, c3;
c1='P';
c2='&';
c3='F';
printf("%c%c%c\n", c1, c2, c3);
printf("%c%c %c\n", c1, c2, c3);
printf("%c %c %c\n", c1, c2, c3);
printf("Padre:%c %c Figlio:%c\n", c1, c2, c3);
printf("Padre: %c %c Figlio: %c\n", c1, c2, c3);
}
7
#include <stdio.h>
char pausa;
int main(void)
{
char asso, re, donna;
int a, r, d;
asso='A';
re='R';
donna='D';
A.Bellini, A.Guidi,
a=11;
r=10;
d=9;
printf("%c %d %c %d %c %d\n", asso, a, re, r, donna, d);
printf("%c%c%c %d %d %d\n", asso, re, donna, a, r, d);
printf("%d %c %d %c %d %c\n", a, asso, r, re, d, donna);
printf("%d %c %d %c %d %c\n", d, donna, r, re, a, asso);
printf("Asso %c%d RE %c%d Donna %c%d\n", asso, a, re, r, donna, d);
}
10
____
____2.00
___
___2.000__545.110
_______
_______2___
___545.1
547.10999__2.00000 545.10999
_547.10999____
____2.00__
__545.11__
__-543.10999
A.Bellini, A.Guidi,
Capitolo 7
2
/* Determina il maggiore tra quattro valori */
#include <stdio.h>
int main(void)
{
int a, b, c, d;
printf("\nDigita quattro valori interi distinti: ");
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
scanf("%d", &d);
if(a>b)
if(a>c)
if(a>d)
printf("Il maggiore e': %d\n", a);
else
printf("Il maggiore e': %d\n", d);
else
if(c>d)
printf("Il maggiore e': %d\n", c);
else
else
if(b>c)
if(b>d)
printf("Il maggiore e': %d\n", b);
else
else
if(c>d)
else
}
4
/* Determina il maggiore e
il minore fra tre valori */
#include <stdio.h>
int main(void)
{
int a, b, c;
printf("\nDigita tre valori
interi distinti: ");
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
if(a>b)
if(a>c) {
printf("Il maggiore e': %d\n", a);
if(b<c)
printf("Il minore e': %d\n", b);
else
printf("Il minore e': %d\n", c);
}
A.Bellini, A.Guidi,
else {
printf("Il minore e': %d\n", b);
}
else
if(b>c) {
printf("Il maggiore e': %d\n", b);
if(a<c)
printf("Il minore e': %d\n", a);
else
printf("Il minore e': %d\n", c);
}
else {
printf("Il minore e': %d\n", a);
}
}
5
/* Esempio visualizzazione menu
e controllo scelte utente */
#include <stdio.h>
int main(void)
{
char scelta;
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
printf("\n MENU DI
PROVA\n");
printf("\n a) Per immettere dati");
printf("\n b) Per determinare il maggiore");
printf("\n c) Per determinare il minore");
printf("\n d) Per ordinare");
printf("\n e) Per visualizzare");
printf("\n\n Scelta: ");
scelta = getchar();
switch(scelta) {
case 'a':
printf("\n In esecuzione l'opzione a");
break;
case 'b':
printf("\n In esecuzione l'opzione b");
break;
case 'c':
printf("\n In esecuzione l'opzione c");
break;
case 'd':
printf("\n In esecuzione l'opzione d");
break;
case 'e':
printf("\n In esecuzione l'opzione e");
break;
default:
printf("\n Opzione inesistente");
break;
}
}
A.Bellini, A.Guidi,
9
#include <stdio.h>
int main(void)
{
int punteggio = 0;
char risposta;
char pausa;
printf("\nIl matematico Kummer e' vissuto nel '700 (s/n)? ");
scanf("%c", &risposta);
if(risposta=='n') punteggio = punteggio + 1;
printf("\nL'ultimo teorema di Fermat e' stato dimostrato nel XX secolo (s/n)?
");
if(risposta=='s') punteggio = punteggio + 1;
printf("\nLa cardinalita' di tutti gli interi e maggiore di quella dei soli
interi pari(s/n)? ");
printf("\nPunteggio: %d su 3", punteggio);
printf("\nPremi un tasto per continuare.");
}
10
#include <stdio.h>
int main(void)
{
int punteggio = 0;
char risposta;
char pausa;
else punteggio = punteggio 1;
printf("\nL'ultimo teorema di Fermat e' stato dimostrato nel XX secolo (s/n)?
");
interi pari(s/n)? ");
}
A.Bellini, A.Guidi,
11
#include <stdio.h>
int main(void)
{
int punteggio = 0;
char risposta;
char pausa;
if(risposta=='n') {
punteggio = punteggio + 1;
printf("\nPitagora e' vissuto nel III secolo a.C. (s/n)? ");
printf("\nEuclide e' vissuto nel III secolo a.C. (s/n)? ");
}
else {
punteggio = punteggio 1;
printf("\nL'ultimo teorema di Fermat e' stato dimostrato alla fine del '900
(s/n)? ");
interi pari? ");
}
}
12
#include <stdio.h>
int main(void)
{
int punteggio = 0;
char risposta;
char pausa;
if(risposta=='n') {
A.Bellini, A.Guidi,
if(risposta=='n') {
printf("\nGauss e' vissuto dopo Galileo (s/n)? ");
}
else {
}
}
else {
(s/n)? ");
interi pari? ");
}
}
13
#include <stdio.h>
int main(void)
{
int punteggio = 0;
char risposta;
char pausa;
if(risposta=='n') {
if(risposta=='n') {
printf("\nGauss e' vissuto dopo Galileo (s/n)? ");
A.Bellini, A.Guidi,
else punteggio = punteggio - 1;
}
else {
punteggio = punteggio - 1;
}
}
else {
(s/n)? ");
if(risposta=='s') {
printf("\nRiemann e' nato dopo Gauss (s/n)? ");
}
else {
printf("\nLa cardinalita' di tutti gli interi e maggiore di quella dei
soli interi pari? ");
}
}
}
A.Bellini, A.Guidi,
Capitolo 8
1
/* Verifica il valore delle espressioni date */
#include <stdio.h>
int a, b, c, ris;
int main(void)
{
a = 5;
b = 35;
c = 7;
ris = a+b*c;
printf("\n a) %d", ris);
ris = a>b;
printf("\n b) %d", ris);
ris = (a+b) * (a<b);
printf("\n c) %d", ris);
ris = (a+b) && (a<b);
printf("\n d) %d", ris);
ris = (a+b) || (a>b);
printf("\n e) %d", ris);
ris = ((a*c) b) || (a>b);
printf("\n f) %d", ris);
ris = ((a*c) != b) || (a>b);
printf("\n g) %d", ris);
ris = (a>b) || (a<c) || (c==b);
printf("\n h) %d\n", ris);
/* O ALTERNATIVAMENTE ALL'INTERNO DELLE PRINTF */
printf("\n a) %d", a+b*c);
printf("\n b) %d", a>b);
printf("\n c) %d", (a+b) *
(a<b));
printf("\n d) %d", (a+b) && (a<b));
printf("\n e) %d", (a+b) || (a>b));
printf("\n f) %d", ((a*c) b) || (a>b));
printf("\n g) %d", ((a*c) != b) || (a>b));
printf("\n h) %d\n", (a>b) || (a<c) || (c==b));
}
I risultati visualizzati dal programma saranno i seguenti:
a) 250 b) 0
c) 40 d) 1
e) 1 f) 0
g) 0 h) 1
2
I risultati visualizzati dal programma saranno i seguenti:
a) Vero (1) b) Falso (0)
c) Vero (1) d) Vero (1)
e) Falso (0) f) Vero (1)
3
I risultati visualizzati dal programma saranno:
a) vero (1) b) falso (0)
c) vero (1) d) vero (1)
e) vero (1) f) falso (0)
A.Bellini, A.Guidi,
4
d = (a*2+b) != c ? a*b*c: a+b+c;
5
printf("\n Il maggiore e': %d",
(x=(a>b)?a:b)>c?x:c);
dove x è una variabile int.
A.Bellini, A.Guidi,
Capitolo 9
1
/* Determina il fattoriale dei numeri minori o uguali all'intero
immesso dall'utente */
#include <stdio.h>
int main(void)
{
int n, fat, aux;
printf("CALCOLO DEI FATTORIALI DEI NUMERI <= N\n\n");
printf("Inser. n: ");
scanf("%d", &n);
fat = 1;
printf("Il fattoriale di: 0 ha
valore: %d\n", fat);
for(aux=1; aux<=n; aux++) {
fat = fat*aux;
printf("Il fattoriale di: %d ha
valore: %d\n", aux, fat);
}
}
2
/* Determina il maggiore, il minore e la media dei valori immessi */
#include <stdio.h>
#include <limits.h>
int main(void)
{
int i, n, numero, max, min, media;
printf("MAGGIORE MINORE E MEDIA\n");
min = INT_MAX;
max = INT_MIN;
media = 0;
i = 1;
do {
printf("\nLunghezza della
sequenza: ");
scanf("%d", &n);
}
while(n<1);
for(i=1; i<=n; i++) {
printf("Valore int.: \t");
scanf("%d", &numero);
if(numero>max)
max = numero;
else
if(numero<min)
min = numero;
media = media+numero;
}
printf("Maggiore: %d\n", max);
printf("Minore: %d\n", min);
printf("Media: %d\n", media/n);
}
A.Bellini, A.Guidi,
3
/* Visualizza un rettangolo di cornice * e parte interna Q;
le dimensioni del rettangolo sono decise dall'utente */
#include <stdio.h>
int main(void)
{
int i, j, linee, colonne;
do {
printf("\nNumero di linee: ");
scanf("%d", &linee);
}
while(linee<1);
do {
printf("\nNumero di colonne: ");
scanf("%d", &colonne);
}
while(colonne<1);
for(i=1; i<=linee; i++)
for(j=1; j<=colonne; j++)
if(i==1 || i==linee || j==1
|| j==colonne) {
printf("*");
if(j==colonne) printf("\n");
}
else printf("Q");
}
4
/* Visualizza tanti rettangoli quanti ne desidera l'utente con
caratteri e dimensioni scelti a tempo di esecuzione */
#include <stdio.h>
int main(void)
{
int i, j, y, linee, colonne, volte;
char cornice, interno;
do {
printf("\nNumero di linee: ");
scanf("%d", &linee);
}
while(linee<1);
do {
scanf("%d", &colonne);
}
while(colonne<1);
printf("\nCarattere della
cornice: ");
scanf("%1s", &cornice);
printf("\nCarattere dell'interno: ");
scanf("%1s", &interno);
do {
printf("\nNumero di
visualizzazioni: ");
scanf("%d", &volte);
}
while(colonne<1);
for(y=1; y<=volte; y++)
A.Bellini, A.Guidi,
for(i=1; i<=linee; i++)
for(j=1; j<=colonne; j++)
if(i==1 || i==linee || j==1 || j==colonne ) {
printf("%c", cornice);
if(j==colonne) printf("\n");
}
else printf("%c", interno);
}
12
int i;
for(i=1; i<=99; i=i+2)
printf("\n%d", i);
13
int i;
for(i=-2; i>=-50; i=i-2)
printf("\n%d", i);
14
int i;
for(i=-150; i<=-1; i++)
if(i%4!=0)
printf("\n%d", i);
16
int i, j;
int primo;
for(i=1; i<=100; i++) {
primo=1;
for(j=2; j<i; j++)
if(i%j==0) primo=0;
if(primo==1)
printf("\nNumero primo: %d", i);
}
17
int i, j;
j=1;
for(i=2; j<1000; i++) {
printf("\n%d", j);
j=j+i;
}
18
int i, j;
j=1;
for(i=2; j<10000; i++) {
printf("\n%d", j);
j=i*i*i;
}
Oppure con una sola variabile:
A.Bellini, A.Guidi,
int i;
for(i=1; i*i*i<10000; i++)
printf("\n%d", i*i*i);
A.Bellini, A.Guidi,
Capitolo 10
1
Il ciclo che effettua la somma deve essere realizzato in modo che l’elemento del secondo array sia simmetrico rispetto
al primo.
for(i=0; i<n; i++)
c[i] = a[i] + b[ni1];
/* Somma incrociata di due vettori */

#include <stdio.h>
int main(void)
{
int n = 4;
int a[n], b[n], c[n];
int i;
char pausa;
printf("\nVettore a\n");
for(i=0; i<n; i++) {
printf("Elemento %d del primo vettore: ", i+1);
scanf("%d", &a[i]);
}
printf("\nVettore b\n");
for(i=0; i<n; i++) {
printf("Elemento %d del secondo vettore: ", i+1);
scanf("%d", &b[i]);
}
/* Somma incrociata a+b */

for(i=0; i<n; i++)
c[i] = a[i] + b[n-i-1];
printf("\nSomma incrociata a+b\n");

for(i=0; i<n; i++)
printf("Elemento %d della somma incrociata: %d\n", i+1, c[i]);
}
2
Se l’elemento in esame risulta il maggiore if(voti[i]>max) è inutile confrontarlo con il minore, altrimenti else
lo si confronta. (Scegliamo di effettuare i confronti, gli assegnamenti e i calcoli necessari a determinare il maggiore, il
minore e la media all’interno di un solo ciclo, per cui la scansione dell’array avviene una sola volta.)
max = voti[0];
min = voti[0];
media = voti[0];
for(i = 0;i <= 5; i++) {
if(voti[i]>max)
max = voti[i];
else
if(voti[i]<min)
min = voti[i];
media = media+voti[i];
A.Bellini, A.Guidi,
}
3
Diamo la soluzione per la prima parte dell’esercizio lasciando al lettore l’onere e il piacere di completarlo.
/* Carica un vettore alternativamente di zeri e uni,
visualizza il vettore */
#include <stdio.h>
#define MAX_ELE 1000 /* massimo numero di elementi */
int main(void)
{
int prova[MAX_ELE];
int i, n;
char invio;
do {
printf("\nNumero elementi: ");
scanf("%d", &n);
}
while(n<1 || n>MAX_ELE);
/* Si carica il vettori di zeri e uni */
prova[0] = 0;
for(i=1; i<n; i++)
if(i%2 == 1) prova[i] = 1;
else prova[i] = 0;
for(i=0; i<n; i++)
printf("%d \n", prova[i]);
printf("\nQualsiasi tasto per continuare...");
scanf("%c", &invio);
}
4
/* Cerca l’elemento del vettore piu’ prossimo a k */
#include <stdio.h>
#include <math.h>
int main(void)
{
int v1[MAX_ELE];
int i, n, k, prossimo, indice;
char invio;
do {
scanf("%d", &n);
}
while(n<1 || n>MAX_ELE);
printf("IMMISSIONE ELEMENTI\n");
A.Bellini, A.Guidi,
for(i=0; i<n; i++) {
printf("Valore intero %d: ", i+1);
scanf("%d", &v1[i]);
}
printf("IMMISSIONE di k\n");
printf("Valore intero k: ");
scanf("%d", &k);
/* Ricerca elemento piu' prossimo a k*/
prossimo = fabs(kv1[0]);
indice = 0;
for(i=1; i<n; i++)
if((fabs(kv1[i])) < prossimo){
prossimo = fabs(kv1[i]);
indice = i;
}
printf("\nValore piu' prossimo a k nel vettore: %d\n", v1[indice]);
for(i=0; i<n; i++)
printf("%d \n", v1[i]);
printf("\nQualsiasi tasto per continuare...");
}
12
Devono essere definite le dimensioni della matrice.
#define N 10
#define P 10
#define M 10
int mat1[N][P];
int mat2[P][M];
int pmat[N][M];
Si devono richiedere all’utente le reali dimensioni e si deve controllare che il loro valore non superi le dimensioni delle
matrici. I valori da richiedere sono soltanto tre, in quanto le colonne della prima matrice devono essere in numero
uguale alle righe della seconda.
/* Richiesta delle dimensioni */
do {
printf("Numero di linee I
matrice: ");
scanf("%d", &n);
}
while((n>=N) || (n<1));
do {
printf("Numero colonne I
matrice / righe II matrice: ");
scanf("%d", &p);
}
while((p>=P) || (p<1));
do {
printf("Numero di colonne II
matrice: ");
A.Bellini, A.Guidi,
scanf("%d", &m);
}
while((m>=M) || (m<1));
Anteriormente devono essere state dichiarate le variabili n, m e p.
int n, m, p;
Sostituire N, M e P con n, m e p nel resto del programma.
14
/* Calcolo media voti per studente e per prova.
Nell'esemplificazione utilizziamo 3 studenti e 4 prove */
#include <stdio.h>
#define N 4
#define M 5
float voti[N][M];
int main(void)
{
int i, j, n, m;
char pausa;
n=N;
m=M;
printf("\n \n CARICAMENTO DEI VOTI \n \n");
for(i=0; i<n1; i++)
for(j=0; j<m1; j++) {
printf("Ins. studente %d prova %d: ", i+1, j+1);
scanf("%f", &voti[i][j]);
};
/* Calcolo medie per studente */
for(i=0; i<n1; i++) {
voti[i][m1] = 0;
for(j = 0; j < m1; j++)
voti[i][m1] = voti[i][m1] + voti[i][j];
voti[i][m1] = voti[i][m1] / (m1);
}
/* Calcolo medie per prova */
for(j=0; j<m; j++) {
voti[n1][j] = 0;
for(i=0; i<n1; i++)
voti[n1][j] = voti[n1][j] + voti[i][j];
voti[n1][j] = voti[n1][j]/(n1);
}
printf("\n \n VISUALIZZAZIONE DELLA MATRICE \n ");
for(i=0; i<n; i++) {
printf("\n");
for(j=0; j<m; j++)
printf("%8.3f", voti[i][j]);
}
}
Esempio di esecuzione:
Ins. studente 1 prova 1: 4
A.Bellini, A.Guidi,
VISUALIZZAZIONE DELLA MATRICE
4.000 5.000 4.000 7.000 5.000
8.000 10.000 8.000 10.000 9.000
6.000 7.000 8.000 6.000 6.750
6.000 7.333 6.667 7.667 6.917
A.Bellini, A.Guidi,
Capitolo 11
1
/* Funzione per il calcolo di una qualsiasi potenza
con esponente >= zero */
double pot(double base, int esp)
{
double po;
po = 1;
if(esp == 0)
return(1);
else {
while(esp) po *= base;
return(po);
}
}
2
#include <stdio.h>
void messaggio (int, int);
char messaggio[] = "Ciao, baby";
int main(void)
{
int riga = 10;
int colonna = 20;
messaggio (riga, colonna);
}
/* Funzione che visualizza un messaggio a un generica
coordinata x,y dello schermo */
void messaggio(int r, int c)
{
while(c) printf("\n");
while(r) putchar(' ');
printf("%s\n\n", messaggio);
}
3
#include <stdio.h>
char buf[128];
void minMaiusc (void);
int main(void)
{
printf("\nInserisci stringa: ");
scanf("%s", buf);
minMaiusc();
printf("%s\n", buf);
}
/* Funzione che converte le lettere minuscole in maiuscole */
void minMaiusc(void)
{
int i;
for (i = 0; buf[i] != '\0'; i++)
if (buf[i] >= 'a' && buf[i] <= 'z')
A.Bellini, A.Guidi,
buf[i] = buf[i] 'a' + 'A';
}
4
#include <stdio.h>
int numeri = 0;
int alfa = 0;
char buf[80];
int i;
char pausa;
void numAlfa(void);
int main(void)
{
scanf("%s", buf);
numAlfa();
printf("Ci sono %2d caratteri nmerici\n", numeri);
printf("Ci sono %2d caratteri alfabetici\n", alfa);
}
/* Funzione che conta il numero di caratteri e cifre */
void numAlfa(void)
{
for (i = 0; buf[i] != '\0'; i++)
switch(buf[i]) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
numeri++;
break;
default:
alfa++;
break;
}
}
5
Esercizio: modificare la funzione realizzata nell’esercizio 4 in modo che calcoli il numero di zeri, cifre pari e cifre
dispari e il numero di caratteri che non sono cifre numeriche.
#include <stdio.h>
int zeri = 0, pari = 0, dispari = 0;
int alfa = 0;
char buf[80];
int i;
char pausa;
void numAlfa(void);
int main(void)
A.Bellini, A.Guidi,
{
scanf("%s", buf);
numAlfa();
printf("Ci sono %2d zeri\n", zeri);
printf("Ci sono %2d cifre pari\n", pari);
printf("Ci sono %2d cifre dispari\n", dispari);
printf("Ci sono %2d caratteri alfabetici\n", alfa);
}
/* Funzione che conta il numero di caratteri e cifre */
void numAlfa(void)
{
for (i = 0; buf[i] != '\0'; i++)
switch(buf[i]) {
case '0':
zeri++;
break;
case '2':
case '4':
case '6':
case '8':
pari++;
break;
case '1':
case '3':
case '5':
case '7':
case '9':
dispari++;
break;
default:
alfa++;
break;
}
}
14
#include <stdio.h>
void interiPositivi(int);
int main(void)
{
int i;
i=50;
interiPositivi(i);
}
/* Funzione che visualizza i numeri interi positivi

da 1 a n */
void interiPositivi(int n) {
int i;
for(i=1; i<=n; i=i+2)
printf("\n%d", i);
}
A.Bellini, A.Guidi,
16
#include <stdio.h>
void interiPositivi2(int, int);
int main(void)
{
int i, j;
i=2; j=50;
interiPositivi2(i,j);
}
/* Funzione che visualizza i numeri interi positivi

da n a m con n minore di m */
void interiPositivi2(int n, int m) {
int i;
for(i=n; i<=m; i=i+2)
printf("\n%d", i);
}
A.Bellini, A.Guidi,
Capitolo 12
1
Qualsiasi soluzione si adotti tra quelle proposte nel testo, l’operatore relazionale dell’if che controlla lo scambio di
valori tra gli elementi deve essere cambiato da > a <.
if(vet[i]<vet[i+1])
Non ci sono altre modifiche da effettuare.
2
/* Ricerca di un valore in una matrice */
#include <stdio.h>
#define N 10
#define M 10
char alfa[N][M];
int main(void)
{
int n, m, i, j, k;
char ric;
/* Richiesta delle dimensioni */
do {
printf("Numero di linee: ");
scanf("%d", &n);
}
while((n>=N) || (n<1));
do {
printf("Numero di colonne: ");
scanf("%d", &m);
}
while((m>=M) || (m<1));
printf("\n \n CARICAMENTO DELLA MATRICE \n \n");
for(i=0; i<n; i++)
for(j=0; j<m; j++) {
printf("Ins.carattere nella linea %d colonna %d val:", i, j);
scanf("%1s", &alfa[i][j]);
};
/* Richiesta del carattere da ricercare */
printf("\n \n Carattere da ricercare: ");
scanf("%1s", &ric);
printf("\n \n VISUALIZZAZIONE DELLA MATRICE \n ");
for(i=0; i<n; i++) {
printf("\n");
for(j = 0; j < m; j++)
printf("%3c", alfa[i][j]);
}
printf("\n\n");
/* Ricerca del carattere all'interno della matrice */
k = 0;
for(i=0; i<n; i++)
for(j=0; j<m; j++) {
if(alfa[i][j]==ric) {
printf("%c in linea %d colonna %d\n", ric, i+1, j+1);
k = 1;
}
};
if(k==0) printf("%c non presente nella matrice", ric);
}
A.Bellini, A.Guidi,
Esempio di esecuzione:
Carattere da ricercare: a
VISUALIZZAZIONE DELLA MATRICE
t b a
m d g
a k k
d a m
v f g
a in linea 1 colonna 3
A.Bellini, A.Guidi,
Caso di Studio I
1
Si deve inserire in gestioneSequenza, dopo le dichiarazioni delle variabili e prima dell’inizio del ciclo di gestione
delle scelte dell’utente la chiamata della funzione immissione.
n = immissione();
2
#include <stdio.h>
void gestioneMenu(void);
int main(void)
{
gestioneMenu();
}
void gestioneMenu()
{
int n;
int scelta = 'z';
char invio;
int ele, posizione;
while(scelta != 'x') {
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
printf("\t\t\t BORRI & BIANCHI SpA");
printf("\n\t\t Sistema per la gestione integrata");
printf("\n\t\t\t OPZIONI DISPONIBILI");
printf("\n\n\n\t\t\t a. Magazzino");
printf("\n\t\t\t b. Clienti");
printf("\n\t\t\t c. Fornitori");
printf("\n\t\t\t x. Fine");
printf("\n\n\n\t\t\t\t Scegliere una opzione: ");
scanf("%c", &scelta);
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
switch(scelta) {
case 'a': printf("Hai scelto a");
printf("\n\n Premere Invio per continuare...");
break;
case 'b': printf("Hai scelto b");
break;
case 'c': printf("Hai scelto c");
break;
}
}
printf("Hai scelto x");
}
A.Bellini, A.Guidi,
3
Vanno effettuate due modifiche nelle funzioni di ordinamento e di ricerca binaria.
void ordinamento(int n)
{
int i, p, k, n1;
int aux;
p = n; n1 = p;
do {
k = 0;
for(i = 0; i < n1-1; i++)
if(vet[i] < vet[i+1]) {
aux = vet[i]; vet[i] = vet[i+1];
vet[i+1] = aux;
k = 1; p = i + 1;
}
n1 = p;
}
while (k == 1 && n1>1);
}
/* ricerca binaria */
int ricBin(int n, int ele)
{
int i, alto, basso, pos;
alto = 0; basso = n - 1; pos = -1;

do {
i = (alto+basso)/2;
if(vet[i] == ele) pos = i;
else if(vet[i] > ele) alto = i + 1;
else basso = i - 1;
}
while(alto <= basso && pos == -1);
return(pos);
}
4 e 5
La funzione di ricerca sequenziale non restituisce la posizione dell’elemento e non ha la necessità di prendere in
ingresso il valore da ricercare.
void ricerca(int);
La chiamata alla funzione di ricerca sequenziale diventa:
case 3: ricerca(n);
La funzione di ricerca sequenziale diventa:
/* Ricerca sequenziale */
void ricerca (int n)
{
int i, ele;
char invio;
i = 0;
printf("Elemento da ricercare: ");
scanf("%d", &ele);
while (ele != vet[i] && i < n-1) ++i;
if(ele == vet[i])
A.Bellini, A.Guidi,
printf("\nElem. %d presente in posizione %d\n", ele, i);
else
printf("\nElemento non presente!\n");
}
Modifiche analoghe devono essere apportate per la ricerca binaria.
6
#include <stdio.h>

int vet[MAX_ELE]; /* array che ospita la sequenza */
void gestioneSequenza(void);
int immissione(void);
void ordinamento(void);
int ricerca(void);
int ricBin(void);
void visualizzazione(void);
int n, ele;
int main(void)
{
gestioneSequenza();
}
void gestioneSequenza()
{
int scelta = -1;
char invio;
int posizione;
while(scelta != 0) {
printf("\t\t\t GESTIONE SEQUENZA");
printf("\n\n\n\t\t\t 1. Immissione");
printf("\n\n\t\t\t 2. Ordinamento");
printf("\n\n\t\t\t 3. Ricerca completa");
printf("\n\n\t\t\t 4. Ricerca binaria");
printf("\n\n\t\t\t 5. Visualizzazione");
printf("\n\n\t\t\t 0. Fine");
scanf("%d", &scelta);
switch(scelta) {
case 1: n = immissione();
break;
case 2: ordinamento();
break;
case 3: printf("Elemento da ricercare: ");
scanf("%d", &ele);
posizione = ricerca();
if(ele == vet[posizione])
A.Bellini, A.Guidi,
printf("\nElem. %d presente in posizione %d\n",
ele, posizione);
else
break;
scanf("%d", &ele);
posizione = ricBin();
if(posizione != -1)
ele, posizione);
else
break;
case 5: visualizzazione();
break;
}
}
}
int immissione()
{
int i, n;
do {
scanf("%d", &n);
}
while (n < 1 || n > MAX_ELE);
for(i = 0; i < n; i++) {

printf("\nImmettere un intero n.%d: ",i);
scanf("%d", &vet[i]);
}
return(n);
}
void ordinamento()
{
int i, p, k, n1;
int aux;
p = n; n1 = p;
do {
k = 0;
for(i = 0; i < n1-1; i++)
if(vet[i] > vet[i+1]) {
vet[i+1] = aux;
k = 1; p = i + 1;
}
n1 = p;
}
while (k == 1 && n1>1);
}
A.Bellini, A.Guidi,
int ricerca ()
{
int i;
i = 0;

return(i);
}
int ricBin()
{
alto = 0; basso = n - 1; pos = -1;

do {
i = (alto+basso)/2;
else if(vet[i] < ele) alto = i + 1;
else basso = i - 1;
}
return(pos);
}
void visualizzazione()
{
int i;
char invio;
for(i = 0; i < n; i++)

printf("\n%d", vet[i]);
}
8
int immissione()
{
int i, n;
do {
printf("\nNumero elementi (si accettano solo numeri pari): ");
scanf("%d", &n);
}
while (n < 1 || (n%2)!=0 || n > MAX_ELE);
for(i = 0; i < n; i++) {

printf("\nImmettere un intero n: %d: ",i);
}
return(n);
}
A.Bellini, A.Guidi,
9
int immissione()
{
int i, n;
do {
scanf("%d", &n);
}
for(i = 0; i < n; i++) {

do {
printf("\nImmettere un intero n (nell'intervallo -20 +100): %d: ",i);
}
while(vet[i]<-20 || vet[i]>100);
}
return(n);
}
A.Bellini, A.Guidi,
Capitolo 13
3
/* Concatenazione di dei primi n caratteri di una stringa
su di un'altra con strcat */
#include <stdio.h>
#include <string.h>
char frase[160] = "Analisi, requisiti";
int main(void)
{
char dimmi[80];
int i;
for(i=0; ((dimmi[i]=getchar())!='\n') && (i<80); i++)
;
dimmi[i] = '\0';
strncat(frase, dimmi, 5);
printf("%s \n", frase);
}
4
/* Confronto dei primi n caratteri di due stringhe con strncmp */
#include <stdio.h>
#include <string.h>
char prima[160] = "Analisi, requisiti";
int main(void)
{
char seconda[80];
int i, x;
for(i=0; ((seconda[i]=getchar())!='\n') && (i<80); i++)
;
seconda[i]='\0';
if((x=(strncmp(prima, seconda, 5)))==0)
printf("Sono uguali\n");
else
if(x>0)
printf("La prima e' maggiore della seconda\n");
else
printf("La seconda e' maggiore della prima\n");
}
A.Bellini, A.Guidi,
Capitolo 14
1
/* Scansione e visualizzazione di un array di interi */
#include <stdio.h>
int a[5] = { 1, 2, 3, 4, 5 };
int main(void)
{
int i, *p;
p = a;
printf("Gli elementi del vettore sono:\n\n");
for (i = 0; i <= 4; i++)
printf("a[%d] = %d\n", i, *p++);
}
2
/* Scansione e visualizzazione di un array di stringhe */
#include <stdio.h>
char *vet[] = {"Messaggio #1\n",
"Messaggio #2\n",
"Messaggio #3\n",
"Messaggio #4\n",
"Messaggio #5\n",
NULL
};
char **p = vet;
int main(void)
{
while(*p != NULL)
printf("%s", *p++);
}
3
/* Funzione che ritorna il puntatore alla prima occorrenza
della stringa t in s */
char *strInStr(char *s, char *t)
{
char *v;
while(*s != '\0') {
if(*s == *t)
for(v = t; *s == *v;) {
if(*++v == '\0')
return(s(vt)+1);
if(*s++ == '\0')
return(NULL);
}
else
s++;
}
return(NULL);
}
4
/* versione 1 che usa gli array*/
A.Bellini, A.Guidi,
strcop( char s[], char t[])
{
int i=0;
while ((s[i] = t[i]) != '\0') i++;
}
/*versione 1.1 che usa i puntatori*/
strcop(char *s, char *t)
{
while ((*s = *t) != '\0')
{s++; t++;}
}
/* versione 2 */
{
while ((*s++ = *t++) != '\0') ;
}
/* versione 3 */
{
while (*s++ = *t++);
}
La migliore è la versione 3, anche se abbastanza criptica al primo impatto.
5
#include <stdio.h>
#include <malloc.h>
int main(void)
{
char *s;
int n;
printf("Inserire dimensione del buffer : ");
scanf("%d", &n);
s = (char*) malloc(n+1);
...
}
6
/* Esempio di uso di memcpy */
#include <stdio.h>
#include <string.h>
int main ()
{
char cifre[]="1234567890";
char decimali[10];
char pausa;
memcpy (decimali, cifre, 4);
decimali[4]='\0';
printf ("decimali: %s\n", decimali);
scanf("&c", pausa);
}
Se non si inserisce nella giusta posizione il carattere di fine stringa:

A.Bellini, A.Guidi,
decimali[4]='\0';
l’istruzione
printf ("decimali: %s\n", decimali);
visualizza ulteriori caratteri dopo 1234. Vediamo una soluzione alternativa.
/* II Esempio di uso di memcpy */

#include <stdio.h>
#include <string.h>
int main ()
{
char cifre[]="1234567890";
char decimali[10];
char pausa; int i;
memcpy (decimali, cifre, 4);
printf ("decimali: ");
for(i=0;i<4;i++)
printf ("%c", decimali[i]);
printf ("\n");
scanf("&c", pausa);
}
7
/* Esempio di uso di memmove */
#include <stdio.h>
#include <string.h>
int main ()
{
char y[100]= "1234567890";
char pausa;
printf ("Prima: %s\n", y);
memmove(y+4, y, 4);
printf ("Dopo: %s\n", y);
scanf("&c", pausa);
}
8
/* Esempio di uso di memcmp */
#include <stdio.h>
#include <string.h>
int main ()
{
char uno[]= "santo";
char due[]= "santi";
int r;
char pausa;
r=memcmp(uno, due, strlen(uno));
if(r>0)
printf ("%s maggiore di %s", uno, due);
else
printf ("%s maggiore di %s", due, uno);
scanf("&c", pausa);
}
A.Bellini, A.Guidi,
9
/* Esempio di uso di memchr */
#include <stdio.h>
#include <string.h>
int main ()
{
char numero[]= "1 2 3";
char cifra = '2';
char pausa;
char * p;
p = (char*) memchr(numero, cifra, strlen(numero));
if(p != NULL)
printf ("%c presente in %s in posizione %d", cifra, numero, pnumero+1);
else
printf ("%c non presente in %s", cifra, numero);
scanf("&c", pausa);
}
L’istruzione:
p = (char*) memchr(numero, cifra, strlen(numero));
effttua un cast, cioè una confersione del valore restituito da memchr in un puntatore a char come si vedrà nei capitoli
successivi.
10
/* Esempio di uso di memset */
#include <stdio.h>
#include <string.h>
int main ()
{
char cifre[]="1234567890";
char cifra = '9';
char pausa;
char * p;
printf ("Prima: %s\n", cifre);
memset(cifre, cifra, 2);
printf ("Dopo: %s", cifre);
scanf("&c", pausa);
}
A.Bellini, A.Guidi,
Caso di studio II
1
/* Fusione di due sequenze ordinate */
#include <stdio.h>
#define MAX_ELE 1000
int immissione(int *);

void ordinamento(int, int *);
void visualizzazione(int, int *);
void merge(int, int *, int, int *, int *);
int main(void)
{
int vet1[MAX_ELE]; /* prima sequenza */
int vet2[MAX_ELE]; /* seconda sequenza */
int vet3[MAX_ELE*2]; /* merge */
int n; /* lunghezza prima sequenza */

int m; /* lunghezza seconda sequenza */
n = immissione(vet1);
m = immissione(vet2);
ordinamento(n, vet1);
ordinamento(m, vet2);
merge(n, vet1, m, vet2, vet3);
visualizzazione(n, vet1);
visualizzazione(m, vet2);
visualizzazione(n+m, vet3);
}
int immissione(int *vet)

{
int i, n;
do {
scanf("%d", &n);
}
for(i = 0; i < n; i++) {

}
return(n);
}
void ordinamento(int n, int *vet)

{
int i, p, k, n1;
int aux;
p = n; n1 = p;
do {
k = 0;
for(i = 0; i < n1-1; i++)
vet[i+1] = aux;
k = 1; p = i + 1;
A.Bellini, A.Guidi,
}
n1 = p;
}
while (k == 1 && n1>1);
}
void visualizzazione( int n, int *vet)

{
int i;
char invio;
for(i = 0; i < n; i++)

}
/* Fusione delle due sequenze (merge) */

void merge( int n, int *vet1, int m, int *vet2, int *vet3)
{
int i = 0, j = 0, k = 0;
do {
if(vet1[i]<=vet2[j])
vet3[k++] = vet1[i++];
else
vet3[k++] = vet2[j++];
}
while(i<n && j<m);
if(i<n)
for(; i<n; vet3[k++] = vet1[i++])
;
else
for(; j<m; vet3[k++] = vet2[j++])
;
}
2
/* Fusione di piu’ sequenze ordinate */
#include <stdio.h>
#define MAX_ELE 1000

void merge(int, int *, int, int *, int *);
int main(void)
{
int vet1[MAX_ELE]; /* prima sequenza */
int vet2[MAX_ELE]; /* seconda sequenza */
int vet3[MAX_ELE*2]; /* altri merge */
int n; /* lunghezza prima sequenza */

int m; /* lunghezza seconda sequenza */
int i, altroVettore;
m = immissione(vet2);
A.Bellini, A.Guidi,
ordinamento(m, vet2);
do {
m = n+m;
for(i = 0; i < m; i++) vet2[i] = vet3[i];
printf("\nSe vuoi immettere un altro vettore scrivi 1 altrimeni 0: ",
altroVettore);
scanf("%d", &altroVettore);
}
while (altroVettore > 0);

{
int i, n;
do {
scanf("%d", &n);
}
for(i = 0; i < n; i++) {

}
return(n);
}

{
int i, p, k, n1;
int aux;
p = n; n1 = p;
do {
k = 0;
for(i = 0; i < n1-1; i++)
vet[i+1] = aux;
k = 1; p = i + 1;
}
n1 = p;
}
while (k == 1 && n1>1);
}

{
int i;
char invio;
A.Bellini, A.Guidi,
for(i = 0; i < n; i++)

}
/* Fusione delle due sequenze (merge) */

void merge( int n, int *vet1, int m, int *vet2, int *vet3)
{
int i = 0, j = 0, k = 0;
do {
if(vet1[i]<=vet2[j])
vet3[k++] = vet1[i++];
else
vet3[k++] = vet2[j++];
}
while(i<n && j<m);
if(i<n)
for(; i<n; vet3[k++] = vet1[i++])
;
else
for(; j<m; vet3[k++] = vet2[j++])
;
}
3
/* Modifica del programma di gestione seguenza del caso di
Studio II, per impedire la ricerca binaria nel caso che
la sequenza non sia stata ancora ordinata. */
#include <stdio.h>
void gestioneSequenza(void);
int ricerca(int, int , int *);
int ricBin(int, int , int *);
int ordinato = 0;
int main(void)
{
gestioneSequenza();
}
void gestioneSequenza()
{
int sequenza[MAX_ELE]; /* array che ospita la sequenza */
int n;
int scelta = -1;
char invio;
int ele, posizione;
while(scelta != 0) {
A.Bellini, A.Guidi,
printf("\t\t\t GESTIONE SEQUENZA");
printf("\n\n\n\t\t\t 1. Immissione");
printf("\n\n\t\t\t 2. Ordinamento");
printf("\n\n\t\t\t 3. Ricerca completa");
printf("\n\n\t\t\t 4. Ricerca binaria");
printf("\n\n\t\t\t 5. Visualizzazione");
printf("\n\n\t\t\t 0. fine");
switch(scelta) {
case 1: n = immissione(sequenza);
break;
case 2: ordinamento(n, sequenza);
break;
scanf("%d", &ele);
posizione = ricerca(n, ele, sequenza);
if(ele == sequenza[posizione])
ele, posizione);
else
break;
case 4: if (ordinato == 0)
printf("\Ricerca binaria non applicabile! \n");
printf("\nL’arrai deve essere ordinato. \n");
else {
printf("Elemento da ricercare: ");
scanf("%d", &ele);
posizione = ricBin(n, ele, sequenza);
if(posizione != -1)
ele, posizione);
else
}
break;
case 5: visualizzazione(n, sequenza);
break;
}
}
}

{
int i, n;
ordinato = 0;
do {
A.Bellini, A.Guidi,
scanf("%d", &n);
}
for(i = 0; i < n; i++) {

}
return(n);
}

{
int i, p, k, n1;
int aux;
p = n; n1 = p;
do {
k = 0;
for(i = 0; i < n1-1; i++)
vet[i+1] = aux;
k = 1; p = i + 1;
}
n1 = p;
}
while (k == 1 && n1>1);
ordinato = 1;
}
int ricerca(int n, int ele, int *vet)
{
int i;
i = 0;

return(i);
}
int ricBin(int n, int ele, int *vet)
{
alto = 0; basso = n - 1; pos = -1;
do {
i = (alto+basso)/2;
else if(vet[i] < ele) alto = i + 1;
else basso = i - 1;
}
return(pos);
}
A.Bellini, A.Guidi,

{
int i;
char invio;
for(i = 0; i < n; i++)

}
4
La soluzione che diamo esegue quanto richiesto dal problema: creazione e uso delle funzioni di immissione di matrici,
calcolo della matrice prodotto e visualizzazione delle matrici. In questo modo si osserva il riuso delle funzioni su
matrici diverse e il passaggio del parametro array bidimensionale.
La soluzione non è però completa in quanto non presenta il menu per porter ripetere l’immissione delle matrici. La
gestione del menu viene presentata in numerosissimi esercizi e soluzioni del libro e in questo caso la lasciamo al lettore.
/* Calcolo del prodotto di due matrici

con l'uso di funzioni */
#include <stdio.h>
#define MAX_ELE 10
#define N MAX_ELE
#define P MAX_ELE
#define M MAX_ELE
void immissioneMatrice(int, int, int [MAX_ELE][MAX_ELE]);

void prodottoMatrici(int, int, int, int [MAX_ELE][MAX_ELE], int [MAX_ELE]
[MAX_ELE], int [MAX_ELE][MAX_ELE]);
void visualizzazioneMatrice(int, int, int [MAX_ELE][MAX_ELE]);
int main(void)
{
int mat1[N][P]; /* prima matrice */
int mat2[P][M]; /* seconda matrice */
int pmat[N][M]; /* matrice prodotto */
int n, m, p;
char invio;
do {
printf("\nNumero di righe prima matrice: ");
scanf("%d", &n);
}
do {
printf("\nNumero di colonne prima matrice / righe della seconda: ");
scanf("%d", &p);
}
while (p < 1 || p > MAX_ELE);
do {
A.Bellini, A.Guidi,
printf("\nNumero di colonne della seconda matrice: ");
scanf("%d", &m);
}
while (m < 1 || m > MAX_ELE);
immissioneMatrice(n, p, mat1);
immissioneMatrice(p, m, mat2);
prodottoMatrici(n, m, p, mat1, mat2, pmat);
visualizzazioneMatrice(n, p, mat1);
visualizzazioneMatrice(p, m, mat2);
visualizzazioneMatrice(n, m, pmat);
}
void immissioneMatrice(int righe, int colonne, int mat[MAX_ELE][MAX_ELE])

{
int i, j;
printf("\n \n CARICAMENTO MATRICE \n \n");
for(i=0; i<righe; i++)
for(j=0; j<colonne; j++) {
printf("Inserisci linea %d colonna %d val:", i, j);
scanf("%d", &mat[i][j]);
};
}
void prodottoMatrici(int n, int m, int p, int mat1[MAX_ELE][MAX_ELE], int

mat2[MAX_ELE][MAX_ELE], int pmat[MAX_ELE][MAX_ELE])
{
int i = 0, j = 0, k = 0;
for(i=0; i<n; i++)
for(j=0; j<m; j++) {
pmat[i][j] = 0;
for(k=0; k<p; k++)
pmat[i][j] = pmat[i][j] + mat1[i][k] * mat2[k][j];
};
}
void visualizzazioneMatrice(int righe, int colonne, int mat[MAX_ELE][MAX_ELE])

{
int i, j;
printf("\n \n VISUALIZZA MATRICE \n ");
for(i=0; i<righe; i++) {
printf("\n");
for(j=0; j<colonne; j++)
printf("%5d", mat[i][j]);
}
}
5
Come per il precedente esercizio la soluzione che riportiamo non presenta il menu per porter ripetere l’immissione della
matrice e la ricerca di un elemento che lasciamo al lettore.
/* Ricerca di un elemento in una matrice bidimensionale con l'uso di funzioni */

#include <stdio.h>
#define MAX_ELE 10
A.Bellini, A.Guidi,
#define N MAX_ELE
#define M MAX_ELE
void immissioneMatrice(int, int, int [MAX_ELE][MAX_ELE]);

void ricercaElementoNellaMatrice(int, int, int [MAX_ELE][MAX_ELE]);
void visualizzazioneMatrice(int, int, int [MAX_ELE][MAX_ELE]);
int main(void)
{
int mat1[N][M]; /* prima matrice */
int n, m;
char invio;
do {
printf("\nNumero di righe: ");
scanf("%d", &n);
}
do {
scanf("%d", &m);
}
while (m < 1 || m > MAX_ELE);
immissioneMatrice(n, m, mat1);
ricercaElementoNellaMatrice(n, m, mat1);
visualizzazioneMatrice(n, m, mat1);
}
void immissioneMatrice(int righe, int colonne, int mat[MAX_ELE][MAX_ELE])

{
int i, j;
printf("\n \n CARICAMENTO MATRICE \n \n");
for(i=0; i<righe; i++)
for(j=0; j<colonne; j++) {
printf("Inserisci linea %d colonna %d val:", i, j);
scanf("%d", &mat[i][j]);
};
}
void ricercaElementoNellaMatrice(int n, int m, int mat[MAX_ELE][MAX_ELE])

{
int i = 0, j = 0, ele, trovato;
printf("\nElemento da ricercare: ");
scanf("%d", &ele);
trovato=0;
for(i=0; i<n; i++)
for(j=0; j<m; j++)
if(mat[i][j] == ele) trovato = 1;
if(trovato == 1)
printf("\nElemento presente nella matrice");
else
A.Bellini, A.Guidi,
printf("\nElemento NON presente nella matrice");
}
void visualizzazioneMatrice(int righe, int colonne, int mat[MAX_ELE][MAX_ELE])

{
int i, j;
printf("\n \n VISUALIZZA MATRICE \n ");
for(i=0; i<righe; i++) {
printf("\n");
for(j=0; j<colonne; j++)
printf("%5d", mat[i][j]);
}
}
7
La funzione viene così dichiarata:
void immissione(int *, int *);
Il primo parametro è il puntatore alla variabile n di gestioneSequenza dove immissione memorizzerà,
mediante il puntatore pn, la lunghezza della sequenza.
void immissione(int *pn, int *vet)
{
int i, n;
char invio;
do {
scanf("%d", &n);
}
for(i = 0; i < n; i++) {
}
*pn = n;
}
A.Bellini, A.Guidi,
Capitolo 15
3
/* Calcolo della potenza di base elevata a esponente dove
esponente e' un numero maggiore uguale a zero */
#include <stdio.h>
double potenza(float, int);
int main(void)
{
float b; int e;
printf("\n\n Calcolo della potenza \n\n");
printf("Inser. base: \t");
scanf("%f", &b);
printf("Inser. esponente: \t");
scanf("%d", &e);
printf("Potenza: %lf\n", potenza(b, e));
}
/* Funzione per il calcolo di base elevata a esp con esp>=0 */
double potenza(float base, int esp)
{
double pot = 1;
if(esp==0) return(1); /* caso
esponente uguale a zero */
if(esp>0) { /* calcolo della potenza */
do
pot = pot*base; /* base*base*base... esp volte */
while(esp>0);
}
return(pot);
}
5
/* Funzione per il calcolo di base elevata a esp.
esp può essere un intero qualsiasi */
{
int s = 1;
double pot = 1; /* inizializzazione di pot a 1 caso
di esponente uguale a zero */
if(esp<0) { /* l'esponente è negativo? */
esp = abs(esp);
s = 0;
}
if(esp>0) { /* calcolo della potenza */
do
pot = pot*base; /* b*b*b... n volte */
while(esp>0);
}
if(s) return(pot); /* l'esponente è positivo? */
else return(1/pot);
}
Per utilizzare la funzione abs si deve aver inclusa la libreria stdlib.h.
6
/* Funzione ricorsiva per il calcolo di base elevata a esp.
A.Bellini, A.Guidi,
esp può essere un intero qualsiasi */
{
if(esp==0)
return(1);
else
if(esp<0)
return(1/potenza(base, esp));
else
return(base*potenza(base, esp1));
}
7
/* Massimo comune divisore di due interi positivi */
#include <stdio.h>
int mcd(int, int);
int main(void)
{
int t, k;
printf("\n\n Calcolo del massimo
comune divisore \n\n");
printf("Inser. t: \t");
scanf("%d", &t);
printf("Inser. k: \t");
scanf("%d", &k);
printf("Massimo comune divisore:
%d\n", mcd(t, k));
}
/* Funzione ricorsiva per il calcolo del massimo comune divisore */
int mcd(int t, int k)
{
if(k==0)
return(t);
else
if(k>t)
return(mcd(k, t));
else
return(mcd(k, t%k));
}
A.Bellini, A.Guidi,
Capitolo 16
1
Di seguito alcuni esempi di struttura che modellano le entità richieste nell’esercizio, naturlamente le strutture realmente
utilizzate dipendono dal problema e in generalo saranno molto più ampie.
a
struct studente {
char matricola[10];
char corsoDiStudi[10];
char nome[30];
char cognome[30];
int giornoNascita;
char meseNascita[20];
int annoNascita;
char comuneNascita[30];
char cittaResidenza[20];
char viaResidenza[35];
int numeroResidenza;
char internoResidenza[10];
char provinciaResidenza;
char cittaDomicilio[20];
char viaDomicilio[35];
int numeroDomicilio;
char internoDomicilio[10];
char provinciaDomicilio;
char telefono[10];
};
b
struct professore {
char matricola[10];
char laurea[10];
char specializzazione[10];
char abilitazione[10];
char nome[30];
char cognome[30];
int giornoNascita;
int annoNascita;
char telefono[10];
};
c
struct personaComputer {
char marca[20];
char modello[30];
char processore[10];
int numeroProcessori;
A.Bellini, A.Guidi,
int dimensioneMemoria;
char schedaVideo[30];
char tipoSchermo[10];
int numeroPorteUSB;
char schedaDiRete[30];
char tipoDriverDVD[10];
};
Vediamo come verrebbe modificata la definizione di studente e professore, mentre lasciamo al lettore un’eventuale
modifica nel senso richiesto della definizione di personal computer.
struct data {
int giorno;
char mese [20];
int anno;
};
struct ind {
char via[35];
int numero;
char interno
char citta[30];
char prov[2];
};
a
struct studente {
char matricola[10];
char corsoDiStudi[10];
char nome[30];
char cognome[30];
int giornoNascita;
int annoNascita;
char telefono[10];
};
b
struct professore {
char matricola[10];
char laurea[10];
char specializzazione[10];
char abilitazione[10];
char nome[30];
char cognome[30];
struct data dataNasc;
A.Bellini, A.Guidi,
struct indResidenza indirizzo;
struct indDomicilio indirizzo;
char telefono[10];
};
3
/* Gestionde di una lista di automobili */
#include <stdio.h>
#include <string.h>
#define MAXELE 30
#define DIM 50
#define MENU 0
#define INS 1
#define VIS 4
#define OUT 100
struct automobile {
char marca[DIM];
char modello[DIM];
int venduto;
};
/* Vettore auto */
automobile listaAuto[MAXELE];
/* Numero elementi allocati nel vettore auto */

int index = 0;
int menAutomobile(void);
int insAutomobile(int);
void visAutomobile(struct automobile *);
void visAuto(void);
/* Presenta il menu e lancia la funzione scelta */

int main(void)
{
int scelta = MENU;
while(scelta!=OUT) {
switch(scelta) {
case MENU:
scelta = menAutomobile();
if(scelta == MENU)
scelta = OUT;
break;
case INS:
index = insAutomobile(index);
scelta = MENU;
break;
case VIS:
visAuto();
scelta = MENU;
break;}
}
}
/* Menu */
int menAutomobile(void)
A.Bellini, A.Guidi,
{
int scelta;
char invio;
int vero = 1;
while(vero){
printf("\t\t\t Auto");
printf("\n\n\n\t\t\t 1. Immissione Automobile");
printf("\n\n\t\t\t 4. Visualizza Automobili");
switch(scelta) {
case 0:
case 1:
case 4:
return(scelta);
default:
break;
}
}
return(0);
}
/* Inserisce un automobile nella lista della auto */

int insAutomobile(int pos)
{
char invio;
if(pos>=MAXELE) {
printf(" Non si possono inserire altre auto");
return(pos);
}
printf("\n\t\tINSERIMENTO AUTOMOBILE");
printf("\n\t\t---------------\n\n");
printf("\nMarca : ");
gets_s(listaAuto[pos].marca, DIM);
printf("\nModello : ");
gets_s(listaAuto[pos].modello, DIM);
printf("\nVenduto : ");
scanf("%d", &listaAuto[pos].venduto);
pos++;
return(pos);
}
/* Visualizza automobile */
void visAutomobile(struct automobile *p)
{
printf("\n\n--------------------\n");
printf("\n\t\tMarca : %s", p->marca);
printf("\n\t\tModello : %s", p->modello);
printf("\n\t\tVenduto : %d", p->venduto);
printf("\n\n--------------------\n");
}
A.Bellini, A.Guidi,
/* Visualizza lista auto */
void visAuto(void)
{
int i; char pausa;
struct automobile *ps = &listaAuto[0];
for (i=0; i<index; i++) {
visAutomobile(ps++);
}
}
4
/* Modifica alla gestione di una lista di automobili */
#include <stdio.h>
#include <string.h>
#define MAXELE 30
#define DIM 50
#define MENU 0
#define INS 1
#define VIS 4
#define OUT 100
struct modello {
char codice[DIM];
char descrizione[100];
int anno;
};
struct automobile {
char marca[DIM];
struct modello mod;
int venduto;
};
/* Vettore auto */
automobile listaAuto[MAXELE];
/* Numero elementi allocati nel vettore auto */

int index = 0;
int menAutomobile(void);
int insAutomobile(int);
void visAutomobile(struct automobile *);
void visAuto(void);

int main(void)
{
int scelta = MENU;
switch(scelta) {
case MENU:
scelta = menAutomobile();
if(scelta == MENU)
scelta = OUT;
A.Bellini, A.Guidi,
break;
case INS:
index = insAutomobile(index);
scelta = MENU;
break;
case VIS:
visAuto();
scelta = MENU;
break;}
}
}
/* Menu */
int menAutomobile(void)
{
int scelta;
char invio;
int vero = 1;
while(vero){
printf("\t\t\t Auto");
printf("\n\n\n\t\t\t 1. Immissione Automobile");
printf("\n\n\t\t\t 4. Visualizza Automobili");
switch(scelta) {
case 0:
case 1:
case 4:
return(scelta);
default:
break;
}
}
return(0);
}
/* Inserisce un automobile nella lista della auto */

int insAutomobile(int pos)
{
char invio;
if(pos>=MAXELE) {
printf(" Non si possono inserire altre auto");
return(pos);
}
printf("\n\t\tINSERIMENTO AUTOMOBILE");
printf("\n\t\t---------------\n\n");
printf("\nMarca : ");
gets_s(listaAuto[pos].marca, DIM);
printf("\nCodice Modello : ");

gets_s(listaAuto[pos].mod.codice, DIM);
printf("\nDescrizione Modello : ");
gets_s(listaAuto[pos].mod.descrizione, DIM);
printf("\nAnno : ");
A.Bellini, A.Guidi,
scanf("%d", &listaAuto[pos].mod.anno);
printf("\nVenduto : ");
scanf("%d", &listaAuto[pos].venduto);
pos++;
return(pos);
}
/* Visualizza automobile */
void visAutomobile(struct automobile *p)
{
printf("\n\n--------------------\n");
printf("\n\t\tMarca : %s", p->marca);
printf("\n\t\tModello : %s", p->mod.codice);

printf("\n\t\tModello : %s", p->mod.descrizione);
printf("\n\t\tModello : %d", p->mod.anno);
printf("\n\t\tVenduto : %d", p->venduto);

printf("\n\n--------------------\n");
}
/* Visualizza lista auto */

void visAuto(void)
{
int i; char pausa;
struct automobile *ps = &listaAuto[0];
visAutomobile(ps++);
}
}
5
/* Gestionde di una libro */
#include <stdio.h>
#include <string.h>
#define DIM 50
struct libro {
char titolo[DIM];
char autore[DIM];
char editore[DIM];
int anno;
char isbn[20];
float prezzo;
};
void insLibro(struct libro *);

void visLibro(struct libro *);
int main(void)
{
struct libro *l1;
A.Bellini, A.Guidi,
struct libro testo;
l1 = &testo;
insLibro(l1);
visLibro(l1);
}
/* Inserisce un libro */
void insLibro(struct libro *p)
{
char invio;
printf("\n\t\tINSERIMENTO LIBRO");
printf("\n\t\t-------------------\n\n");
printf("\nTitolo : ");
gets_s(p->titolo, DIM);
printf("\nAutore : ");
gets_s(p->autore, DIM);
printf("\nEditore : ");
gets_s(p->editore, DIM);
printf("\nAnno di Edizione: ");
scanf("%d", &p->anno);
printf("\nISBN : ");
gets_s(p->isbn, 20);
printf("\nPrezzo: ");
scanf("%f", &p->prezzo);
}
/* Visualizza un libro */
void visLibro(struct libro *p)
{
char pausa;
printf("\n\n--------------------\n");
printf("\n\t\tTitolo : %s", p->titolo);
printf("\n\t\tAutore : %s", p->autore);
printf("\n\t\tEditore : %s", p->editore);
printf("\n\t\tAnno di Edizione : %d", p->anno);
printf("\n\t\tISBN : %s", p->isbn);
printf("\n\t\tPrezzo : %f", p->prezzo);
printf("\n\n--------------------\n");
}
A.Bellini, A.Guidi,
Caso di Studio III

4
Nel Listato del Caso di Studio III è stata aggiunta la define:
#define INSMUL 5
E’ stato essere modificato il main aggiungendo la nuova opzione per la gestione del caso d’inserimento multiplo di
persone. Sono state dichiarate due varibili nuove: i e numeroElmenti.
case INSMUL:
printf("Quanti elementi desidera immettere: ");
scanf("%d", &numeroElementi);
i = 1;
while(i++ <= numeroElementi) insPer();
scelta = MENU;
break;
E’ stata aggiunta nella funzione menPer la visualizzazione del nuovo caso:
printf("\n\n\t\t\t 5. Inserimento multiplo");

#include <stdio.h>
#include <string.h>
#define MAXELE 30
#define DIM 31
#define MENU 0
#define INS 1
#define CAN 2
#define RIC 3
#define VIS 4
#define INSMUL 5
#define OUT 100
/* Semplice struttura che modella una persona */

struct per {
char cognome[DIM];
char nome[DIM];
char ind[DIM];
int eta;
};
/* Vettore persone */
struct per anag[MAXELE];
/* Numero elementi allocati nel vettore anag */

int index = 0;
int menPer(void);
int insPer(int);
struct per * cerPer(char *, char *, int);
void eliPer(struct per *);
void canPer(void);
void ricPer(void);
void visPer(struct per *);
void visAnagrafe(void);

int main(void)
{
int scelta = MENU, i, numeroElementi;
char invio;
A.Bellini, A.Guidi,
switch(scelta) {
case MENU:
scelta = menPer();
if(scelta == MENU)
scelta = OUT;
break;
case INS:
index = insPer(index);
scelta = MENU;
break;
case CAN:
canPer();
scelta = MENU;
break;
case RIC:
ricPer();
scelta = MENU;
break;
case VIS:
visAnagrafe();
scelta = MENU;
break;
case INSMUL:
i = 1;
while(i++ <= numeroElementi) index = insPer(index);
scelta = MENU;
break;
}
}
}
/* Menu */
int menPer(void)
{
int scelta;
char invio;
int vero = 1;
while(vero){
printf("\t\t\t ANAGRAFE");
printf("\n\n\n\t\t\t 1. Immissione Persona");
printf("\n\n\t\t\t 2. Cancellazione Persona");
printf("\n\n\t\t\t 3. Ricerca Persona");
printf("\n\n\t\t\t 4. Visualizza anagrafe");
switch(scelta) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
return(scelta);
A.Bellini, A.Guidi,
default:
break;
}
}
return(0);
}
/* Inserisce persona nell'anagrafe */

int insPer(int pos)
{
char invio;
if(pos>=MAXELE) {
printf(" Non si possono inserire altri nomi");
return(pos);
}
printf("\n\t\tINSERIMENTO PERSONA");
printf("\n\t\t---------------\n\n");
printf("\nCognome : ");
gets_s(anag[pos].cognome);
printf("\nNome : ");
gets_s(anag[pos].nome, DIM);
printf("\nIndirizzo : ");
gets_s(anag[pos].ind, DIM);
printf("\nEta' : ");
scanf("%d", &anag[pos].eta);
pos++;
return(pos);
}
/* Cancella persona dall'anagrafe, se presente */

void canPer(void)
{
char pausa;
char cognome[DIM], nome[DIM];
int eta;
struct per *ps;
printf("\n\t\tCANCELLA PERSONA");
printf("\n\t\t------\n\n");
gets_s(cognome, DIM);
gets_s(nome, DIM);
scanf("%d", &eta);
/* invoca ricerca persona */
ps = cerPer(cognome, nome, eta);
if(ps == NULL) {
printf("\nPersona non presente in anagrafe");
return;
}
/* Invoca visualizza persona */
visPer(ps);
printf("\nConfermi cancellazione? (S/N) ");
if(pausa=='S' || pausa=='s') {
A.Bellini, A.Guidi,
eliPer(ps);
return;
}
}
/* Elimina persona dall'anagrafe */

void eliPer(struct per *p)
{
strcpy(p->cognome, "");
strcpy(p->nome, "");
strcpy(p->ind, "");
p->eta = 0;
}
/* Ricerca persona se presente nell'anagrafe */

void ricPer(void)
{
char pausa;
int eta;
struct per *ps;
/* Inserimento dati persona da ricercare */
printf("\n\t\tRICERCA PERSONA");
gets_s(nome, DIM);
scanf("%d", &eta);
/* invoca ricerca persona */
ps = cerPer(cognome, nome, eta);
if(ps == NULL) {
return;
}
visPer(ps);
}
/* Scansione sequenziale del vettore anag alla ricerca di

una persona che abbia determinati cognome, nome ed età */
struct per *cerPer(char *cg, char *nm, int et)
{
int i;
for(i=0; i<=index; i++) {
if(strcmp(cg, anag[i].cognome) == 0)
if(strcmp(nm, anag[i].nome) == 0)
if(et == anag[i].eta)
return(&anag[i]);
}
return(NULL);
}
/* Visualizza persona */
void visPer(struct per *p)
A.Bellini, A.Guidi,
{
printf("\n\n--------------------\n");
printf("\n\t\tCognome : %s", p->cognome);
printf("\n\t\tNome : %s", p->nome);
printf("\n\t\tIndirizzo : %s", p->ind);
printf("\n\t\tEta' : %d", p->eta);
printf("\n\n--------------------\n");
}
/* Visualizza l'anagrafe completa */

void visAnagrafe(void)
{
int i; char pausa;
struct per *ps = &anag[0];
visPer(ps++);
}
}
A.Bellini, A.Guidi,
Capitolo 17
1
L’istruzione
fp = fopen("c:\\autoexec.bat", "r");
apre il lettura il file autoexec.bat, per prendere in considerazione qualsiasi altro file è sufficiente sostituirne il
nome come parametro della funzione fopen.
/* Restituisce il contenuto del file autoexec.bat */
#include <stdio.h>
int main(void)
{
FILE *fp;
char buffer[81];
printf("\nIl file autoexec.bat contiene: ");
while(fgets(buffer, 80, fp) !=NULL)
printf(buffer);
fclose(fp);
}
2
/* Apre un file il cui nome e’ richiesto all’utente
e vi inserisce 80 caratteri */
#include <stdio.h>
char buffer[80] = "Prova d'uso... \n ...Questa e' la seconda riga.\n";
int main(void)
{
int numwrite;
FILE *fp;
char nomefile[80];
printf("Digitare il nome del file: ");
gets_s(nomefile, 16);
fp = fopen(nomefile, "w");
numwrite = fwrite(buffer, sizeof(char), 80, fp);
printf("%d caratteri scritti sul file %s\n", numwrite, nomefile);
printf("Controllare visualizzando il file con un editor\n");
printf("del sistema operativo in uso\n");
}
3
/* Apre un file il cui nome e’ richiesto all’utente
legge e rilegge la prima riga di 80 carattteri */
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *fp;
char nomefile[80], buffer[81];
printf("Digitare il nome del file:");
gets_s(nomefile, 80);
/* Apre il file */
if((fp = fopen(nomefile, "r")) == NULL){
A.Bellini, A.Guidi,
perror("Mancata apertura del file");
exit(1) ;
}
/* Legge e visualizza una riga */
fgets(buffer, 80, fp);
printf("La linea letta e' : %s", buffer);
/* Ora ritorna all'inizio e rilegge una riga*/
fseek(fp, 0L, 0);
fgets(buffer, 80, fp);
printf("La linea riletta e' : %s", buffer);
}
4
#include <stdio.h>
int main(void)
{
int i;
FILE *fp;
char sequenza[80];
/* Apre il file. Il simbolo di root \ si ottiene con il
doppio slash */
printf("Le prime 10 sequenze di
caratteri sono:\n");
for(i = 0; i < 10; i++) {
if (fscanf(fp, "%s", sequenza)
== EOF){
printf("Fine file!\n");
break;
}
else
printf("Sequenza %d =
\"%s\"\n", i, sequenza);
}
}
EOF è una costante di libreria che rappresenta la End Of File, cioè la fine del file.
A.Bellini, A.Guidi,
Caso di studio IV
4
Nel Listato del Caso di Studio IV è stata aggiunta la define:
#define INSMUL 5
E’ stato essere modificato il main aggiungendo la nuova opzione per la gestione del caso d’inserimento multiplo di
persone in anagrafe. Sono state dichiarate due varibili nuove: i e numeroElmenti.
case INSMUL:
i = 1;
scelta = MENU;
break;
E’ stata aggiunta nella funzione menPer la visualizzazione del nuovo caso:
#include <stdio.h>
#include <string.h>
#define DIM 31
#define MENU 0
#define INS 1
#define CAN 2
#define RIC 3
#define VIS 4
#define INSMUL 5
#define OUT 100
/* Semplice struttura che modella una persona */

struct per {
char cognome[DIM];
char nome[DIM];
char ind[DIM];
int eta;
};
/* Puntatore al file */
FILE *fp;
/* La variabile di appoggio anag per le operazioni sul file */

struct per anag;
int menPer(void);
void insPer(void);
void ricPer(void);
void canPer(void);
long cerPer(char *, char *, int);
void eliPer(long pos);
void visPer(void);
void visAnagrafe(void);

int main(void)
{
int scelta = MENU, i, numeroElementi;
A.Bellini, A.Guidi,
char invio;
switch(scelta) {
case MENU:
scelta = menPer();
if(scelta == MENU)
scelta = OUT;
break;
case INS:
insPer();
scelta = MENU;
break;
case CAN:
canPer();
scelta = MENU;
break;
case RIC:
ricPer();
scelta = MENU;
break;
case VIS:
visAnagrafe();
scelta = MENU;
break;
case INSMUL:
i = 1;
scelta = MENU;
break;
}
}
}
/* Menu */
int menPer(void)
{
int scelta;
char invio;
int vero = 1;
while(vero){
printf("\t\t\t ANAGRAFE");
printf("\n\n\n\t\t\t 1. Immissione Persona");
printf("\n\n\t\t\t 2. Cancellazione Persona");
printf("\n\n\t\t\t 3. Ricerca Persona");
printf("\n\n\t\t\t 4. Visualizza anagrafe");
switch(scelta) {
case 0:
A.Bellini, A.Guidi,
case 1:
case 2:
case 3:
case 4:
case 5:
return(scelta);
default:
break;
}
}
return(0);
}
/* inserisce persona nel file anag.dat */

void insPer(void)
{
char invio;
/* Se il file non esiste lo crea,
i dati sono appesi in fondo al file */
fp = fopen("anag.dat","a+");
printf("\n\t\tINSERIMENTO PERSONA");
printf("\n\t\t---------------\n\n");
gets_s(anag.cognome, DIM);
gets_s(anag.nome, DIM);
printf("\nIndirizzo : ");
gets_s(anag.ind, DIM);
scanf("%d", &anag.eta);
fwrite(&anag, sizeof(struct per), 1, fp);

fclose(fp);
}
/* Cancella una persona dall'anagrafe, se presente */

void canPer(void)
{
char pausa;
int eta;
long pos;
printf("\n\t\tCANCELLA PERSONA");
gets_s(nome, DIM);
scanf("%d", &eta);
/* Invoca ricerca persona */
pos = cerPer(cognome, nome, eta);
if(pos == -1) {
A.Bellini, A.Guidi,
return;
}
/* Invoca visualizza persona */
visPer();
printf("\nConfermi cancellazione ? (S/N) ");
if(pausa=='S' || pausa=='s') {
eliPer(pos);
return;
}
}
/* Elimina persona dall'anagrafe */

void eliPer(long pos)
{
strcpy(anag.cognome, "");
strcpy(anag.nome, "");
strcpy(anag.ind, "");
anag.eta = 0;
fp = fopen("anag.dat","r+");
fseek(fp,pos,0);
fwrite(&anag, sizeof(struct per), 1, fp);
fclose(fp);
}
/* Ricerca persona */
void ricPer(void)
{
char pausa;
int eta;
long pos;
/* Inserimento dati persona da ricercare */
printf("\n\t\tRICERCA PERSONA");
gets_s(nome, DIM);
scanf("%d", &eta);
/* Invoca la funzione di scansione sequenziale */
pos = cerPer(cognome, nome, eta);
if(pos == -1) {
return;
}
visPer();
}
/* Effettua una scansione sequenziale del file anag.dat

A.Bellini, A.Guidi,
alla ricerca di una persona che abbia determinati
cognome, nome ed età */
long cerPer(char *cg, char *nm, int et)
{
int n;
long pos = 0L;
fp = fopen("anag.dat", "r");
for(;;) {
n = fread(&anag, sizeof(struct per), 1, fp);
if(n==0) {
fclose(fp);
pos = -1;
return (pos);
}
else
if(strcmp(cg, anag.cognome) == 0)
if(strcmp(nm, anag.nome) == 0)
if(et == anag.eta) {
pos = ftell(fp);
fclose(fp);
return(pos-sizeof(struct per));
}
}
}
/* Visualizza persona */
void visPer(void)
{
printf("\n\n--------------------\n");
printf("\n\t\tCognome : %s", anag.cognome);
printf("\n\t\tNome : %s", anag.nome);
printf("\n\t\tIndirizzo : %s", anag.ind);
printf("\n\t\tEta' : %d", anag.eta);
printf("\n\n--------------------\n");
}
/* Visualizza l'anagrafe completa */

void visAnagrafe(void)
{
int n; char pausa;
fp = fopen("anag.dat", "r");
do {
n = fread(&anag, sizeof(struct per), 1, fp);
if(n==0) fclose(fp);
else {
visPer();
}
}
while(n!=0);
}
14
A.Bellini, A.Guidi,
Si potrebbe procedere come nel Caso di Studio IV sostituendo la struttura
struct per
con le strutture:
struct dat
{int giorno, mese, anno};
typedef struct dat Data;
struct student {
char *cogStud;
char *nomStud;
char *indStud;
Data datNasc;
};
A.Bellini, A.Guidi,
Capitolo 18
1
#include <stdio.h>
int main(void)
{
short int i;
int j;
char pausa;
i = 32768;
printf("\ncon il tipo short inserendo 32768 ottengo: %d", i);
i = 32769;
printf("\ncon il tipo short inserendo 32769 ottengo: %d", i);
j = 32768;
printf("\ncon il tipo int inserendo 32768 ottengo: %d", j);
j = 32769;
printf("\ncon il tipo int inserendo 32769 ottengo: %d", j);
}
Risultati probabili:
con il tipo short inserendo 32768 ottengo: -32768

con il tipo short inserendo 32769 ottengo: -32767
con il tipo int inserendo 32768 ottengo: 32768
con il tipo int inserendo 32769 ottengo: 32769
Al lettore spiegare il perché di questi risultati e il perché dipendano dall’implementazione.
2
#include <stdio.h>
int main(void)
{
char c, pausa;
printf("\nImmetti 300: ");
scanf("%c", &c);
printf("%c", c);
scanf("%c", &c);
printf("%c", c);
scanf("%c", &c);
printf("%c", c);
scanf("%c", &c);
printf("%c", c);
A.Bellini, A.Guidi,
scanf("%c", &c);
printf("%c", c);
scanf("%c", &c);
printf("%c", c);
printf("\nQualsiasi tasto per continuare..");
}
Risultati:
Immetti 300: 300

3
Immetti 44: 44
4
Immetti 6: 6
6
Immetti 257: 257
2
Immetti 256: 256
2
Immetti 255: 255
2
Qualsiasi tasto per continuare..

Al lettore spiegare il perché di questi risultati e perché si sono dovute aggiungere al programma di prova tutte quelle
scanf("%c", &pausa). Cosa succede se si tolgono?
3
#include <stdio.h>
int main(void)
{
unsigned char c;
char pausa;
c = '\166' & '\360';
printf("c: %o\n", c);
c = '\100' & '\360';
c = '\0' & '\360';
c = '\111' & '\360';
c = '\110' & '\360';

}
Risultati:
c: 160
A.Bellini, A.Guidi,
c: 100
c: 0
c: 100
c: 100
Al lettore spiegare il perché.
4
#include <stdio.h>
int main(void)
{
unsigned char c;
char pausa;
c = '\111' ^ '\360';
c = '\321' ^ '\360';
c = '\350' ^ '\360';

}
Risultati:
c: 271
c: 41
c: 30
5
#include <stdio.h>
int main(void)
{
unsigned char c;
char pausa;
c = ~'\351';
c = ~'\222';
c = ~'\123';

}
Risultati:
c: 26
c: 155
A.Bellini, A.Guidi,
c: 254
6
#include <stdio.h>
int main(void)
{
unsigned char c;
char pausa;
c = '\123';
printf("c (unsgned char \\123): %o\n", c);
c = c >> 1;
printf("c (>>1): %o\n", c);
c = '\123';
c = c >> 2;
printf("c (>>2): %o\n", c);
c = '\123';
c = c >> 3;
printf("c (>>3): %o\n", c);
c = '\123';
c = c << 1;
printf("c (<<1): %o\n", c);
c = '\123';
c = c << 2;
printf("c (<<2): %o\n", c);
c = '\123';
c = c << 3;
printf("c (<<3): %o\n", c);

}
Risultati:
c (unsgned char \123): 123

c (>>1): 51
c (>>2): 24
c (>>3): 12
c (<<1): 246
c (<<2): 114
c (<<3): 230
7
#include <stdio.h>
int main(void)
{
unsigned char c;
char pausa;
c = '\321';
c = c >> 1;
A.Bellini, A.Guidi,
c = '\321';
c = c << 1;

}
Risultati:
c: 150
c: 242

A.Bellini, A.Guidi,
Capitolo 19
Soluzione esercizi 1, 2, 3, 4, 5 e 6
/* Esercizi di Output formattato */
#include <stdio.h>
int main(void)
{
int i;
char stringa[100] ="Eccomi qua";
char pausa;
/* Esercizio 1 */
for(i=1; i<101; i++)
printf("%o\n", i);
/* Esercizio 2 */
for(i=1; i<101; i++)
printf("%x\n", i);
/* Esercizio 3 */
printf("%s\n", stringa);
/* Esercizio 4 */
printf("%e\n", 123.321);
/* Esercizio 5 */
printf("%%\n");
/* Esercizio 6 */
printf("%10o\n", 198);
}
Soluzione esercizi 7, 8, 9, 10, 11 e 12
/* Esercizi di Input formattato */
#include <stdio.h>
int main(void)
{
int i;
float x;
char stringa[100];
char pausa;
/* Esercizio 7 */
printf("Inserire un intero in formato ottale: ");
scanf("%o", &i);
printf("%d\n", i);
/* Esercizio 8 */
printf("Inserire un intero in formato esadecimale: ");
scanf("%x", &i);
printf("%d\n", i);
/* Esercizio 9 */
printf("Inserire un intero in formato esponenziale: ");
scanf("%e", &x);
printf("%f\n", x);
/* Esercizio 10 */
A.Bellini, A.Guidi,
printf("Inserire una stringa di caratteri abc: ");
scanf("%[abc]", &stringa);
/* Esercizio 11 */
printf("Inserire una stringa di caratteri che non siano abc: ");
scanf("%[^abc]", &stringa);
/* Esercizio 12 */
printf("Inserire una stringa di caratteri, vengono letti solo i primi 3:");
scanf("%3s", &stringa);
}
13
/* Esercizio di Input/Output formattato su stringa */
#include <stdio.h>
int main(void)
{
int i;
float x;
char s1[100] = "123";
char s2[100];
char pausa;
sscanf(s1, "%o", &i);

sprintf(s2, "%d\n", i);
printf("%d\n", i);
}
A.Bellini, A.Guidi,
Capitolo 20
1
#include <stdio.h>
struct tavSim {
char *nome;
char tipo;
union {
char *valStr; /*usato se tipo == 's' */
int valInt; /* usato se tipo == 'i' */
};
};
void stampaVoce(struct tavSim *);
int main(void)
{
tavSim a, b;
char pausa;
a.nome = "Rossella";
a.tipo = 's';
a.valStr = "Vero";
stampaVoce(&a);
a.nome = "Jessica";
a.tipo = 'i';
a.valInt = 1;
stampaVoce(&a);
a.nome = "Sabra";
a.tipo = 'f';
a.valInt = 1;
stampaVoce(&a);
}
void stampaVoce(struct tavSim *p)

{
switch (p->tipo) {
case 's':
printf("%s\n", p->valStr);
break;
case 'i':
printf("%d\n", p->valInt);
break;
default:
printf("\nValore di tipo non corretto\n");
break;
}
}
Il programma restituisce:
Vero
1
Valore di tipo non corretto
A.Bellini, A.Guidi,
2
#include <stdio.h>
int main(void)
{
struct binario {
unsigned uno: 1;
unsigned due: 2;
unsigned tre: 3;
unsigned quattro: 4;
unsigned cinque: 5;
unsigned sei: 6;
unsigned sette: 7;
unsigned otto: 8;
} a;
char pausa;
a.uno = 0;
a.due = 1;
a.tre = 0;
a.quattro = 0;
a.cinque = 0;
a.sei = 0;
a.sette = 0;
a.otto = 0;
printf("%d", a.uno);
printf("%d", a.due);
printf("%d", a.tre);
printf("%d", a.quattro);
printf("%d", a.cinque);
printf("%d", a.sei);
printf("%d", a.sette);
printf("%d", a.otto);
}
3
#include <stdio.h>
struct binario {
unsigned uno: 1;
unsigned due: 2;
unsigned tre: 3;
unsigned quattro: 4;
unsigned cinque: 5;
unsigned sei: 6;
unsigned sette: 7;
unsigned otto: 8;
};
int decimale(struct binario *);
int main(void)
{
struct binario a;
char pausa;
A.Bellini, A.Guidi,
a.uno = 0;
a.due = 1;
a.tre = 0;
a.quattro = 0;
a.cinque = 0;
a.sei = 0;
a.sette = 0;
a.otto = 0;
printf("%d", a.uno);
printf("%d", a.due);
printf("%d", a.tre);
printf("%d", a.quattro);
printf("%d", a.cinque);
printf("%d", a.sei);
printf("%d", a.sette);
printf("%d", a.otto);
printf("\n%d", decimale(&a));
}
int decimale(struct binario *b)

{
int risultato;
risultato = (b->otto)+b->sette*2+b->sei*4+b->cinque*8+b->quattro*16+b-
>tre*32+b->due*64+b->uno*128;
return risultato;
}
A.Bellini, A.Guidi,
Capitolo 21
1
Presentiamo due possibili soluzioni che si differenziano per il modo in cui i risultati vengono comunicati dalla funzione
al chiamante. Nella prima versione (contaPari) i due parametri vengono passati per indirizzo; nella seconda
(contaPari2) la funzione è di tipo int e ritorna il numero di pari, mentre il numero dei dispari è ancora restituito
per indirizzo.
struct elemento {
int inf;
struct elemento *pun;
};
struct elemento *creaLista2();
void visualizzaLista(struct elemento *);
void contaPari(struct elemento *, int *, int *);
int contaPari2(struct elemento *, int *);
int main(void)
{
int pari, dispari;
struct elemento *puntLista;
puntLista = creaLista2();
visualizzaLista(puntLista);
/* chiamata prima versione di conta pari */
contaPari(puntLista, &pari, &dispari);
printf("\nPari: %d Dispari: %d", pari, dispari);
/* chiamata seconda versione di conta pari */
printf("\nPari: %d", contaPari2(puntLista, &dispari));
printf(" Dispari: %d\n", dispari);
}
void contaPari(struct elemento *p, int *ppari, int *pdispari)
{
*ppari = *pdispari = 0;
while(p!=NULL) {
if(p>inf % 2 == 0)
(*ppari)++;
else
(*pdispari)++;
p = p>pun;
}
}
contaPari2(struct elemento *p, int *pdispari)
{
int pari = 0;
*pdispari = 0;
while(p!=NULL) {
if(p>inf % 2 ==0)
pari++;
else
(*pdispari)++;
p = p>pun;
}
return(pari);
}
A.Bellini, A.Guidi,
2
Si noti come la funzione eliminaPari modifichi il valore al puntatore iniziale della lista nel caso che il primo
elemento contenga un numero pari; per questa ragione è necessario utilizzare un puntatore ausiliario paus per scorrere
in avanti la lista e restituire comunque al chiamante il corretto riferimento all’inizio della lista.
/* Accetta in ingresso una sequenza di valori interi terminante con zero

e la memorizza in una lista lineare. Successivamente il
programma elimina dalla lista i numeri pari. */
#include <stdio.h>
#include <malloc.h>
struct elemento {
int inf;
};
struct elemento *eliminaPari(struct elemento *);
int main(void)
{
puntLista = eliminaPari(puntLista);
}
struct elemento *eliminaPari(struct elemento *p)
{
struct elemento *paus;
int logica = 1;
while(p!=NULL && logica)
if(p>inf % 2 == 0)
p = p>pun;
else
logica = 0;
paus = p;
while(paus>pun != NULL)
if(paus>pun>inf % 2 == 0)
paus>pun = paus>pun>pun;
else
paus = paus>pun;
return(p);
}
3
/* Accetta in ingresso una sequenza di valori interi terminante con zero
e la memorizza in una lista lineare. Successivamente il
programma rihiede all'utente un numero intero n ed elimina dalla lista
i numeri divisibili esattamente per n. */
#include <stdio.h>
#include <malloc.h>
struct elemento {
int inf;
};
A.Bellini, A.Guidi,
struct elemento *eliminaDivN(struct elemento *);
int main(void)
{
char invio;
puntLista = eliminaDivN(puntLista);
}
/* Accetta in ingresso una sequenza di interi e li

memorizza in una lista. Il numero di interi che compongono
la sequenza termina con il valore zero */
struct elemento *creaLista2()
{
struct elemento *p, *paus;
struct elemento x;
printf("\nInserisci un'informazione (0 per fine lista): ");

scanf("%d", &x.inf);
if(x.inf==0) p = NULL; /* lista vuota */

else {
/* Creazione del primo elemento */
p = (struct elemento *)malloc(sizeof(struct elemento));
p->inf = x.inf;
paus=p;
while(x.inf!=0) {
printf("\nInserisci un'informazione (0 per fine lista): ");
if(x.inf!=0) {
/* Creazione dell'elemento successivo */
paus->pun = (struct elemento *)malloc(sizeof(struct elemento));
paus = paus->pun; /* attualizzazione di paus */

paus->inf = x.inf; /* inserimento dell'informazione
nell'elemento */
}
else
paus->pun = NULL; /* Marca di fine lista */
}
}
return(p);
}
struct elemento *eliminaDivN(struct elemento *p)

{
int logica = 1;
int n;
do {
printf("\nInserisci un numero intero positivo maggiore di 1: ");
scanf("%d", &n);
}
while(n<2);
A.Bellini, A.Guidi,
while(p!=NULL && logica)

if(p->inf % n == 0)
p = p->pun;
else
logica = 0;
paus = p;
while(paus->pun != NULL)
if(paus->pun->inf % n == 0)
paus->pun = paus->pun->pun;
else
paus = paus->pun;
return(p);
}
/* Visualizza la lista */
void visualizzaLista(struct elemento *p)
{
printf("\npuntLista---> ");
/* Ciclo di scansione della lista */

while(p!=NULL) {
printf("%d", p->inf); /* visualizza il campo informazione */
printf("---> ");
p = p->pun; /* scorre di un elemento in avanti */
}
printf("NULL\n\n");
}
4
/* Data in ingresso una sequenza di valori interi terminante con zero,
costruisce due liste lineari, una contenente i valori positivi e una
i valori negativi. Visualizza le liste costruite. */
#include <stdio.h>
#include <malloc.h>
struct elemento {
int inf;
};
struct elemento *aggiungi(struct elemento *, struct elemento);
int main(void)
{
struct elemento *puntPositivi = NULL;
struct elemento *puntNegativi = NULL;
struct elemento x;
do {
printf("\nInserisci una
informazione (0 per fine lista): ");
if(x.inf>0)
puntPositivi = aggiungi(puntPositivi, x);
if(x.inf<0)
puntNegativi = aggiungi(puntNegativi, x);
}
while(x.inf!=0);
visualizzaLista(puntPositivi);
visualizzaLista(puntNegativi);
}
A.Bellini, A.Guidi,
struct elemento *aggiungi(struct elemento *p, struct elemento x)
{
if(p==NULL) {
p = (struct elemento *) malloc(sizeof(struct elemento));
p>inf = x.inf;
p>pun = NULL;
}
else {
paus = (struct elemento *) malloc(sizeof(struct elemento));
paus>inf = x.inf;
paus>pun = p;
p = paus;
}
return(p);
}
A.Bellini, A.Guidi,
Caso di studio V
1
Nel Listato del Caso di Studio V deve essere modificata solo la funzione inserimento, per capire se il valore da
inserire è maggiore del valore del primo elemento (> diventa <):
/* Inserimento del valore passato dall'utente nella lista

mantenendo l'ordinamento (inverso) */
struct elemento *inserimento(struct elemento *p)

{
struct elemento *p0, *p1;
int posizione;
...
/* Creazione elemento */
...
if(p->inf < p0->inf) { /* se il valore dell'elemento è */
p0->pun = p; /* maggiore del primo l'elemento */
p = p0; /* diventa il primo della lista */
}
e per capire se se debba andare avanti nella scansione (< diventa >):
...
if(p1->pun->inf > p0->inf)
p1 = p1->pun; /* scorre in avanti p1 */
else
posizione = 1; /* interrompe lo scorrimento */
}
2
Nel Listato del Caso di Studio V deve essere modificata solo la funzione gestioneLista aggiungendo la nuova
opzione per la gestione del caso d’inserimento multiplo di elementi.
Sono state dichiarate due varibili nuove: i e numeroElmenti.
E’ stata aggiunta la visualizzazione del nuovo caso:
printf("\n\n\t\t\t 4. Per inserire piu' elementi");
E’ stato gestito il nuovo caso con la chiamata ripetitiva della funzione inserimento.
case 4:
i = 1;
while(i++ <= numeroElementi)
puntLista = inserimento(puntLista);
break;
void gestioneLista(void)
{
struct elemento *puntLista = NULL;
int scelta = -1, numeroElementi, i;
char pausa;
while(scelta!=0) {
printf("\t\tGESTIONE DI UNA SEQUENZA DI VALORI ORDINATI\n");
printf("\t\t MEDIANTE UNA STRUTTURA A LISTA");
printf("\n\n\n\t\t\t 1. Per inserire un elemento");
printf("\n\n\t\t\t 2. Per eliminare un elemento");
printf("\n\n\t\t\t 3. Per visualizzare la lista");
A.Bellini, A.Guidi,
printf("\n\n\t\t\t 0. Per finire");
switch(scelta) {
case 1:
break;
case 2:
puntLista = eliminazione(puntLista);
break;
case 3:
visualizzazione(puntLista);
printf("\n\nPremere un tasto per continuare...");
scanf("%c%c", &pausa, &pausa);
break;
case 4:
i = 1;
break;
}
}
}
3
In modo analogo all’esercizio precedente nel Listato del Caso di Studio V deve essere modificata solo la funzione
gestioneLista aggiungendo la nuova opzione per la gestione del caso d’eliminazione multipla di elementi.
{
char pausa;
while(scelta!=0) {
printf("\n\n\t\t\t 5. Per eliminare piu' elementi");
switch(scelta) {
case 1:
break;
case 2:
break;
case 3:
A.Bellini, A.Guidi,
break;
case 4:
i = 1;
break;
case 5:
printf("Di quanti elementi desidera richiedere l'eliminazione: ");
i = 1;
break;
}
}
}
4
Nel Listato del Caso di Studio V deve essere dichiarata la funzione di ricerca:
void ricerca(struct elemento *);
Nella funzione gestioneLista deve essere aggiunta la nuova opzione per la gestione della ricerca:
...
printf("\n\n\t\t\t 6. Ricerca di un elemento");
...
case 6:
ricerca(puntLista);
break;
Deve essere creata la funzione ricerca.

Si noti che la variabile presente svolge la funzione di flag (elemento trovato/non trovato), mentre la variabile
posizione indica la posizione dove l’elemento è stato eventualmente trovato.
/* Ricerca di un elemento nella lista ordinata */

void ricerca(struct elemento *p)
{
struct elemento *p1 = p;
struct elemento e;
int presente = 0, posizione = 1;
char pausa;
printf("\nInserire l'informazione da ricercare: ");

scanf("%d", &e.inf);
if(p1!=NULL) { /* se la lista è vuota fine */

if(p1->inf == e.inf) /* se è il primo della lista */
presente = 1;
else /* ricerca dell'elemento */
while(p1->pun!=NULL && presente!=1) {
posizione++;
if(p1->pun->inf != e.inf)
else
A.Bellini, A.Guidi,
presente = 1; /* interrompe lo scorrimento */
}
}
if(!presente) {
printf("\nElemento non incontrato nella lista ");
}
else {
printf("\nElemento in posizione: %d", posizione);
}
}
7
/* GESTIONE DI LISTA ORDINATA
Operazioni di inserimento, eliminazione e visualizzazione.
Utilizza una lista lineare
ELEMNTO DELLA LISTA DI TIPO CARATTERE */
#include <stdio.h>
#include<malloc.h>
struct elemento {
char inf;
};
void gestioneLista(void);
struct elemento *inserimento(struct elemento *);

struct elemento *eliminazione(struct elemento *);
void visualizzazione(struct elemento *);
void ricerca(struct elemento *);
int main(void)
{
gestioneLista();
}
{
char pausa;
while(scelta!=0) {
printf("\n\n\t\t\t 5. Per eliminare piu' elementi");
printf("\n\n\t\t\t 6. Ricerca di un elemento");
A.Bellini, A.Guidi,
switch(scelta) {
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
i = 1;
break;
case 5:
printf("Di quanti elementi desidera richiedere l'eliminazione: ");
i = 1;
break;
case 6:
ricerca(puntLista);
break;
}
}
}
/* Visualizzazione della lista */

void visualizzazione(struct elemento *p)
{
struct elemento *paus = p;
printf("\npuntLista---> ");
while(paus!=NULL) {
printf("%c---> ", paus->inf);
paus = paus->pun;
}
printf("NULL");
}
/* Inserimento del valore passato dall'utente nella lista

mantenendo l'ordinamento */
struct elemento *inserimento(struct elemento *p)
{
struct elemento *p0, *p1;
int posizione;
char pausa;
/* Creazione elemento */
p0 = (struct elemento *)malloc(sizeof(struct elemento));
printf("\nInserire l'informazione (un carattere): ");

scanf("%c%c", &pausa, &p0->inf);
A.Bellini, A.Guidi,
if(p==NULL) { /* se la lista è vuota, l'elemento */
p = p0; /* diventa il primo e unico della lista */
p->pun = NULL;
}
else {
if(p->inf > p0->inf) { /* se il valore dell'elemento è */
p0->pun = p; /* inferiore al primo l'elemento */
p = p0; /* diventa il primo della lista */
}
else { /* ricerca della posizione di inserimento */
p1 = p;
posizione = 0;
while(p1->pun!=NULL && posizione!=1) {
if(p1->pun->inf < p0->inf)
else
}
p0->pun = p1->pun; /* connessione all'elemento successivo */
p1->pun = p0; /* connessione dall'elemento precedente */
}
}
return(p); /* ritorno del puntatore all'inizio della lista */
}
/* Eliminazione dell'elemento richiesto dalla lista ordinata */

struct elemento *eliminazione(struct elemento *p)
{
struct elemento *p1 = p, *p2;
struct elemento e;
int posizione = 0;
char pausa;
printf("\nInserire l'informazione da eliminare: ");

scanf("%c%c", &pausa, &e.inf);

if(p1->inf == e.inf) { /* se è il primo da eliminare */
p2 = p1;
p = p->pun; /* si modifica il puntatore alla testa */
free(p2);
return(p);
}
else { /* ricerca dell'elemento da eliminare */
while(p1->pun!=NULL && posizione!=1) {
if(p1->pun->inf!=e.inf)
else {
p2 = p1->pun;
p1->pun = p1->pun->pun; /* eliminazione elemento */
free(p2); /* libera la memoria */
return( p );
}
}
}
}
if(!posizione) {
}
A.Bellini, A.Guidi,
return(p);
}
/* Ricerca di un elemento nella lista ordinata */

void ricerca(struct elemento *p)
{
struct elemento *p1 = p;
struct elemento e;
int presente = 0, posizione = 1;
char pausa;
printf("\nInserire l'informazione da ricercare: ");

scanf("%c%c", &pausa, &e.inf);

if(p1->inf == e.inf) /* se è il primo della lista */
presente = 1;
else /* ricerca dell'elemento */
while(p1->pun!=NULL && presente!=1) {
posizione++;
if(p1->pun->inf != e.inf)
else
presente = 1; /* interrompe lo scorrimento */
}
}
if(!presente) {
}
else {
printf("\nElemento in posizione: %d", posizione);
}
}
A.Bellini, A.Guidi,
Capitolo 22
1
/* Funzione ricorsiva per visitare in ordine differito un albero binario.
La struttura dei nodi e’ quella vista nel primo esempio del
capitolo. */
void differito(struct nodo *p)
{
if(p!=NULL) {
differito(p>albSin);
differito(p>albDes);
printf("%d ", p>inf);
}
}
2
/* Si considera la seguente definizione di nodo di albero binario:
struct nodo {
int inf;
int occorrenze;
struct nodo *albSin;
struct nodo *albDes;
};
La funzione creaNodo2 differisce da creaNodo del primo esempio

del capitolo, in quanto calcola il numero di occorrenze multiple
dello stesso valore eventualmente immesse dall’utente, e memorizza
tali occorrenze nel nodo stesso nel campo occorrenze. */
struct nodo *creaNodo2(struct
nodo *p, int val)
{
if(p==NULL) {
p = (struct nodo *) malloc(sizeof(struct nodo));
p>inf = val;
p>occorrenze = 1;
p>albSin = NULL;
p>albDes = NULL;
}
else {
if(val > p>inf)
p>albDes = creaNodo2(p>albDes, val);
else
if(val < p>inf)
p>albSin = creaNodo2(p>albSin, val);
else
++p>occorrenze;
}
return(p);
}
3
/* Funzione che visita in forma simmetrica l’albero binario e
Che visualizza, oltre al valore di ogni nodo, il corrispondente
A.Bellini, A.Guidi,
numero di occorrenze, memorizzate mediante la funzione creaNodo2
dell’esercizio precedente. */
void simmetrico(struct nodo *p)
{
if(p!=NULL) {
simmetrico(p>albSin);
printf("\n%d %d", p>inf, p>occorrenze);
simmetrico(p>albDes);
}
}
4
/* Funzione ricorsiva per visitare in ordine differito un albero
Implementato mediante liste multiple. */
void differito(struct nodo *p)
{
struct nodo *paus = p;
paus = paus>pArco;
printf("(");
while(paus!=NULL) {
differito(paus>figlio);
paus = paus>pArco;
}
printf("%c)", p>inf);
}
7
Per evitare di cadere in un ciclo infinito, ogni nodo del percorso deve essere visitato una e una sola volta. A questo
scopo si usa un array (giaVisitati[]) che contiene tanti elementi interi quanti sono i nodi del grafo memorizzati
nell’array s[] e nello stesso ordine di s[]. Tutto l’array viene inizializzato a zero; prima di transitare per un certo
nodo ci si domanda se l’elemento corrispondente di giaVisitato ha valore 1: se così non è si assegna 1 a
quell’elemento e lo si visita. Devono essere dichiarate le seguenti funzioni e variabili globali:
void giro(char);
void vai(int);
int giaVisitati[10] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int main(void)
{
char etichetta, invio;
matAdiacenze();
visMatAdiacenze();
successori();
visita();
/* VISITA A PARTIRE DA UN NODO */
printf("\nImmettere l'etichetta di un nodo: ");
scanf("%c", &etichetta);
giro(etichetta);
}
void giro(char e)
A.Bellini, A.Guidi,
{
int i = 0;
printf("\n");
while(i<n && s[i].inf!=e) i++;
if (i==n) return;
vai(i);
}
void vai(int i)
{
struct successore *p;
p = s[i].pun;
while(p!=NULL) {
if(giaVisitati[p>inf]==0) {
giaVisitati[p>inf] = 1;
printf(" %c", s[p>inf].inf);
vai( p>inf );
}
p = p>pun;
}
}
A.Bellini, A.Guidi,
Capitolo 23
1
#include <stdio.h>
#define PARI(a, b) {if(((a)%(2))==0) (b)=(1); else (b)=(0);}
int i, unoZero;
char pausa;
int main(void)
{
printf("Dammi un intero: ");
scanf("%d", &i);
PARI(i,unoZero);
printf("%d\n", unoZero);
}
2
#include <stdio.h>
#define SEGMENTO(a, b, l) {l = a-b; if((l)<(0))(l)=(-l);}
int main(void)
{
int estremo1, estremo2, lunghezza;
char pausa;
printf("\n\nLUNGHEZZA SEGMENTO\n");
printf("Primo estremo: ");
scanf("%d", &estremo1);
printf("Secondo estremo: ");
scanf("%d", &estremo2);
SEGMENTO(estremo1, estremo2, lunghezza);
printf("%d\n", lunghezza);
}
3
Con
#define DIM 100;
non è segnalato nessuno errore. Se l’intenzione era di far sostituire in tutto il programma del simbolo DIM con il valore
100, ciò non è stato ottenuto: le macro del precompilatore, al contrario delle istruzioni, non si chiudono con un punto e
virgola. In realtà a DIM verrà sostituito 100;. Ciononostante
a. n = DIM;
non genererà un errore e n assumerà davvero il valore 100, è come se avessimo scritto:
A.Bellini, A.Guidi,
n = 100;;
dove è presente un’istruzione nulla. Tutto bene anche scrivendo:
n = DIM
infatti la sostituzione genererà
n = DIM;
Un effetto che probabilmente non avevamo previsto.
Naturalmente è sconsigliato utilizzare volontariamente questo tipo di codice difficilmente comprensibile e quindi
mantenibile nel tempo. L’istruzione
b. float array[DIM];
generare un errore infatti la sostituzione ha questo effetto:
float array[100;];
4
La macro
#define VERO (a>100)
assegna a VERO il (a>100) per cui l’istruzione
while (VERO)
provoca un errore come il seguente in fase di compilazione
'a' undeclared (first use this function)
6
#include <stdio.h>
#define POTENZA(b, e, p) \
{if((e)==0)(p)=1; \
else if((e)==1)(p)=(b); \
else if((e)==2)(p)=(b)*(b); \
else if((e)==3)(p)=(b)*(b)*(b); \
else if((e)==4)(p)=(b)*(b)*(b)*(b); \
else if((e)==5)(p)=(b)*(b)*(b)*(b)*(b);}
int main(void)
{
int base, esponente, potenza;
char pausa;
printf("Base: ");
scanf("%d", &base);
printf("Esponente (0, 1,2,3,4,5): ");
scanf("%d", &esponente);
POTENZA(base, esponente, potenza);

A.Bellini, A.Guidi,
printf("%d\n", potenza);
}
Si noti come la macro rimanga valida anche con base e potenza variabili floating.
…
int esponente;
float base, potenza;
char pausa;
printf("Base: ");
scanf("%f", &base);
printf("%f\n", potenza);
…
7
#include <stdio.h>
{p=1; \
while((e--)!=0)(p)=(p)*(b);}
8
#include <stdio.h>
{switch (e) { \
case 0: (p)=1; break; \
case 1: (p)=(b); break; \
case 2: (p)=(b)*(b); break; \
case 3: (p)=(b)*(b)*(b); break; \
case 4: (p)=(b)*(b)*(b)*(b); break; \
case 5: (p)=(b)*(b)*(b)*(b)*(b); break;}\
}
int main(void)
{
int base, esponente, potenza;
char pausa;
printf("Base: ");
scanf("%d", &base);
printf("%d\n", potenza);
}
A.Bellini, A.Guidi,
9
#include <stdio.h>
#define SUPERFICIE(b, h, p, a) \
{switch (p) { \
case 'T': (a) = (b)*(h)/2.0; break; \
case 'R': (a) = (b)*(h); break; \
default : (a)=-1; break; \
}}
#include <stdio.h>
double area(float, float, char);
int main(void)
{
float b, h;
double tri, ret, altro;
char pausa;
printf("Inserire base: ");

scanf("%f", &b);
printf("Inserire altezza: ");
scanf("%f", &h);
SUPERFICIE(b, h, 'T', tri);

printf("Il triangolo (b = %f, h = %f) ha area %f\n", b, h, tri);
SUPERFICIE(b, h, 'R', ret);
printf("Il rettangolo (b = %f, h = %f) ha area %f\n", b, h, ret);
SUPERFICIE(b, h, 'x', altro);
printf("Poligono non definito %d\n", altro);
}
10
#include <stdio.h>
#include <math.h>
#define SUPERFICIE(b, h, p, a ) \
{switch (p) { \
case 'T': (a) = (b)*(h)/2.0; break; \
case 'R': (a) = (b)*(h); break; \
case 'E': (a) = sqrt((h)*(h)-(b/2)*(b/2))*(b)/2*6;\
break; \
default : (a)=-1; break; \
}}
#include <stdio.h>
int main(void)
{
float b, h;
double tri, ret, altro, pen;
char pausa;
printf("Inserire base: ");

scanf("%f", &b);
printf("Inserire altezza (nel caso del pentagono e' l'apotema): ");
scanf("%f", &h);
A.Bellini, A.Guidi,
SUPERFICIE(b, h, 'T', tri);

printf("Il triangolo (b = %f, h = %f) ha area %f\n", b, h, tri);
SUPERFICIE(b, h, 'R', ret);
printf("Il rettangolo (b = %f, h = %f) ha area %f\n", b, h, ret);
SUPERFICIE(b, h, 'x', altro);
printf("Poligono non definito %d\n", altro);
SUPERFICIE(b, h, 'E', pen);
printf("L’esagono (b = %f, h = %f) ha area %f\n", b, h, pen);
}
11
/* Esempio di macro che concatena
i primi n caratteri di una
stringa su di un'altra */
#include <stdio.h>
#define CONCATENA(uno,due,n) {\
for(i=0; uno[i]!='\0'; i++);\
for(j=0; (uno[i]=due[j])!='\0'
&& j<(n)1; i++,j++);\
}
char stringa1[100] = "Prima stringa ";
int main(void)
{
char stringa2[100];
int i, j, n;
printf("Inserire una parola: ");
for(i=0; (stringa2[i] = getchar())!='\n'; i++)
;
stringa2[i]='\0';
printf("Caratteri da concatenare: ");
scanf("%d", &n);
CONCATENA(stringa1, stringa2, n);
printf(" Stringa concatenata: %s \n", stringa1);
}
A.Bellini, A.Guidi,
Capitolo 27
1
#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
// Ecco il secondo programma in Objective-C
NSLog (@"\nTre casettine dai tetti aguzzi \nun verde praticello \nun esiguo
ruscello.");
// Oppure
NSLog (@"Tre casettine dai tetti aguzzi");
NSLog (@"un verde praticello");
NSLog (@"un esiguo ruscello.");
}
2
{
BOOL B1, B2;
B1 = YES;
B2 = NO;
if(B1!=0) { NSLog (@"B1 or B2 = Vero"); }

else if(B2!=0) { NSLog (@"B1 or B2 = Vero"); }
else { NSLog (@"B1 or B2 = Falso");}
if(B1==0) { NSLog (@"B1 and B2 = Falso"); }

else if(B2==0) { NSLog (@"B1 and B2 = Falso"); }
else { NSLog (@"B1 and B2 = Vero"); }
}
3
{
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSString *stringa = @"1 2 3 4 5 6 7";
int lung = [stringa length];
NSLog(@"'%@' contiene %d caratteri", stringa, lung);
NSRange range;
range.location = 0;
range.length = 2;
NSString *str1 = [stringa substringWithRange:range];
range.location = 2;
range.length = 2;
range.location = 4;
range.length = 6;
range.location = 10;
range.length = 3;
NSLog(@"'%@%@%@%@'", str1, str3, str2, str4);
[pool drain];
}
Output del programma:

‘1 2 3 4 5 6 7’ contiene 13 caratteri
‘1 3 4 5 2 6 7’
A.Bellini, A.Guidi,
Capitolo 28
1
int main(int argc, const char * argv[])
{
// Crea 2 oggetti
NSString* qui = [NSString stringWithString:@"Huey"];
NSString* quo = [NSString stringWithString:@"Dewey"];
NSString* qua = [NSString stringWithString:@"Louie"];
// Crea un array vuoto

NSMutableArray *sList = [NSMutableArray array];
// Aggiunge stringhe all’array

[sList addObject:qui];
[sList addObject:qua];
// Visualizza l'array
NSString *s;
for (s in sList)
{
NSLog(@"Una stringa: %@", s);
}
// Mette quo come secondo elemento della lista

[sList insertObject:quo atIndex:1];
// Visualizza l'array
for (s in sList)
{
NSLog(@"Una stringa: %@", s);
}
[pool drain];
return 0;
}
3
{
// Crea un dizionario
NSDictionary* biblioteca;
biblioteca = [NSDictionary dictionaryWithObjectsAndKeys:

@"Linguaggio C", @"9788838668210",
@"I segreti di Pitagora", @"9788896052358",
@"Programmare in Java", @"978883866400",
@"La verdadera historia del tiempo", @"789978043141",
@"Il ladro che rubo' lo Zero", @"97888xxxxxxx", nil];
//Enumera le coppie del dizionario

NSArray* keys;
A.Bellini, A.Guidi,
int i, count;
id key, value;
keys = [biblioteca allKeys];

count = [keys count];
for (i = 0; i < count; i++)
{
key = [keys objectAtIndex: i];
value = [biblioteca objectForKey: key];
NSLog (@"Chiave: %@ corrispondente al valore: %@", key, value);
}
//Look-up "9788896052358" in biblioteca

NSString* titolo;
titolo = [biblioteca objectForKey: @"9788896052358" ];
if(titolo)
{
NSLog(@"isbn 9788896052358 ha come titolo %@", titolo);
}
else
{
NSLog(@"Nessun titolo disponibile per 1234567890123");
}
//Look-up di una chiave che non esiste

titolo = [biblioteca objectForKey: @"1234567890123" ];
if(titolo)
{
NSLog(@"123456789123 ha come titolo %@", titolo);
}
else
{
NSLog(@"Nessun titolo disponibile per 1234567890123");
}
[pool drain];
return 0;
}
A.Bellini, A.Guidi,
Capitolo 29
1
#include <stdio.h>
// Dichiarazione della classe Persona

@interface Persona: NSObject
{
@public
// variabili d’istanza accessibili dovunque
NSString* nome;
NSString* cognome;
NSString* indirizzo;
NSString* titolo_di_studio;
}
// Dichiarazione dei metodi
- (void) setName: (NSString*) nm;
- (void) setCognome: (NSString*) cg;
- (void) setIndirizzo: (NSString*) ind;
- (void) setTitolo: (NSString*) ts;
@end
// Implementazione della classe Persona

@implementation Persona
- (void) setName: (NSString*) nm
{
nome = nm;
}
{
cognome = cg;
}
- (void) setIndirizzo: (NSString*) ind;
{
indirizzo = ind;
}
- (void) setTitolo: (NSString*) ts;
{
titolo_di_studio = ts;
}
@end
// Uso della classe Persona

{
// Crea un istanza di Persona
Persona* mario = [[Persona alloc] init];
[mario setName: @"Mario"];
[mario setCognome: @"Rossi"];
[mario setIndirizzo: @"Via F. Rosselli,22 50100 Firenze"];
[mario setTitolo: @"Laurea in informatica"];
NSString* nome = mario->nome;
NSString* cognome = mario->cognome;
NSString* indirizzo = mario->indirizzo;
NSString* titolo_di_studio = mario->titolo_di_studio;
NSLog(@"La mia prima persona ha nome %@ e cognome %@", nome, cognome);
NSLog(@"indirizzo %@ e titolo di studio %@", indirizzo, titolo_di_studio);
[mario dealloc];
A.Bellini, A.Guidi,
//Crea una seconda istanza di Persona
Persona* letizia = [[Persona alloc] init];
[letizia setName: @"Letizia"];
[letizia setCognome: @"Bonarini"];
[letizia setIndirizzo: @"Corso Buenos Aires, 11 20100 Milano"];
[letizia setTitolo: @"Diploma superiore"];
nome = letizia->nome;
cognome = letizia->cognome;
indirizzo = letizia->indirizzo;
titolo_di_studio = letizia->titolo_di_studio;
NSLog(@"La mia seconda persona ha nome %@ e cognome %@", nome, cognome);
// Crea una terza istanza di Persona

Persona* susanna = [[Persona alloc] init];
[susanna setName: @"Susanna"];
[susanna setCognome: @"Parenti"];
[susanna setIndirizzo: @"Via G.Verga, 22 Palermo"];
[susanna setTitolo: @"Laurea in ingegneria civile"];
nome = susanna->nome;
cognome = susanna->cognome;
indirizzo = susanna->indirizzo;
titolo_di_studio = susanna->titolo_di_studio;
NSLog(@"La mia terza persona ha nome %@ e cognome %@", nome, cognome);
[mario dealloc];
return (0);
4
#include <stdio.h>
@interface Persona: NSObject

{
// instance variables
NSString* nome;
NSString* cognome;
}
// Dichiarazione dei metodi
+ (id) personaWithNome: (NSString*) nm WithCognome: (NSString*) cg;
- initWithNome: (NSString*)nm WithCognome: (NSString*) cg;
- init;
- (void) setName: (NSString*) nm;
- (NSString*) Nome;
- (NSString*) Cognome;
- (void) dealloc;
@end
@interface Studente: Persona

{
// instance variables
int media;
NSString* corso;
}
// Metodi (di fabbrica) di classe
A.Bellini, A.Guidi,
+ (id) studenteWithNome: (NSString*) nm WithCognome: (NSString*) cg WithMedia:
(int) lv WithCorso: (NSString*)
az;
// Medodi di istanza
- initWithNome: (NSString*)nm WithCognome: (NSString*) cg WithMedia: (int) lv
WithCorso: (NSString*)cr;
- init;
- (void) setMedia: (int) md;
- (void) setCorso: (NSString*) cr;
- AlzaMedia;
- (int) Media;
- (NSString*) Corso;
- (void) dealloc;
@end
@implementation Persona
+(id) personaWithNome: (NSString*) nm WithCognome: (NSString*) cg;
{
return AUTORELEASE([[self alloc] initWithNome: nm WithCognome:cg]);
}
- initWithNome: (NSString*)nm WithCognome: (NSString*) cg

{
self = [super init];
if (self != nil) {
nome = nm;
cognome = cg;
}
return self;
}
- init
{
return [self initWithNome: @"" WithCognome: @""];
}
- (void) setName: (NSString*) nm

{
[nm retain];
[nome release];
nome = nm;
}

{
[cg retain];
[cognome release];
cognome = cg;
}
- (NSString*) Nome
{
return nome;
}
- (NSString*) Cognome
{
return cognome;
}
- (void) dealloc
A.Bellini, A.Guidi,
{
[nome release];
[cognome release];
[super dealloc];
}
@end
@implementation Studente
+ (id) studenteWithNome: (NSString*) nm WithCognome: (NSString*) cg WithMedia:
(int) md WithCorso: (NSString*)
cr
{
return AUTORELEASE([[self alloc] initWithNome: nm WithCognome:cg WithMedia: md
WithCorso: cr]);
}
- initWithNome: (NSString*)nm WithCognome: (NSString*) cg WithMedia: (int) md

WithCorso: (NSString*) cr
{
self = [super initWithNome: nm WithCognome: cg];
if (self != nil) {
media = md;
corso = cr;
}
return self;
}
- init
{
return [self initWithNome: @"" WithCognome: @"" WithMedia: 0 WithCorso: @""];
}
- AlzaMedia
{
media = media +1;
- (void) setMedia: (int) md

{
media = md;
}
- (void) setCorso: (NSString*) cr;

{
[cr retain];
[corso release];
corso = cr;
}
- (int) Media
{
return media;
}
- (NSString*) Corso
{
return corso;
}
- (void) dealloc
A.Bellini, A.Guidi,
{
[corso release];
[super dealloc];
}
@end

{
// Crea un istanza di Studente
NSAutoreleasePool * pool = [NSAutoreleasePool new];
Studente* marcovaldo =
[Studente studenteWithNome: @"Luciano" WithCognome:@"Marcovaldo" WithMedia: 24
WithCorso:@"Giurisprudenza"];
NSString* nome = [marcovaldo Nome];
NSString* cognome = [marcovaldo Cognome];
int media = [marcovaldo Media];
NSString* corso = [marcovaldo Corso];
NSLog(@"La mia prima persona ha nome %@, cognome %@, media %u e corso %@", nome,
cognome, media, corso);
[marcovaldo AlzaMedia];
media = [marcovaldo Media];
NSLog(@"Nuova Media %u", media);

[pool drain];
return (0);
}
Lasciamo al lettore il compito di estendere il programma per la gestione degli esemi, dei voti e il calcolo della media.

Isbn6821-0 SoluzioneDegliEsercizi

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Isbn6821-0 SoluzioneDegliEsercizi

Caricato da

Copyright:

Formati disponibili

Linguaggio C, Una guida alla programmazione con elementi di Objective-C 5/ed

Soluzioni degli esercizi (Applica le abilità)

 SUGGERIMENTI DI PROGRAMMAZIONE Non si riescono a leggere i risultati nella finestra di

printf("Un tasto qualsiasi per continuare\n");

/* Somma incrociata di due vettori */

/* Somma incrociata a+b */

printf("\nSomma incrociata a+b\n");

/* Funzione che visualizza i numeri interi positivi

/* Funzione che visualizza i numeri interi positivi

alto = 0; basso = n - 1; pos = -1;

La chiamata alla funzione di ricerca sequenziale diventa:

La funzione di ricerca sequenziale diventa:

Modifiche analoghe devono essere apportate per la ricerca binaria.

#define MAX_ELE 1000 /* massimo numero di elementi */

for(i = 0; i < n; i++) {

while (ele != vet[i] && i < n-1) ++i;

alto = 0; basso = n - 1; pos = -1;

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

for(i = 0; i < n; i++) {

for(i = 0; i < n; i++) {

Se non si inserisce nella giusta posizione il carattere di fine stringa:

visualizza ulteriori caratteri dopo 1234. Vediamo una soluzione alternativa.

/* II Esempio di uso di memcpy */

int immissione(int *);

int n; /* lunghezza prima sequenza */

int immissione(int *vet)

for(i = 0; i < n; i++) {

void ordinamento(int n, int *vet)

void visualizzazione( int n, int *vet)

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

/* Fusione delle due sequenze (merge) */

int immissione(int *);

int n; /* lunghezza prima sequenza */

int immissione(int *vet)

for(i = 0; i < n; i++) {

void ordinamento(int n, int *vet)

void visualizzazione( int n, int *vet)

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

/* Fusione delle due sequenze (merge) */

#define MAX_ELE 1000 /* massimo numero di elementi */

int immissione(int *vet)

for(i = 0; i < n; i++) {

void ordinamento(int n, int *vet)

while (ele != vet[i] && i < n-1) ++i;

void visualizzazione( int n, int *vet)

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

/* Calcolo del prodotto di due matrici

void immissioneMatrice(int, int, int [MAX_ELE][MAX_ELE]);

void immissioneMatrice(int righe, int colonne, int mat[MAX_ELE][MAX_ELE])

void prodottoMatrici(int n, int m, int p, int mat1[MAX_ELE][MAX_ELE], int

void visualizzazioneMatrice(int righe, int colonne, int mat[MAX_ELE][MAX_ELE])

/* Ricerca di un elemento in una matrice bidimensionale con l'uso di funzioni */

void immissioneMatrice(int, int, int [MAX_ELE][MAX_ELE]);

void immissioneMatrice(int righe, int colonne, int mat[MAX_ELE][MAX_ELE])

void ricercaElementoNellaMatrice(int n, int m, int mat[MAX_ELE][MAX_ELE])

void visualizzazioneMatrice(int righe, int colonne, int mat[MAX_ELE][MAX_ELE])

/* Numero elementi allocati nel vettore auto */

/* Presenta il menu e lancia la funzione scelta */

/* Inserisce un automobile nella lista della auto */

/* Numero elementi allocati nel vettore auto */

/* Presenta il menu e lancia la funzione scelta */

/* Inserisce un automobile nella lista della auto */

printf("\nCodice Modello : ");

struct elemento eliminaDivN(struct elemento p)

struct elemento inserimento(struct elemento p)

struct elemento inserimento(struct elemento );