Argomento di Programmazione 1. Fatto a lezione a ottobre, deck 5.1, parte centrale: slide 34-43 (tipi definiti dal programmatore, struct, dot notation), slide 44-58 (esempi: scheda di biblioteca, intersezione di rette, memoria allocata, rettangolo), slide 59-68 (typedef), slide 69-76 (enum). Il resto del deck (tipi predefiniti, sizeof, conversioni) è in Tipi di dati e conversioni. L’accesso ai campi attraverso un puntatore (p->campo) è in Puntatori.
Il filo di questa parte del deck:
tipi user-defined struct, bit-field, union, enum, typedef
|
struct aggrega campi di tipo DIVERSO (l'array solo dello stesso tipo)
| definizione del tipo (niente memoria) + dichiarazione (memoria)
dot notation variabile.campo, ha la precedenza più alta
|
esempi scheda biblioteca, rette, Impiegato, rettangolo di punti
|
typedef un nome nuovo per un tipo esistente: Stringa, Data, Vettore
|
enum un tipo con pochi valori con nome: {lun, mar, ...} = 0, 1, ...
|
array di struct dati[i].campo: lo schema della domanda 6 della provetta
1Definizioni
Tipi definiti dal programmatore (slide 34). Il C offre cinque modi:
struct: strutture che raggruppano variabili di tipo diverso;- bit-field: strutture che permettono di accedere ai singoli bit di una parola;
union: la stessa porzione di memoria vista con tipi diversi;enum(enumerazione): una lista di simboli;typedef: nuovi nomi per tipi esistenti.
Nel corso si usano struct, enum e typedef. Bit-field e union sono solo citati.
struct (slide 35-39). L’array non va bene per oggetti fatti di parti di tipo diverso. Un impiegato ha nome, cognome, codice fiscale (testo), stipendio (numero con decimali): con un array dovresti scegliere un tipo solo. Il costruttore struct permette di definire variabili strutturate che aggregano informazioni eterogenee, in contrasto con l’array. Ogni elemento si chiama campo (field).
struct Impiegato { definizione del TIPO "struct Impiegato"
char Nome[20];
char Cognome[20];
float Stipendio;
char CodiceFiscale[16];
};
Sintassi generale:
struct IdStruttura {
Tipo1 nomeCampo1;
Tipo2 nomeCampo2;
...
TipoN nomeCampoN;
} IdVar; IdVar è facoltativo: dichiara subito una variabile
Confronto con l’array, che è il punto concettuale:
| array | struct | |
|---|---|---|
| elementi | tutti dello stesso tipo | di tipo diverso |
| si accede con | un indice calcolato: a[i] | un nome fisso: s.campo |
| si può scorrere con un ciclo | sì | no (i campi hanno nomi) |
assegnazione in blocco x = y | no | sì, copia tutti i campi |
confronto x == y | no (confronta indirizzi) | no, non compila |
Definizione e dichiarazione (slide 36-37). La definizione struct Impiegato { ... }; crea un tipo: è uno stampo, e da sola non alloca memoria. La dichiarazione crea una variabile di quel tipo, e lì si alloca memoria. Si può dichiarare insieme alla definizione o dopo:
struct Impiegato { ... } amministratore, segretario; definizione + dichiarazione
struct Impiegato staff1, staff2; dichiarazione, dopo
In C il nome del tipo è struct Impiegato, con la parola struct davanti: scrivere solo Impiegato staff1; non compila (in C++ sì). Per non ripetere struct si usa typedef.
Dot notation (slide 40-42). Ai campi di una variabile struct si accede con il punto: staff1.Stipendio = 0.0;. Il punto sta nel gruppo di precedenza più alta (notazione suffissa, con (), [] e ->), associatività da sinistra a destra. Un campo si usa come una variabile normale del suo tipo:
if (staff1.Stipendio < 2000)
staff1.Stipendio = 1.5 * staff1.Stipendio;
Per la precedenza, &r1.m è &(r1.m): l’indirizzo del campo, quello che serve a scanf. E con campi annidati il punto si ripete da sinistra: r.top_left.x è il campo x del campo top_left di r.
typedef (slide 59-63). Dà un nome nuovo a un tipo che esiste già (built-in o strutturato): un sinonimo. Il nuovo tipo eredita le operazioni del tipo di partenza. Il prof la chiama un’operazione di “traduzione lessicale”: il compilatore sostituisce il nome con il tipo vero. Va messo fra le costanti e le variabili.
typedef int intero; intero numero; è un int
typedef char Stringa[20]; Stringa nome = "Mario"; è un char[20]
typedef struct { nome del tipo dopo la graffa
Tipo1 nomeCampo1;
...
} NomeTipo;
La forma typedef struct { ... } NomeTipo; è quella delle prove d’esame: dopo, le variabili si dichiarano con NomeTipo x;, senza struct.
enum (slide 69-76). Definisce un nuovo tipo le cui variabili possono assumere solo un numero finito e predeterminato di valori, elencati con un nome:
enum giorno {lun, mar, mer, gio, ven, sab, dom}; definizione
enum giorno birth; dichiarazione
if (birth == mar) ...
Internamente ogni valore è una costante intera, a partire da 0 e crescente di 1: lun è 0, mar 1, …, dom 6. Per questo valgono automaticamente gli operatori degli interi (minore, uguale, maggiore). Se si assegna un valore a una costante, le successive continuano da lì:
enum months {Jan = 1, Feb, Mar, ..., Dec}; Feb = 2, Mar = 3, ..., Dec = 12
Perché usarlo invece di un int: birth <mark> mar si legge, birth </mark> 1 no; e il tipo dichiara quali valori hanno senso.
2Concetti
2.1Quanta memoria occupa una struct
(slide 53-56) Le domande del prof:
- Viene allocata memoria con la sola definizione
struct Impiegato { ... };? No: è un tipo, non una variabile. - Con definizione e dichiarazione
struct Impiegato { ... } employee1, employee2;? Sì: due variabili. - Quanta? Ogni variabile occupa almeno la somma dei campi: byte, quindi 120 byte per due.
#include <stdio.h>
struct impiegato {
char nome[20];
char cognome[20];
float stipendio;
char codice_fiscale[16];
};
int main(void)
{
struct impiegato employee1;
struct impiegato employee2;
printf("sizeof(struct impiegato)=%zu\n", sizeof(struct impiegato));
printf("due variabili: %zu byte\n", sizeof(employee1) + sizeof(employee2));
return 0;
}
Output (verificato): sizeof(struct impiegato)=60 e due variabili: 120 byte.
“Almeno” perché il compilatore può inserire byte vuoti (padding) per allineare i campi: un int o un float da 4 byte sta a un indirizzo multiplo di 4, così la CPU lo legge in un colpo. In Impiegato il float cade all’offset 40, già multiplo di 4, e non serve padding. In questa struct invece sì:
#include <stdio.h>
typedef struct {
char c;
int i;
char d;
} sparsa;
typedef struct {
int i;
char c;
char d;
} compatta;
typedef char stringa[20];
int main(void)
{
stringa nome = "Mario";
printf("%zu %zu %zu %s\n", sizeof(sparsa), sizeof(compatta), sizeof(nome), nome);
return 0;
}
Output (verificato): 12 8 20 Mario.
In sparsa: c all’offset 0, 3 byte di padding, i a 4-7, d a 8, altri 3 byte per arrivare a un multiplo di 4: 12. In compatta gli stessi campi in altro ordine stanno in 8. Per gli esercizi d’esame basta la somma dei campi, ma sizeof è la risposta vera.
2.2typedef e quello che nasconde
(slide 62, 65-68) La domanda del prof su typedef char Stringa[20];: “cosa ci perdiamo in questa traduzione da array di 20 char a Stringa?”. Ci perdiamo la visibilità che si tratta di un array: Stringa nome; sembra una variabile semplice, ma resta un array di 20 char, quindi non si assegna con nome = "Luigi";, non si confronta con l’uguaglianza, ha spazio per 19 caratteri più '\0'. Il nome nuovo non cambia le regole, le nasconde.
Quando conviene (slide 65-66): typedef double VettoreDiReali[20]; VettoreDiReali v1, v2, v3; non è più chiaro di double v1[20], v2[20], v3[20];. Invece
typedef double PioggeMensili[12];
typedef double IndiciBorsa[12];
PioggeMensili Piogge01, Piogge02, Piogge03;
IndiciBorsa Indici01, Indici02, Indici03;
è preferibile a sei double ...[12]: il nome dice cosa contiene la variabile, anche se il tipo sotto è lo stesso.
Le matrici (slide 67-68) si possono costruire come array di array, anche con typedef:
int matrice1[20][20];
int matriceTridimensionale1[10][20][30]; elemento: matriceTridimensionale1[2][8][15]
typedef int Vettore[20];
typedef Vettore MatriceIntera20Per20[20]; array di 20 Vettore
typedef int MatriceIntera20Per20[20][20]; stessa cosa, più breve
2.3enum con typedef
(slide 74-76) Per non riscrivere enum giorno a ogni dichiarazione si dà un nome al tipo:
typedef enum {lun, mar, mer, gio, ven, sab, dom} GiornoSettimana;
GiornoSettimana giorno;
giorno = mar;
printf("%d", giorno); stampa 1
printf non conosce i nomi delle costanti: stampa l’intero. Per stampare "mar" serve uno switch sul valore (o un array di stringhe indicizzato dal valore), come nelle prove al calcolatore.
Un programma che mette insieme typedef, enum e struct:
#include <stdio.h>
typedef enum { LUN, MAR, MER, GIO, VEN, SAB, DOM } giorno_settimana;
typedef enum { GEN = 1, FEB, MAR_MESE, APR, MAG, GIU, LUG, AGO, SET, OTT, NOV, DIC } mese_anno;
typedef struct {
int giorno;
mese_anno mese;
int anno;
} data;
int main(void)
{
giorno_settimana g = MAR;
data d1 = {14, OTT, 2026};
data d2;
printf("%d %d %d\n", g, DOM, OTT);
d2 = d1;
d2.anno++;
printf("d1: %d/%d/%d d2: %d/%d/%d\n", d1.giorno, d1.mese, d1.anno, d2.giorno, d2.mese, d2.anno);
if (d1.anno < d2.anno)
printf("d1 < d2\n");
for (g = LUN; g <= DOM; g++)
if (g >= SAB)
printf("%d e' weekend\n", g);
return 0;
}
Output (verificato):
1 6 10
d1: 14/10/2026 d2: 14/10/2027
d1 < d2
5 e' weekend
6 e' weekend
Tre cose da notare. Le costanti di tutti gli enum stanno nello stesso spazio dei nomi: MAR non può essere sia martedì sia marzo, per questo il mese si chiama MAR_MESE. d2 = d1 copia tutta la struct, e modificare d2.anno non tocca d1. Un enum si incrementa e si confronta come un intero.
2.4Assegnazione fra struct: è una copia
b = a; fra due variabili dello stesso tipo struct copia tutti i campi, anche quelli array. È l’unico caso in cui un array viene copiato con una sola assegnazione: da solo nome = altro_nome; non compila, dentro una struct viaggia con lei. Dopo la copia le due variabili sono indipendenti: sono due blocchi di memoria distinti, e cambiare l’una non tocca l’altra.
#include <stdio.h>
typedef struct {
char nome[10];
int punti;
} squadra;
int main(void)
{
squadra a = {"Inter", 3};
squadra b;
b = a;
b.punti += 3;
a.punti = b.punti * 2;
b.nome[0] = 'i';
printf("%s %d\n", a.nome, a.punti);
printf("%s %d\n", b.nome, b.punti);
return 0;
}
| istruzione | a | b |
|---|---|---|
| dichiarazioni | ”Inter”, 3 | indefinito |
b = a; | ”Inter”, 3 | ”Inter”, 3 |
b.punti += 3; | ”Inter”, 3 | ”Inter”, 6 |
a.punti = b.punti * 2; | ”Inter”, 12 | ”Inter”, 6 |
b.nome[0] = 'i'; | ”Inter”, 12 | ”inter”, 6 |
Output (verificato):
Inter 12
inter 6
La minuscola compare solo in b: l’array nome è stato copiato, non condiviso. Il confronto a <mark> b invece non compila (invalid operands to binary </mark>): si confrontano i campi uno per uno.
2.5Array di struct
Un array può avere come elementi delle struct: studente classe[30]; sono 30 struct una dopo l’altra in memoria. Si legge da sinistra a destra, come la dot notation:
classe l'array intero
classe[1] la seconda struct (tipo studente)
classe[1].voto il campo voto della seconda struct (tipo int)
classe[1].nome[0] il primo carattere del nome della seconda struct (tipo char)
classe.voto[1] non compila: classe è un array, non ha campi. gcc lo dice a modo suo, '(studente *)&classe' is a pointer; did you mean to use '->'? (verificato), perché il nome dell’array vale come puntatore al primo elemento (vedi Puntatori). L’indice va sull’array, il punto sull’elemento. Ogni elemento occupa sizeof(studente) byte, qui .
Gli algoritmi sono quelli di Array (contare, sommare, massimo, ricerca), con una differenza sola: la condizione o la somma guardano un campo dell’elemento. Lo schema è sempre lo stesso:
inizializza contatori / somme / indice del migliore PRIMA del ciclo
for (i = 0; i < N; i++)
se dati[i].campo soddisfa la condizione: aggiorna
stampa DOPO il ciclo
Esempio 1, la domanda 6 della prova del 22/10/2024 (prova 2024, pagina 2). Date le dichiarazioni
#define N 10
typedef struct Dato{
float valore;
int indice;
}Dato;
Dato dati[N];
scrivere un algoritmo che stampi quanti elementi hanno nel campo indice un valore minore di 5 e quanti hanno il campo valore compreso fra e , estremi inclusi.
Si riconosce un conteggio con condizione, due volte. Servono due contatori separati, perché un elemento può soddisfare una condizione, l’altra, entrambe o nessuna: con un else fra i due if un elemento con tutte e due le proprietà verrebbe contato una volta sola. “Compreso fra, estremi inclusi” è >= -1.5 && <= 1.5, mai -1.5 <= x <= 1.5. Il programma completo, con un array di prova riempito nella dichiarazione (all’esame basta il ciclo con i due contatori):
#include <stdio.h>
#define N 10
typedef struct Dato {
float valore;
int indice;
} Dato;
int main(void)
{
Dato dati[N] = {{0.5f, 7}, {-2.0f, 8}, {1.5f, 5}, {3.2f, 1}, {-1.5f, 4},
{0.0f, 9}, {7.1f, 2}, {-0.7f, 6}, {1.6f, 0}, {-3.0f, 5}};
int i;
int quanti_indice = 0;
int quanti_valore = 0;
for (i = 0; i < N; i++) {
if (dati[i].indice < 5)
quanti_indice++;
if (dati[i].valore >= -1.5f && dati[i].valore <= 1.5f)
quanti_valore++;
}
printf("indice < 5: %d\n", quanti_indice);
printf("valore in [-1.5, 1.5]: %d\n", quanti_valore);
return 0;
}
i | dati[i].valore | dati[i].indice | indice < 5 | valore in | quanti_indice | quanti_valore |
|---|---|---|---|---|---|---|
| 0 | 0.5 | 7 | no | sì | 0 | 1 |
| 1 | -2.0 | 8 | no | no | 0 | 1 |
| 2 | 1.5 | 5 | no (5 < 5 falso) | sì (estremo) | 0 | 2 |
| 3 | 3.2 | 1 | sì | no | 1 | 2 |
| 4 | -1.5 | 4 | sì | sì (estremo) | 2 | 3 |
| 5 | 0.0 | 9 | no | sì | 2 | 4 |
| 6 | 7.1 | 2 | sì | no | 3 | 4 |
| 7 | -0.7 | 6 | no | sì | 3 | 5 |
| 8 | 1.6 | 0 | sì | no | 4 | 5 |
| 9 | -3.0 | 5 | no | no | 4 | 5 |
Output (verificato): indice < 5: 4 e valore in [-1.5, 1.5]: 5. Le righe 2 e 4 sono il controllo degli estremi: con < e > al posto di <= e >= il secondo conteggio darebbe 3. Il confronto con l’estremo 1.5 fra float qui è esatto, perché si scrive in binario con un numero finito di cifre (1.1); con un estremo come 0.1 non sarebbe così (vedi Tipi di dati e conversioni).
Esempio 2, media con condizione e massimo. Media dei voti dei maggiorenni (con un messaggio se non ce ne sono) e nome dello studente con il voto più alto. Si riconoscono due schemi nello stesso ciclo: somma e conteggio condizionati (la media si calcola dopo il ciclo, e solo se il conteggio non è zero), e massimo con indice del migliore, così alla fine si ha accesso a tutti i suoi campi.
#include <stdio.h>
#define N 5
typedef struct {
char nome[20];
int eta;
float voto;
} studente;
int main(void)
{
studente classe[N] = {{"Anna", 19, 27.5f}, {"Bruno", 17, 29.0f}, {"Carla", 20, 24.0f},
{"Dario", 18, 29.0f}, {"Elena", 16, 22.5f}};
int i;
int imax = 0;
int quanti = 0;
float somma = 0;
for (i = 0; i < N; i++) {
if (classe[i].eta >= 18) {
somma += classe[i].voto;
quanti++;
}
if (classe[i].voto > classe[imax].voto)
imax = i;
}
if (quanti > 0)
printf("media maggiorenni: %.2f\n", somma / quanti);
else
printf("nessun maggiorenne\n");
printf("voto piu' alto: %s (%.1f)\n", classe[imax].nome, classe[imax].voto);
return 0;
}
i | nome | eta >= 18 | somma | quanti | voto > classe[imax].voto | imax |
|---|---|---|---|---|---|---|
| 0 | Anna | sì | 27.5 | 1 | 27.5 > 27.5 no | 0 |
| 1 | Bruno | no | 27.5 | 1 | 29.0 > 27.5 sì | 1 |
| 2 | Carla | sì | 51.5 | 2 | 24.0 > 29.0 no | 1 |
| 3 | Dario | sì | 80.5 | 3 | 29.0 > 29.0 no | 1 |
| 4 | Elena | no | 80.5 | 3 | 22.5 > 29.0 no | 1 |
Dopo il ciclo: . Output (verificato): media maggiorenni: 26.83 e voto piu' alto: Bruno (29.0). somma è float, quindi la divisione per l’intero quanti è fra reali; con int somma servirebbe il cast (float)somma / quanti. Dario ha lo stesso voto di Bruno ma non lo sostituisce: col > vince il primo trovato, col >= vincerebbe l’ultimo.
3Metodo
Definire una struct per un oggetto del problema.
- Elenca le informazioni dell’oggetto e scegli per ognuna il tipo: testo in
char nome[N](con = lunghezza massima + 1), interi inint, decimali infloat, valori da un elenco chiuso in unenum. - Scrivi
typedef struct { ... } NomeTipo;prima dimain. - Dichiara le variabili, singole o in array:
NomeTipo elenco[DIM];.
Inizializzare. Con una lista fra graffe, nell’ordine dei campi: data d = {14, OTT, 2026};. Per una struct annidata, graffe annidate: {{1, 5}, {4, 2}}. I campi non elencati valgono 0, come per gli array.
Leggere da tastiera. Un scanf per campo, con & per i campi numerici e senza & per i campi stringa (sono array): scanf("%d", &s.anno), scanf("%19s", s.autore).
Stampare un enum come testo. switch (x.tipo) { case A: printf("A"); break; ... default: printf("N/A"); }.
Copiare e confrontare. La copia è y = x;. Il confronto si fa campo per campo; per i campi stringa, carattere per carattere (vedi Stringhe).
Algoritmo su un array di struct (domanda 6 della provetta).
- Leggi la consegna e scrivi accanto a ogni richiesta lo schema: “quanti” è un contatore, “media” è somma più contatore, “il più alto” è un indice del migliore, “c’è / dove sta” è una ricerca.
- Dichiara e inizializza contatori e somme prima del ciclo (a 0), l’indice del migliore a 0.
- Un solo
for (i = 0; i < N; i++); dentro, unifseparato per ogni richiesta, con il campo giusto:dati[i].campo. - Traduci gli intervalli con
&&ed estremi espliciti: “fra e inclusi” èx >= a && x <= b. - Dopo il ciclo: le divisioni (con il contatore diverso da 0) e le stampe.
- Controlla su un array piccolo inventato da te, con un elemento sugli estremi e uno che soddisfa entrambe le condizioni.
Calcolare la memoria. Somma delle dimensioni dei campi (char 1, int e float 4, double 8, array: dimensione per numero di celle), moltiplicata per il numero di variabili dichiarate. La sola definizione vale zero.
4Esempi svolti a lezione
4.1Inizializzazione di una data
(slide 43) La slide definisce struct Data { int giorno; int mese; int anno; };, dichiara struct Data mia-data; e assegna i campi uno a uno. Due errori:
mia-datanon è un identificatore valido: il trattino è l’operatore meno, quindi il compilatore leggemia - data. Si scrivemia_data;- l’ultima riga è
mia-data.giorno=1999;: va nel campoanno. E il commento “Lunedì=1, Martedì=2” sugiorno=2confonde il giorno del mese con quello della settimana.
Versione corretta: struct Data mia_data; mia_data.giorno = 2; mia_data.mese = 12; mia_data.anno = 1999;, oppure in una riga struct Data mia_data = {2, 12, 1999};. Per i campi array e stringa valgono le regole viste per gli array: si inizializzano nella dichiarazione, non si assegnano dopo.
4.2Scheda di biblioteca
(slide 44-45) Inizializzare due schede di biblioteca, una nel programma e una da tastiera, e stamparle. Il codice del prof, con i controlli di lettura e la larghezza nei %s:
#include <stdio.h>
struct scheda {
char autore[20];
char titolo[100];
int anno;
};
int main(void)
{
struct scheda prima;
struct scheda seconda = {"Moravia", "Indifferenti", 1990};
int a[10];
printf("Autore?\n");
if (scanf("%19s", prima.autore) != 1)
return 1;
printf("Titolo?\n");
if (scanf("%99s", prima.titolo) != 1)
return 1;
printf("Anno?\n");
if (scanf("%d", &prima.anno) != 1)
return 1;
printf("Prima scheda\n");
printf(" Autore=%s\n", prima.autore);
printf(" Titolo=%s\n", prima.titolo);
printf(" Anno=%d\n", prima.anno);
printf("Seconda scheda\n");
printf(" Autore=%s\n", seconda.autore);
printf(" Titolo=%s\n", seconda.titolo);
printf(" Anno=%d\n", seconda.anno);
printf("sizeof scheda prima: %zu\n", sizeof(prima));
printf("sizeof array di interi a: %zu\n", sizeof(a));
return 0;
}
Con input Calvino, Palomar, 1983 stampa (verificato):
Autore?
Titolo?
Anno?
Prima scheda
Autore=Calvino
Titolo=Palomar
Anno=1983
Seconda scheda
Autore=Moravia
Titolo=Indifferenti
Anno=1990
sizeof scheda prima: 124
sizeof array di interi a: 40
I commenti del prof sul scanf("%s", Prima.Autore): legge la stringa ignorando gli spazi bianchi iniziali, aggiunge '\0' alla fine, e termina quando ha finito di fare match, cioè al primo spazio. Quindi un titolo come Gli indifferenti non si legge così: entrerebbe solo Gli. La memoria: byte per la scheda, per l’array, nessun padding (l’int cade all’offset 120, multiplo di 4).
4.3Intersezione di due rette
(slide 46-52) Ogni retta è rappresentata da una struct con coefficiente angolare e intercetta . Il punto d’intersezione si ricava uguagliando le due :
e poi . La divisione richiede : due rette con la stessa pendenza sono parallele (nessun punto comune) o coincidenti (infiniti). La soluzione delle slide 48-52 (main() senza int, senza la graffa di apertura) non controlla questo caso. Versione corretta:
#include <stdio.h>
struct retta {
float m;
float d;
};
int main(void)
{
struct retta r1;
struct retta r2;
float x;
printf("Coeff. angolare 1? ");
if (scanf("%f", &r1.m) != 1)
return 1;
printf("Intercetta 1? ");
if (scanf("%f", &r1.d) != 1)
return 1;
printf("Coeff. angolare 2? ");
if (scanf("%f", &r2.m) != 1)
return 1;
printf("Intercetta 2? ");
if (scanf("%f", &r2.d) != 1)
return 1;
printf("\nRetta 1: y = %fx + %f\n", r1.m, r1.d);
printf("Retta 2: y = %fx + %f\n", r2.m, r2.d);
if (r1.m == r2.m) {
printf("Rette parallele: nessun punto o infiniti punti comuni\n");
return 0;
}
x = (r1.d - r2.d) / (r2.m - r1.m);
printf("Punto d'intersezione (%f,%f)\n", x, r1.m * x + r1.d);
return 0;
}
Con l’input della slide 47 (, , , ) le ultime tre righe sono (verificato):
Retta 1: y = -5.000000x + 1.400000
Retta 2: y = 10.400000x + -4.300000
Punto d'intersezione (0.370130,-0.450649)
Controllo a mano: , . Con 2 1 2 5 stampa il messaggio delle rette parallele. Qui il confronto r1.m == r2.m fra float è accettabile perché i valori sono letti, non calcolati; con valori calcolati servirebbe la soglia di Tipi di dati e conversioni. Il + -4.300000 è l’effetto di stampare + %f con un numero negativo.
4.4Un rettangolo fatto di punti
(slide 57-58) Definire un rettangolo con i lati paralleli agli assi a partire da una struct punto: bastano due vertici opposti, perché gli altri due si ricavano. Una struct può avere come campo un’altra struct. Il prof scrive topleft e bottomright; qui con nomi italiani e con un uso:
#include <stdio.h>
struct punto {
int x;
int y;
};
struct rettangolo {
struct punto top_left;
struct punto bottom_right;
};
int main(void)
{
struct rettangolo r = {{1, 5}, {4, 2}};
struct punto p = {3, 3};
int base;
int altezza;
base = r.bottom_right.x - r.top_left.x;
altezza = r.top_left.y - r.bottom_right.y;
printf("base=%d altezza=%d area=%d\n", base, altezza, base * altezza);
if (p.x >= r.top_left.x && p.x <= r.bottom_right.x && p.y <= r.top_left.y && p.y >= r.bottom_right.y)
printf("(%d,%d) e' dentro\n", p.x, p.y);
else
printf("(%d,%d) e' fuori\n", p.x, p.y);
return 0;
}
Output (verificato): base=3 altezza=3 area=9 e (3,3) e' dentro. Il vertice in alto a sinistra ha la più piccola e la più grande: la base è la differenza delle , l’altezza quella delle nell’ordine opposto. Il punto è dentro se la sua sta fra le due e la sua fra le due .
4.5Esempi di enum dalle slide
(slide 73, 76) Monete e mesi, più un caso con valori espliciti in mezzo all’elenco:
#include <stdio.h>
enum coin { NICKEL, DIME, QUARTER, DOLLAR };
int main(void)
{
enum coin money = DIME;
enum colore { ROSSO = 2, VERDE, BLU = 10, GIALLO };
if (money == QUARTER)
printf("is a quarter\n");
else
printf("money=%d\n", money);
printf("%d %d %d %d\n", ROSSO, VERDE, BLU, GIALLO);
return 0;
}
Output (verificato): money=1 e 2 3 10 11. DIME è la seconda costante, quindi 1. Nel colore, ogni costante senza valore esplicito vale la precedente più 1: VERDE segue ROSSO, GIALLO segue BLU. La slide 64 scrive typedef enum (Gen, Feb, …, Dic) meseAnno; con le tonde: un enum si definisce con le graffe.
5Esercizi tipo esame
In una pagina a parte, dal più facile al livello del 30: Struct, typedef ed enum (esercizi).
6Errori tipici
- Dimenticare il
;dopo la graffa che chiude la definizione di unastruct. - Dichiarare
nomeStruct x;in C senzastructdavanti e senzatypedef. - Pensare che la definizione del tipo allochi memoria.
- Assegnare una stringa a un campo array (
s.nome = "Anna"), o confrontare due struct con l’uguaglianza. &mancante davanti ai campi numerici inscanf,&di troppo davanti ai campi stringa.- Credere che
b = afra struct crei un collegamento: è una copia. - Usare nomi con il trattino (
mia-data, slide 43): il trattino è il meno. - Definire un
enumcon le tonde (slide 64), o usare la stessa costante in dueenum. - Stampare un
enumcon%s: è un intero, si stampa con%do si traduce con unoswitch. - Calcolare la memoria di una struct dimenticando le celle degli array (
char nome[20]sono 20 byte, non 1). classe.voto[i]al posto diclasse[i].voto: l’indice va sull’array, il punto sull’elemento.- Contatori e somme non inizializzati a 0, o inizializzati dentro il ciclo (ripartono da 0 a ogni giro).
- Due conteggi indipendenti scritti con
if ... else if: un elemento che soddisfa entrambe le condizioni viene contato una volta sola. - Media calcolata dentro il ciclo, o divisa per zero quando nessun elemento soddisfa la condizione, o fatta fra interi (
somma / quanticonint sommatronca). - Estremi sbagliati: “compreso fra e estremi inclusi” con
<al posto di<=.
7Domande
-
Quali sono i cinque modi per definire nuovi tipi in C?
-
Cos’è una
structe in cosa differisce da un array? -
Che differenza c’è fra definire una
structe dichiarare una variabile di quel tipo? Quando si alloca memoria? -
Quanta memoria occupano
employee1edemployee2di tipostruct Impiegato(duechar[20], unfloat, unchar[16])? Perchésizeofpuò dare di più della somma dei campi? -
Come si accede a un campo di una
struct? E a un campo di unastructannidata? -
Cosa succede con l’assegnazione
b = afra due variabilistruct? E conb == a? -
Cosa fa
typedef? Cosa “si perde” contypedef char Stringa[20];? -
Cos’è un
enum? Che valori interi prendono le costanti, anche quando alcune hanno un valore esplicito? -
Come si stampa come testo il valore di un campo
enum? -
Dopo
b = a;fra due struct con un campo array, modificareb.nome[0]cambia anchea.nome? Perché? -
Con
studente classe[30];, come si scrive il voto del quarto studente e la prima lettera del suo nome? Perchéclasse.voto[3]non compila? -
In un algoritmo che conta quanti elementi soddisfano due condizioni diverse, perché servono due
ifseparati e non unif ... else if? -
Come si traduce in C “il campo
valoreè compreso fra e , estremi inclusi”? -
Per stampare il nome dello studente con il voto più alto, conviene tenere il voto massimo o l’indice del migliore? Cosa cambia fra
>e>=nel confronto?