Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
Lezione
ott, giorno?
in corso

Struct, typedef ed enum

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:

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:

arraystruct
elementitutti dello stesso tipodi tipo diverso
si accede conun indice calcolato: a[i]un nome fisso: s.campo
si può scorrere con un ciclosìno (i campi hanno nomi)
assegnazione in blocco x = ynosì, copia tutti i campi
confronto x == yno (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:

  1. Viene allocata memoria con la sola definizione struct Impiegato { ... };? No: è un tipo, non una variabile.
  2. Con definizione e dichiarazione struct Impiegato { ... } employee1, employee2;? Sì: due variabili.
  3. Quanta? Ogni variabile occupa almeno la somma dei campi: 20+20+4+16=6020 + 20 + 4 + 16 = 60 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;
}
istruzioneab
dichiarazioni”Inter”, 3indefinito
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 20+4=2420 + 4 = 24.

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 −1.5-1.5 e +1.5+1.5, 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;
}
idati[i].valoredati[i].indiceindice < 5valore in [−1.5,1.5][-1.5, 1.5]quanti_indicequanti_valore
00.57nosì01
1-2.08nono01
21.55no (5 < 5 falso)sì (estremo)02
33.21sìno12
4-1.54sìsì (estremo)23
50.09nosì24
67.12sìno34
7-0.76nosì35
81.60sìno45
9-3.05nono45

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é 1.5=1+121.5 = 1 + \frac12 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;
}
inomeeta >= 18sommaquantivoto > classe[imax].votoimax
0Annasì27.5127.5 > 27.5 no0
1Brunono27.5129.0 > 27.5 sì1
2Carlasì51.5224.0 > 29.0 no1
3Dariosì80.5329.0 > 29.0 no1
4Elenano80.5322.5 > 29.0 no1

Dopo il ciclo: 80.5/3=26.83‾80.5 / 3 = 26.8\overline{3}. 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.

  1. Elenca le informazioni dell’oggetto e scegli per ognuna il tipo: testo in char nome[N] (con NN = lunghezza massima + 1), interi in int, decimali in float, valori da un elenco chiuso in un enum.
  2. Scrivi typedef struct { ... } NomeTipo; prima di main.
  3. 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).

  1. 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.
  2. Dichiara e inizializza contatori e somme prima del ciclo (a 0), l’indice del migliore a 0.
  3. Un solo for (i = 0; i < N; i++); dentro, un if separato per ogni richiesta, con il campo giusto: dati[i].campo.
  4. Traduci gli intervalli con && ed estremi espliciti: “fra aa e bb inclusi” è x >= a && x <= b.
  5. Dopo il ciclo: le divisioni (con il contatore diverso da 0) e le stampe.
  6. 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:

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: 20+100+4=12420 + 100 + 4 = 124 byte per la scheda, 10⋅4=4010 \cdot 4 = 40 per l’array, nessun padding (l’int cade all’offset 120, multiplo di 4).

4.3Intersezione di due rette

(slide 46-52) Ogni retta y=mx+dy = mx + d è rappresentata da una struct con coefficiente angolare mm e intercetta dd. Il punto d’intersezione si ricava uguagliando le due yy:

m1x+d1=m2x+d2⇒(m2−m1) x=d1−d2⇒x=d1−d2m2−m1m_1 x + d_1 = m_2 x + d_2 \quad\Rightarrow\quad (m_2 - m_1)\,x = d_1 - d_2 \quad\Rightarrow\quad x = \frac{d_1 - d_2}{m_2 - m_1}

e poi y=m1x+d1y = m_1 x + d_1. La divisione richiede m1≠m2m_1 \neq m_2: 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 (−5-5, 1.41.4, 10.410.4, −4.3-4.3) 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: x=(1.4−(−4.3))/(10.4−(−5))=5.7/15.4=0.370130x = (1.4 - (-4.3)) / (10.4 - (-5)) = 5.7 / 15.4 = 0.370130, y=−5⋅0.370130+1.4=−0.450649y = -5 \cdot 0.370130 + 1.4 = -0.450649. 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 xx più piccola e la yy più grande: la base è la differenza delle xx, l’altezza quella delle yy nell’ordine opposto. Il punto è dentro se la sua xx sta fra le due xx e la sua yy fra le due yy.

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

7Domande