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

Tipi di dati e conversioni

Argomento di Programmazione 1. Fatto a lezione a ottobre, deck 5.1, prima e ultima parte: slide 3-10 (cos’è un tipo e perché serve), slide 11-22 (int, qualificatori, sizeof), slide 23-27 (float e double, confronti), slide 28-33 (char, integral e floating), slide 77-97 (conversioni implicite ed esplicite), slide 98-102 (π con la serie di Leibniz). La parte centrale del deck (slide 34-76: struct, typedef, enum) è in Struct, typedef ed enum. Le codifiche che stanno sotto i tipi (binario, complemento a 2, virgola mobile, ASCII) sono in Rappresentazione dell’informazione.

Il filo di questa parte del deck:

tipo di dato        insieme di valori + operazioni (int: interi, + - * / %)
   |
perché servono      1) come interpretare i bit   2) quanta memoria
                    3) errori di tipo trovati dal compilatore
   |
tipi predefiniti    integral: char, short, int, long (signed o unsigned)
                    floating: float, double, long double
   |
sizeof              quanti byte occupa un tipo o un'espressione
   |
avvertenze          float == float è inaffidabile: soglia EPSILON
   |
conversioni         implicite: nelle espressioni sale al tipo "più alto",
                    nell'assegnazione va al tipo di sinistra (può troncare)
                    esplicite: il cast (float)x

1Definizioni

