Introduzione_2 - Dipartimento di Matematica

SULL’USO DEI CARATTERI
Ricordiamo che:
int x;
si legge con (“%d” ,&x) e si stampa con (“%d”,x)
float x; si legge con (“%f” ,&x) e si stampa con (“%f”,x)
double x;si legge con (“%lf”,&x) e si stampa con
(“%f”,x)
Vediamo ora che:
char x;
si legge con
(“%c”,&x)
e si stampa con (“%c”,x)
ma anche con (“%d”,x)
Ricordiamo che nel Codice ASCII
I caratteri 0-31 e 127 non sono stampabili. Gli altri sì.
Il carattere 32 stampa un singolo spazio.
I codici delle cifre 0-9 sono consecutivi.
I codici delle lettere a-z e A-Z sono consecutivi.
La differenza tra il codice di una lettera maiuscola e di quella corrispondente
minuscola è 32.
DUE ESEMPI
------------------------------------------
ALTRO ESEMPIO
Questo programma stampa:
Il carattere a
Il carattere 3
Il carattere
ha codice ASCII
Il carattere }
Il carattere ~
ha codice ASCII 97.
ha codice ASCII 51.
10.
ha codice ASCII 125.
ha codice ASCII 126.
N.B. In C c’è un insieme di caratteri speciali (alcuni non stampabili)
che sono rappresentati preceduti da \ . L’ insieme completo delle
“escape” sequences è sul libro. Qui ricordiamo:
\n
\a
\\
\?
\'
\''
\ooo
\xhh
newline
alert
\
?
'
''
carattere con codice specificato dalle
tre cifre ottali ooo
carattere con codice specificato dalle
due cifre esadecimali hh
LETTURA E STAMPA DI PAROLE(STRINGHE)
Ricordiamo che:
int x;
float x;
double x;
char x;
si legge con
si legge con
si legge con
si legge con
(“%d”, &x)
(“%f”, &x )
(“%lf”,&x)
(“%c”,&x)
e si stampa con (“%d”,x)
e si stampa con (“%f”,x)
e si stampa con (“%f”,x)
e si stampa con (“%c”,x)
ma anche con (“%d”,x)
Vediamo ora che una parola:
char p[10+1]; si legge con (“%s”,p)e si stampa con(“%s”,p)
Esempio:
int main()
{
char p[10+1];
int i;
/* lettura di una parola */
puts("Scrivi una parola di al piu' 10 caratteri:");
scanf("%s",p);
/* stampa di una parola */
printf("La parola letta e' %s, p);
i=0;
while (p[i]!='\0')
i++;
printf(" e contiene %d caratteri.\n", i);
return 0;
}
Questo programma stampa:
Scrivi una parola di al piu' 10 caratteri:
annamaria
La parola letta e' annamaria e contiene 9 caratteri.
Il formato %s in scanf si aspetta, come argomento corrispondente, una
array di char sufficientemente grande da contenere tutti i caratteri della
parola da leggere più 1 poichè viene appeso ‘\0’.
Il formato %s in printf si aspetta, come argomento corrispondente, una
array di char stampabili e li stampa tutti fino a quando incontra ‘\0’, che
non stampa .
Si poteva procedere, più faticosamente, così:
#include <stdio.h>
#include <math.h>
int main()
{
char p[10+1],c;
int i = 0,j;
/* lettura alternativa di parola carattere per carattere*/
puts("Scrivi una parola di al piu'10 caratteri poi un blank:");
scanf("%c",&c);
while(c!=' '){
p[i++]=c;
scanf("%c",&c);
}
p[i]='\0';
/* stampa alternativa di parola carattere per carattere*/
printf("La parola letta e' ");
for (j=0;j<i;j++)
printf("%c",p[j]);
printf(" e contiene %d caratteri.\n", i);
return 0;
}
Premessa. In C ad ogni espressione può essere associato un
valore logico di vero o falso:
valore espressione zero
valore espressione non-zero
–
–
falso
vero
Esempio: 3 - 4 e` vero
SULL'USO DI OPERATORI LOGICI
Questo programma stampa:
z = 1, t = 0, v = 0.
-----------------------------------------------
Cosa stampa questo programma?
Espressioni aritmetiche (logiche) in C
• Operatori aritmetici:
+, - , * , / , e operatore modulo %
La divisione tra interi tronca il resto.
Così 9 / 5 restituisce 1.
L’ operatore modulo (tra interi) restituisce il resto della divisione.
Così 9 % 5 restituisce 4.
• Operatori relazionali:
> , < , <= , >=
• Operatori di uguaglianza:
== , !=
• Operatori logici:
&&, | | , !
• Altri operatori:
=,(,),{,}
...........
Semplici regole di valutazione delle espressioni
Le precedenze tra gli operatori determinano l’ordine di valutazione di una
espressione. Gli operatori aritmetici hanno la precedenza dettata dalla
matematica; se si desidera un ordine diverso si usano le parentesi.
Esempio:
Media di a, b, c
• Sbagliato: a + b + c / 3
• Corretto: (a + b + c ) / 3
Nella valutazione innanzitutto vengono valutate le parentesi. Se le parentesi
sono annidate quella più interna viene valutata per prima. Se ci sono più
parentesi di pari livello sono valutate da sinistra a destra. Se ci sono più
operatori di pari livello vengono valutati da sinistra a destra.
Esempio:
Somma di a, b, c.
La somma a + b + c viene valutata come se ci fossero le parentesi
seguenti: ((a + b) + c ).
Si dice che l’operatore + associa da sinistra a destra.
Gli operatori fin qui presentati associano tutti da sinistra a destra eccetto
l’operatore = che associa da destra a sinistra.
Esempio:
int x, y, z;
z = y = x = 0;
Tutte le variabili vengono poste a zero, come se fosse scritto:
(z=(y=(x=0)));
N.B. Osservare sul libro la tabella completa che specifica priorità e
associatività di tutti gli operatori.
COSTANTI
•
int, float, double e char
Esempi:
11263
[ 0x3A
0371
11.23F
12.4
54
0xF3
0271
5F
-34.7e-12
'a','3','\n'
'\xF3'
'\177'
di tipo int (notaz. decimale)
di tipo int (notaz. esadecimale)
di tipo int (notaz. ottale)
]
di tipo float
di tipo double!
di tipo char
(specificata con il carattere)
di tipo char
(specificata con due cifre esadecimali)
di tipo char
(specificata con tre cifre ottali)
Oss: '\0' è numericamente uguale a 0.
•
stringa
Esempio:
"ciao, mondo"
occupa in memoria lo spazio occupato da 12 caratteri
consecutivi, che sono:
'c','i','a','o',',',' ','m','o','n','d','o','\0'
Oss:
'a'
è diverso da "a"
Esempio:
char mio_nome[6+1]={'g','i','u','l','i','a','\0'};
char mio_nome[6+1]= “giulia”;
•
enumerativa
Esempio:
enum semi{quadri, cuori, fiori, picche};
int seme = fiori;
/*seme assume valore 2 *
VARIABILI
Ogni variabile corrisponde ad una locazione della memoria
principale (cella, parola, ecc.), nella quale viene memorizzato il
suo valore.
Ogni variabile deve essere dichiarata con un nome (identificatore)
ed un tipo di dato prima di poter essere usata.
Il nome di una variabile è una sequenza di: caratteri, cifre, _
Non deve iniziare con cifra (errore) o con _ (compilatore).
C distingue tra caratteri maiuscoli e caratteri minuscoli.
I tipi di dato che useremo:
• int
• char
• float, double
– numero intero
– carattere o numero intero piccolo
– numero in virgola mobile
Una variabile di tipo int o float di solito occupa 32 bit; invece
una variabile di tipo char di solito ne occupa solo 8 mentre una di
tipo double ne occupa 64.
Quando si assegna un nuovo valore ad una variabile, il vecchio
valore viene perso.
IDENTIFICATORI
Un identificatore è un nome che viene assegnato a variabili, ma
anche a funzioni, ad oggetti in genere definiti dal programmatore.
Come per i nomi di variabili, gli identificatori possono essere
c o m p o s t i d a lettere e/o c i f r e (caratteri alfanumerici) e
sottolineature (underscore); il primo carattere non può essere
numerico.
PAROLE CHIAVE
Il linguaggio C riserva una serie di termini, detti parole chiave,
per la definizione dei costrutti propri del linguaggio. Sono:
auto, break, case, char, const, continue, default, do, double,
else, enum, extern, float, for, goto, if, int, long, register,
return, short, signed, sizeof, static, struct, switch, typedef,
union, unsigned, void, volatile, while
Le parole chiave non possono essere utilizzate come
identificatori.
Si possono usare tante variabili con un nome che le accomuna
e con un indice, come si fa in matematica: v0, v1, v2, v3.......
UN ESEMPIO DI USO DI VETTORI (ARRAYS)
#include <stdio.h>
int main()
{
int v[5] = {10, 20, 30, 40, 50}, s;
//inizializzazione
s = v[0] + v[1] + v[2] + v[3] + v[4]; //calcolo somma
printf("La somma degli elementi dell'array e' %d\n", s);
return 0;
}
I vettori, o array, permettono di allocare un insieme di elementi
dello stesso tipo in zone contigue della memoria.
Nell'esempio, il vettore v ha 5 elementi ed è indicizzato da 0 a 4,
cioè il primo elemento è v[0], il secondo è v[1], l'ultimo è v[4].
Nel caso in cui il vettore venga indicizzato con un indice al di
fuori del range ammesso:
• nel migliore dei casi si ha un errore di “segmentation fault”
• più spesso si va a scrivere/leggere una variabile che appartiene
al programma, allocata subito dopo il vettore e naturalmente
possono verificarsi fatti indesiderati e imprevedibili, spesso
difficili da diagnosticare.
Si può far diversamente e meglio:
int v[5], s, i;
for (i = 1 ; i <= 5; i++)
v[i-1] = i *10;
// inizializzazione
for (s = i = 0; i < 5; i++)
s = s + v[i];
// calcolo somma
I due cicli anche così:
i = 1;
while (i < =5){
v[i] = i *10;
i++;
}
// inizializzazione
s = i = 0;
while (i < 5){
s = s + v[i];
i++;
}
// calcolo somma