Tipo di dato (slide 3-5). Un tipo è caratterizzato da un insieme di valori (per esempio gli interi) e dalle operazioni su quei valori (per esempio ++, −-, ⋅\cdot, //). Le informazioni da rappresentare sono infinite: tipi noti come interi, reali, caratteri, e oggetti astratti come fatture, budget, l’archivio di una biblioteca. Un linguaggio non può prevederli tutti, quindi offre un meccanismo: pochi tipi semplici (insieme chiuso) e la possibilità di costruirne di composti (insieme aperto).

L’astrazione del tipo separa chi usa il tipo da chi sviluppa le operazioni. Esempio: chi scrive a + b con due int non sa come la CPU somma, e non gli serve. Questo permette realizzazioni diverse dello stesso tipo, che si distinguono per esempio per efficienza.

Classificazione (slide 6).

  1. Tipi predefiniti (built-in) nel linguaggio: semplici (interi, caratteri) e strutturati (array).
  2. Tipi definiti dal programmatore (user-defined): Studente, Viaggio, CodaInMensa. Sono l’argomento di Struct, typedef ed enum.

Perché i tipi sono utili (slide 7-9). Tre ragioni, in ordine:

  1. Determinano come interpretare i bit in memoria. 01100001 può essere decodificato come l’intero 97 o come il carattere 'a': lo decide il tipo della variabile.
  2. Determinano quanta memoria riservare alla variabile: un int occupa più byte di un char.
  3. Permettono di trovare gli errori di tipo durante la compilazione invece che durante l’esecuzione. I linguaggi staticamente tipati (C, C++, Java) controllano i tipi prima di eseguire; quelli dinamicamente tipati (Python, JavaScript, PHP) scoprono l’errore solo quando la riga viene eseguita.

Esempio del punto 3: in C int *p = 3.5; non compila; in Python "ciao" + 3 compila (non c’è compilazione) e fallisce solo quando l’esecuzione arriva a quella riga, magari dopo ore.

Dichiarazione e tipo (slide 10). Ogni variabile va dichiarata prima dell’uso, e nella dichiarazione si specifica il tipo, che fissa l’insieme dei valori che la variabile può assumere e le operazioni che le si possono applicare. La slide colloca le dichiarazioni “dopo main() e prima di ogni istruzione non dichiarativa”: è la regola del C89. Dal C99 si può dichiarare anche più avanti nel blocco, come si fa nelle note quando serve (for (int j = 0; ...)).

Tipi base (slide 11). int (interi), float (reali), double (reali in doppia precisione), char (caratteri). La memoria associata a ciascuno dipende dall’implementazione (compilatore e macchina), non dalla definizione del linguaggio: lo stesso programma può avere limiti diversi su macchine diverse.

int (slide 12-17). Ispirato al numero intero matematico, ma ne rappresenta solo un sottoinsieme finito. Operatori: assegnazione, +, -, *, /, %, confronti. Occupa di solito una parola di memoria (oggi 4 byte).

I qualificatori di tipo cambiano spazio e interpretazione:

Con 32 bit: int va da −231-2^{31} a 231−12^{31} - 1, unsigned int da 00 a 232−12^{32} - 1. I limiti veri della macchina stanno in <limits.h>: INT_MIN vale −2147483648-2147483648 e INT_MAX vale 21474836472147483647.

L’esempio della slide 15, 16 bit tutti a 1:

1111111111111111   -1        se la variabile è signed (CA2)
                   65535     se la variabile è unsigned

Stessi bit, due valori: è la ragione 1 dei tipi.

I tipi predefiniti (slide 77):

famigliatiposi può scrivere anche
integralchar, signed char, unsigned char
integralsigned short intsigned short, short
integralsigned intsigned, int
integralsigned long intlong int, signed long, long
integralunsigned short intunsigned short
integralunsigned intunsigned
integralunsigned long intunsigned long
floatingfloat, double, long double

Integral e floating (slide 33). I tipi integral sono rappresentati come interi e hanno un numero discreto di valori: c’è una corrispondenza biunivoca con un sottoinsieme dei naturali (puoi “numerarli”). I floating cercano di rappresentare i reali, che sono densi (fra due reali ce ne sono infiniti): la rappresentazione è per forza un insieme discreto di punti, con buchi in mezzo.

sizeof (slide 19-21). Operatore unario che restituisce l’occupazione in memoria, in byte, di un tipo o di un’espressione: sizeof(int), sizeof(x), sizeof(a) / sizeof(a[0]). Sta nel gruppo degli operatori unari (con !, ++, --, *, &, il cast), con associatività da destra a sinistra. Il valore è di tipo size_t, un intero senza segno, e si stampa con %zu. La slide dice “restituisce unsigned int, usa %lu”: su gcc a 64 bit size_t è unsigned long, quindi %lu funziona per caso; %zu è quello giusto ovunque.

float e double (slide 23-25). Derivati dai numeri razionali, spesso impropriamente chiamati “reali”. Le costanti si scrivono 315.779 o in notazione esponenziale 3.73E-5 (cioè 3.73⋅10−53.73 \cdot 10^{-5}). Rappresentazione in virgola mobile (IEEE-754, vedi Rappresentazione dell’informazione):

tipobyte tipiciordine di grandezzacifre significative
float4da 10−3810^{-38} a 103810^{38}circa 6
double8da 10−30810^{-308} a 1030810^{308}circa 15
long double8-16almeno come double

Vale float≤double≤long double\text{float} \leq \text{double} \leq \text{long double}. Gli operatori sono gli stessi degli interi ma con significato diverso: / fra floating fa la divisione vera, fra interi tronca. La slide 25 mostra che lo stesso numero ha molte scritture con mantissa ed esponente diversi: 1780000.0000023=178000.00000023⋅101=17800000000023⋅10−71780000.0000023 = 178000.00000023 \cdot 10^1 = 17800000000023 \cdot 10^{-7}.

char (slide 29-30). Di solito un byte, abbastanza per i caratteri ASCII. In C un carattere è il suo codice ASCII, cioè un intero: per questo su un char sono definite assegnazione, operazioni aritmetiche e confronti. Conseguenza: fra i caratteri c’è un ordinamento automatico. '0' (48) è “minore” di '1' (49); 'A' < 'R', '(' < '3', '5' < 'A'. I caratteri di controllo si scrivono con la barra: '\n' a capo, '\t' tab, '\b' backspace, '\r' ritorno carrello.

2Concetti

2.1Le dimensioni vere su gcc

La slide 8 dice “int di solito 2-4 byte (16 bit)” e la 13 “long 32 bit”: erano vere sui sistemi a 16 e 32 bit. L’esercizio della slide 21 chiede di misurarle. Su gcc, Linux x86-64 (la macchina di queste note):

#include <stdio.h>
#include <limits.h>

int main(void)
{
    printf("char: %zu\n", sizeof(char));
    printf("short: %zu\n", sizeof(short));
    printf("int: %zu\n", sizeof(int));
    printf("long: %zu\n", sizeof(long));
    printf("long long: %zu\n", sizeof(long long));
    printf("float: %zu\n", sizeof(float));
    printf("double: %zu\n", sizeof(double));
    printf("long double: %zu\n", sizeof(long double));
    printf("INT_MAX=%d INT_MIN=%d\n", INT_MAX, INT_MIN);
    printf("UINT_MAX=%u\n", UINT_MAX);
    printf("SHRT_MAX=%d CHAR_MIN=%d CHAR_MAX=%d\n", SHRT_MAX, CHAR_MIN, CHAR_MAX);
    return 0;
}

Output (verificato):

char: 1
short: 2
int: 4
long: 8
long long: 8
float: 4
double: 8
long double: 16
INT_MAX=2147483647 INT_MIN=-2147483648
UINT_MAX=4294967295
SHRT_MAX=32767 CHAR_MIN=-128 CHAR_MAX=127

sizeof(char) vale 1 per definizione, su ogni macchina. Gli altri valori vanno presi come “quelli di gcc”: su Windows long resta 4 byte (Dev-C++ del laboratorio). In un esercizio d’esame, se il testo non dice niente, si assume int da 4 byte.

2.2Overflow con e senza segno

Quando un risultato esce dall’intervallo del tipo:

#include <stdio.h>

int main(void)
{
    unsigned short u = 65535;
    short s = -1;
    unsigned int grande = 0;

    printf("u=%d s=%d\n", u, s);
    printf("u+1=%d\n", (unsigned short)(u + 1));
    grande = grande - 1;
    printf("0u-1=%u\n", grande);
    printf("%d %d\n", 'a', 'a' + 1);
    printf("%c %c\n", 97, 'A' + 25);
    return 0;
}

Output (verificato):

u=65535 s=-1
u+1=0
0u-1=4294967295
97 98
a Z

Le ultime due righe sono la doppia natura del char: 'a' stampato con %d è 97, il 97 stampato con %c è 'a', e 'A' + 25 è la venticinquesima lettera dopo la A, la Z.

2.3Confrontare i float

(slide 26-27) I numeri come 0.1 in binario hanno infinite cifre (come 1/3 in decimale: 0.1=0.00011‾20.1 = 0.0\overline{0011}_2, il conto passo per passo è in Rappresentazione dell’informazione, sezione “Parte frazionaria”), quindi vengono memorizzati approssimati. Due calcoli che “matematicamente” danno lo stesso valore possono differire nell’ultima cifra binaria. Le avvertenze della slide:

Il rimedio è confrontare con una soglia: x e y sono “uguali” se x sta fra y - EPSILON e y + EPSILON. (La slide 27 scrive Y + .000001 con la Y maiuscola: in C Y e y sono variabili diverse.)

#include <stdio.h>

#define EPSILON 0.000001

int main(void)
{
    double x = 0.1 + 0.2;
    double y = 0.3;
    float f = 0.1f;

    if (x == y)
        printf("uguali\n");
    else
        printf("diversi: %.17f %.17f\n", x, y);
    if (x >= y - EPSILON && x <= y + EPSILON)
        printf("uguali a meno di EPSILON\n");
    printf("%.10f\n", f);
    return 0;
}

Output (verificato):

diversi: 0.30000000000000004 0.29999999999999999
uguali a meno di EPSILON
0.1000000015

0.1+0.20.1 + 0.2 e 0.30.3 differiscono nella diciassettesima cifra: l’uguaglianza fallisce, il confronto con soglia no. L’ultima riga mostra che anche la sola costante 0.1f non è 0.1.

2.4Conversioni implicite nelle espressioni

(slide 78-82, 93) In C, quando un operando non è del tipo atteso, invece di segnalare errore si fa di solito una conversione automatica (implicita). Esempio della slide:

int i = 10;  float f = 3.0, f1;
f1 = i + f;

Per valutare i + f: (1) i viene convertito in float (10.0), (2) si fa la somma fra float. f1 vale 13.0.

Le regole della slide 93, nell’ordine in cui si applicano a un’operazione binaria:

  1. ogni char e short (con o senza segno) diventa int (promozione intera): 'a' + 1 è un int;
  2. se gli operandi hanno ancora tipi diversi, quello di tipo inferiore viene convertito temporaneamente nel tipo superiore, secondo la gerarchia
int<long<unsigned<unsigned long<float<double<long double\texttt{int} < \texttt{long} < \texttt{unsigned} < \texttt{unsigned long} < \texttt{float} < \texttt{double} < \texttt{long double}
  1. il risultato ha il tipo di livello più alto.

L’idea dietro: si converte verso il tipo che può rappresentare entrambi i valori, così non si perde niente. La gerarchia della slide è quella del vecchio C (Kernighan-Ritchie); nello standard attuale unsigned int sta sotto long, ma per gli esercizi la parte che conta è “interi sotto floating, float sotto double”. Una conseguenza da sapere: fra int e unsigned int vince unsigned, quindi un int negativo confrontato con un unsigned diventa un numero enorme.

La regola si applica operazione per operazione, seguendo l’albero dell’espressione, non all’espressione intera. In 1 / 2 * 3.0 la prima operazione è 1 / 2, fra due int: fa 0. Solo dopo entra il double: 0⋅3.0=0.00 \cdot 3.0 = 0.0.

Esempio 1, la stessa divisione con i tipi che cambiano:

#include <stdio.h>

int main(void)
{
    printf("%d\n", 7 / 2);
    printf("%f\n", 7 / 2.0);
    printf("%f\n", 7.0 / 2);
    printf("%f\n", (float)7 / 2);
    printf("%f\n", (float)(7 / 2));
    printf("%f\n", 1 / 2 * 3.0);
    printf("%f\n", 3.0 * 1 / 2);
    printf("%d\n", 'a' + 1);
    printf("%d\n", '7' - '0');
    return 0;
}
espressioneprima operazionetipiseconda operazionevalore e tipo
7 / 27/2=37 / 2 = 3int, int: intera3, int
7 / 2.07 sale a 7.0, 7.0/2.07.0 / 2.0int, double3.5, double
7.0 / 22 sale a 2.0double, int3.5, double
(float)7 / 2cast: 7.0 (unario, prima di /)7.0/2.07.0 / 2.03.5, float
(float)(7 / 2)7/2=37 / 2 = 3, interaint, intcast: 3.03.0, float
1 / 2 * 3.01/2=01 / 2 = 0 (da sinistra)int, int0.0⋅3.00.0 \cdot 3.00.0, double
3.0 * 1 / 23.0⋅1=3.03.0 \cdot 1 = 3.0double, int3.0/2.03.0 / 2.01.5, double
'a' + 1'a' promosso a int 9797+197 + 198, int
'7' - '0'55−4855 - 48int, int7, int

Output (verificato): 3, 3.500000, 3.500000, 3.500000, 3.000000, 0.000000, 1.500000, 98, 7. Le righe 6 e 7 sono la stessa moltiplicazione e la stessa divisione in ordine diverso: * e / associano da sinistra, quindi l’ordine decide se la divisione avviene fra interi. L’ultima riga è il trucco per avere la cifra da un carattere: le cifre sono consecutive nella tabella ASCII.

Esempio 2, int contro unsigned. Fra un int e un unsigned int il risultato è unsigned (gerarchia sopra), anche in un confronto. Il programma compila, ma con un warning (per questo il blocco non è marcato come C compilabile senza avvisi):

#include <stdio.h>

int main(void)
{
    int a = -1;
    unsigned int b = 1;

    if (a < b)
        printf("-1 < 1\n");
    else
        printf("-1 >= 1 ?!\n");
    printf("%u\n", (unsigned int)a);
    if (a < (int)b)
        printf("con il cast: -1 < 1\n");
    return 0;
}

Output (verificato):

-1 >= 1 ?!
4294967295
con il cast: -1 < 1

Per fare il confronto, a viene convertito in unsigned: i suoi 32 bit tutti a 1 (CA2 di −1-1) letti senza segno valgono 232−1=42949672952^{32} - 1 = 4294967295, che è più grande di 1. È l’esempio della slide 15 (stessi bit, −1-1 o 65535) dentro un if. gcc con -Wall -Wextra avvisa: comparison of integer expressions of different signedness. Con il cast (int)b il confronto torna fra int.

2.5Conversioni nell’assegnazione

(slide 83-92) Le assegnazioni sono “insidiose”, perché lo stesso simbolo / fa operazioni diverse su int e float. La regola: il valore dell’espressione a destra viene convertito al tipo della variabile a sinistra. Questo può causare:

La sequenza della slide, tracciata (le slide 88 e 90 contengono due errori, corretti qui sotto):

#include <stdio.h>

int main(void)
{
    int a = 2;
    int b = 3;
    float c = 10.4f;

    a = c;
    printf("a=c   -> a=%d\n", a);
    c = a;
    printf("c=a   -> c=%f\n", c);
    a = a / b;
    printf("a=a/b -> a=%d\n", a);
    a = a / c;
    printf("a=a/c -> a=%d\n", a);
    return 0;
}
istruzionecalcolo a destratipo a destraassegnatoabc
iniziale2310.4
a = c10.4floattroncato a int10310.4
c = a10intconvertito a float10310.0
a = a / b10/3=310 / 3 = 3int (divisione intera)nessuna conversione3310.0
a = a / c3.0/10.0=0.33.0 / 10.0 = 0.3float (a promosso)troncato a int0310.0

Output (verificato):

a=c   -> a=10
c=a   -> c=10.000000
a=a/b -> a=3
a=a/c -> a=0

Le due “trasformazioni indesiderate” della slide 84 (da int a char, da float a int) e una terza, da int a float, in un altro esempio:

#include <stdio.h>

int main(void)
{
    int x = 300;
    int y = 321;
    char c = x;
    unsigned char u = y;
    int t = -7.9;
    float f = 16777217;
    float g = 123456789;

    printf("c=%d\n", c);
    printf("u=%d %c\n", u, u);
    printf("t=%d\n", t);
    printf("f=%.1f\n", f);
    printf("g=%.1f\n", g);
    return 0;
}

Output (verificato):

c=44
u=65 A
t=-7
f=16777216.0
g=123456792.0
assegnazionecosa succedevalore
char c = x; con 300300 = 1 0010 1100, restano gli 8 bit bassi 00101100300−256=44300 - 256 = 44
unsigned char u = y; con 321modulo 256: 321−256=65321 - 256 = 6565, cioè 'A'
int t = -7.9;troncamento verso lo zero, non verso −∞-\infty−7-7, non −8-8
float f = 16777217;224+12^{24} + 1: un float ha 24 bit di mantissa, l’ultimo 1 non ci sta16777216
float g = 123456789;9 cifre, il float ne tiene circa 6-7123456792

Le ultime due righe mostrano che anche la conversione verso un tipo “superiore” può perdere informazione: un int da 32 bit ha più cifre significative di un float da 32 bit, che ne usa 8 per l’esponente. Il double (53 bit di mantissa) li tiene tutti e due esatti.

Gli errori delle slide: la slide 88 scrive “c = a, c = 2.0”, ma a vale già 10 dopo la prima riga, quindi c è 10.0 (come dicono le altre slide della sequenza). La slide 90 scrive “a = a / b, a = 0”: lo sarebbe con a ancora 2 (2/3=02 / 3 = 0), ma a è 10 e 10/3=310 / 3 = 3. Lo zero arriva solo alla riga dopo, con a / c (slide 92, corretta).

2.6Conversioni esplicite: il cast

(slide 94-97) Il cast (tipo) espressione converte esplicitamente il valore dell’espressione nel tipo indicato. È un operatore unario, con la precedenza degli altri unari: più alta di *, / e %. Quindi si applica all’operando che segue subito, non a tutta l’espressione.

L’esempio della media:

#include <stdio.h>

int main(void)
{
    float average;
    int num1 = 5;
    int num2 = 2;

    average = (num1 + num2) / 2;
    printf("senza cast: %f\n", average);
    average = (float)(num1 + num2) / 2;
    printf("con cast:   %f\n", average);
    average = (float)((num1 + num2) / 2);
    printf("cast tardi: %f\n", average);
    return 0;
}

Output (verificato):

senza cast: 3.000000
con cast:   3.500000
cast tardi: 3.000000

Passo per passo:

La regola pratica: il cast va su uno degli operandi della divisione, non sul risultato.

3Metodo

Prevedere il valore di un’espressione mista.

  1. Disegna l’albero dell’espressione con le precedenze (il cast e gli unari legano più di * e /).
  2. Valuta dal basso, un’operazione alla volta. Per ogni operazione guarda i tipi dei due operandi: se sono entrambi interi, / tronca e % dà il resto; se almeno uno è floating, l’altro sale e la divisione è vera.
  3. Alla fine, se c’è un’assegnazione, converti al tipo della variabile a sinistra (troncando se è intera).

Divisione e resto fra interi. a / b tronca verso lo zero: 17/5=317 / 5 = 3, −17/5=−3-17 / 5 = -3. Il resto ha il segno del dividendo: 17%5=217 \% 5 = 2, −17%5=−2-17 \% 5 = -2. Vale sempre (a/b)⋅b+a%b=a(a / b) \cdot b + a \% b = a.

Evitare la divisione intera. Basta che un operando sia floating: (float)a / b, a / 2.0, a * 1.0 / b. Le costanti con il punto (2.0, 100.0) sono double, senza il punto (2, 100) sono int.

Arrotondare all’intero più vicino (per valori positivi): (int)(x + 0.5). Il cast da solo tronca.

Confrontare floating: mai l’uguaglianza, sempre la soglia x >= y - EPSILON && x <= y + EPSILON.

Tracciare assegnazioni fra tipi diversi: una tabella con una colonna per variabile e una per “tipo del valore a destra”, come quella delle conversioni nell’assegnazione. I float si scrivono con il punto (10.0) per non confonderli con gli int.

4Esempi svolti a lezione

4.1Cast implicito ed esplicito

(slide 96) Il programma del prof ripercorre le divisioni con a 2, b 3, f 10.4:

#include <stdio.h>

int main(void)
{
    int a = 2;
    int b = 3;
    float f = 10.4f;

    printf("a/b=%d\n", a / b);
    f = a / b;
    printf("f=a/b=%f\n", f);
    f = (float)a / b;
    printf("f=(float)a/b=%f\n", f);
    f = f / b;
    printf("f=f/b=%f\n", f);
    f = a / 2.0;
    printf("f=a/2.0=%f\n", f);
    return 0;
}

Output (verificato):

a/b=0
f=a/b=0.000000
f=(float)a/b=0.666667
f=f/b=0.222222
f=a/2.0=1.000000
rigaoperandidivisionerisultato
a / bint, intintera0
f = a / bint, intintera, poi 0 diventa 0.00.0
f = (float)a / bfloat, intfra float0.666667
f = f / bfloat (0.666667), intfra float0.222222
f = a / 2.0int, doublefra double1.0

La seconda riga è la lezione del deck: f è float, ma questo non cambia il tipo della divisione a destra.

4.2π con la serie di Leibniz

(slide 98-102) Calcolare π con una precisione decisa dall’utente usando la serie di Leibniz:

π4=∑n=0∞(−1)n2n+1=1−13+15−17+…\frac{\pi}{4} = \sum_{n=0}^{\infty} \frac{(-1)^n}{2n + 1} = 1 - \frac{1}{3} + \frac{1}{5} - \frac{1}{7} + \ldots

Vincolo della slide 100: niente funzioni come pow. Il segno (−1)n(-1)^n si ottiene con una variabile segno che cambia segno a ogni termine. La domanda “come specificare la precisione?” ha due risposte, le due varianti.

La versione sbagliata della slide 101. Il codice del prof, che lui stesso marca “Errore”, è questo (leggermente ripulito):

#include <stdio.h>

int main(void)
{
    int i;
    int precisione;
    int segno = -1;
    float pigreco = 1;

    if (scanf("%d", &precisione) != 1)
        return 1;
    for (i = 1; i <= precisione; i++) {
        pigreco += segno * 1 / (2 * i + 1);
        printf("i=%d , %f\n", i, pigreco * 4);
        segno = (-1) * segno;
    }
    return 0;
}

Con input 4 stampa quattro volte 4.000000 (verificato). Il motivo è nel commento del prof, “errore senza casting”: segno * 1 / (2 * i + 1) è tutto fra int. Al primo giro −1⋅1/3-1 \cdot 1 / 3 fa −1/3=0-1 / 3 = 0 (troncamento verso lo zero); ogni termine vale 0 e pigreco resta 1. La domanda della slide “se dichiaro segno float?” ha risposta sì: con segno float il prodotto segno * 1 è float e la divisione diventa vera. Altrettanto bene 1.0 al posto di 1.

Variante 1: input uguale al numero di termini.

#include <stdio.h>

int main(void)
{
    int i;
    int termini;
    int segno = -1;
    double somma = 1.0;

    if (scanf("%d", &termini) != 1 || termini < 1) {
        printf("input non valido\n");
        return 1;
    }
    for (i = 1; i < termini; i++) {
        somma += segno * 1.0 / (2 * i + 1);
        segno = -segno;
    }
    printf("pi con %d termini: %f\n", termini, 4 * somma);
    return 0;
}

Tracing con 4 termini (somma parte già dal termine n=0n = 0, cioè 1):

isegnotermine segno * 1.0 / (2*i+1)somma dopo4 * somma
1.04.0
1−1-1−1/3=−0.333333-1/3 = -0.3333330.6666672.666667
2+1+1+1/5=0.2+1/5 = 0.20.8666673.466667
3−1-1−1/7=−0.142857-1/7 = -0.1428570.7238102.895238

Stampa pi con 4 termini: 2.895238; con 10 termini 3.041840, con 1000 3.140593 (verificati). La serie converge molto lentamente: con mille termini la terza cifra decimale è ancora sbagliata.

Variante 2: input uguale al numero di cifre decimali. Il suggerimento della slide 102: guardare la differenza fra due somme successive, cioè il termine appena aggiunto. Per una serie a segni alterni con termini che decrescono a zero l’errore commesso fermandosi è minore del primo termine trascurato. Quindi ci si ferma quando 4⋅12n+14 \cdot \frac{1}{2n+1} (il prossimo termine, già moltiplicato per 4) scende sotto 10−cifre10^{-\text{cifre}}.

#include <stdio.h>

int main(void)
{
    int cifre;
    int k;
    double soglia = 1.0;
    double termine = 1.0;
    double somma = 0.0;
    int n = 0;

    if (scanf("%d", &cifre) != 1 || cifre < 1 || cifre > 8) {
        printf("input non valido\n");
        return 1;
    }
    for (k = 0; k < cifre; k++)
        soglia = soglia / 10;
    while (4 * termine >= soglia) {
        if (n % 2 == 0)
            somma += termine;
        else
            somma -= termine;
        n++;
        termine = 1.0 / (2 * n + 1);
    }
    printf("pi = %.*f (%d termini)\n", cifre, 4 * somma, n);
    return 0;
}
inputstampa (verificato)
1pi = 3.1 (20 termini)
2pi = 3.14 (200 termini)
3pi = 3.141 (2000 termini)
4pi = 3.1415 (20000 termini)

La soglia si costruisce dividendo per 10 tante volte quante sono le cifre (niente pow). Ogni cifra in più costa dieci volte i termini. Con 4 cifre l’ultima stampata è 5 e non 6 (π è 3.14159…): l’errore garantito è minore di 10−410^{-4}, ma la stampa arrotonda il valore approssimato, che sta un po’ sotto π. %.*f prende il numero di decimali dall’argomento cifre.

4.3Leggere caratteri e codici ASCII

(slide 31-32) Lo stesso esercizio del deck 4.3 (caratteri fino a #, codice ASCII, maiuscola delle minuscole), svolto in Rappresentazione dell’informazione, sezione “Caratteri e codice ASCII”. In questa versione il prof legge il primo carattere con scanf("%c") e i successivi con getchar() dentro un char, e nel commento avverte del “comportamento di scanf con LF”: anche l’a capo è un carattere e viene stampato con il suo codice 10.

5Esercizi tipo esame

In una pagina a parte, dal più facile al livello del 30: Tipi di dati e conversioni (esercizi).

6Errori tipici

7Domande