INFORMATICA Il linguaggio C. © Piero Demichelis 2 Premessa Fu creato agli inizi degli anni 70 quale...
-
Upload
aurelio-mauri -
Category
Documents
-
view
215 -
download
2
Transcript of INFORMATICA Il linguaggio C. © Piero Demichelis 2 Premessa Fu creato agli inizi degli anni 70 quale...
INFORMATICA
Il linguaggio C
2© Piero Demichelis
Premessa
• Fu creato agli inizi degli anni ’70 quale strumento per lo sviluppo del Sistema Operativo UNIX.
• Si è diffuso molto rapidamente e nel 1989 l’American National Standards Institute (ANSI) completava la definizione del linguaggio producendo il documento noto come ANSI C, al quale fanno riferimento ormai tutti i compilatori per quel linguaggio.
• A differenza degli altri linguaggi ad alto livello consente un agevole accesso alla struttura hardware del sistema di elaborazione.
3© Piero Demichelis
Caratteristiche Generali
• Il C è un linguaggio: ad alto livello
• ... ma anche poco astratto strutturato
• ... ma con eccezioni fortemente tipizzato
• ogni oggetto ha un tipo semplice (!?)
• poche keyword case sensitive
• maiuscolo diverso da minuscolo negli identificatori! portabile standardizzato (ANSI)
4© Piero Demichelis
Alfabeto
Il vocabolario base del C è costituito dai seguenti simboli:
• tutte le lettere dell’alfabeto inglese maiuscole e minuscole:
A÷Z, a÷z
• le dieci cifre decimali
0 ÷ 9
• un insieme di caratteri speciali, tra cui:
+ * / = < > ( ) [ ] { } . , ; : ” ? ! % # & ˜ ˆ
5© Piero Demichelis
Identificatori
• Si riferiscono ad una delle entità del linguaggio: costanti variabili funzioni ecc.
• Iniziano con un carattere alfabetico oppure con “_” (underscore) e possono contenere solamente caratteri alfabetici, cifre e “_”
• Il C standard prevede che solo i primi 31 caratteri dell'identificatore sono significativi, anche se possono essere usati nomi più lunghi.
6© Piero Demichelis
Commenti
• Sono testi liberi inseriti all’interno del programma dal programmatore per descrivere cosa fa il programma.
• Non sono processati dal compilatore: servono al programmatore, non al sistema!
• Formato: Racchiuso tra i simboli: /* */ Non è possibile annidarli.
• Esempi:/* Questo è un commento corretto! *//* Questo /* risulterà un */ errore */
7© Piero Demichelis
Istruzioni
• Le istruzioni devono essere scritte rispettando alcune regole sintattiche e di punteggiatura.
• L’istruzione deve sempre essere conclusa con un ; (punto e virgola).
• Si può scrivere più di un’istruzione per riga purché ognuna sia conclusa col ;.
• Un’istruzione può occupare più di una riga.
8© Piero Demichelis
Parole chiave
• Riservate!• Nel C standard sono 32:
auto double int struct
break else long switch
case enum register typedef
char extern return union
const float shortunsigned
continue for signed void
default goto sizeof volatile
do if static while
9© Piero Demichelis
Struttura di un programma C
• Struttura generale:
Direttive e parte dichiarativa globale
main () {
Parte dichiarativa locale
Parte esecutiva
}
10© Piero Demichelis
Struttura di un programma C
• Tutti gli oggetti, con le loro caratteristiche, che compongono il programma devono essere preventivamente dichiarati.
• main è la parola chiave che indica il punto di
“ingresso” del programma quando viene eseguito dal S.O.;
il suo contenuto è delimitato da parentesi graffe { … }
11© Piero Demichelis
Struttura di un programma C
• Parte dichiarativa locale: elenco degli oggetti che compongono il main
ognuno con le proprie caratteristiche.
• Parte esecutiva: sequenza di istruzioni, ovvero ciò che
descriviamo con il diagramma di flusso oppure con lo pseudocodice!
12© Piero Demichelis
Struttura di un programma C
• Programma minimo:
main() {}
main() {}
START
STOP
file prova.c
I dati
14© Piero Demichelis
Definizione dei dati
• In C, tutti i dati devono essere dichiarati e definiti prima di essere usati!
• Definizione di un dato:1. riserva spazio in memoria;2. assegna un nome.3. identifica gli operatori leciti su quel dato
• Richiede l’indicazione di: nome (identificatore); tipo; modalità di accesso (variabile/costante).
15© Piero Demichelis
Tipi
• Il tipo definisce l'insieme dei valori che possono essere assunti, la rappresentazione interna e l'insieme degli operatori che possono agire su quel dato.
• Il linguaggio C richiede di definire il tipo dei dati e possiede regole rigide per la loro manipolazione (tipizzazione forte ). Permette inoltre al programmatore di definire nuovi tipi astratti.
• Contemporaneamente permette di “vedere” gli oggetti interni al calcolatore: i registri, la memoria, gli indirizzi (puntatori), ecc.
16© Piero Demichelis
Tipi base (primitivi)
• Sono quelli forniti direttamente dal C.
• Sono identificati da parole chiave! char caratteri ASCII; int interi (complemento a 2); float reali (floating point singola precisione); double reali (floating point doppia precisione).
• La dimensione precisa di questi tipi dipende dall’architettura (non definita dal linguaggio). char = 8 bit sempre
• Attenzione: le parole chiave dei tipi base vanno scritte in minuscolo!
17© Piero Demichelis
char
• Il tipo char (character) definisce un carattere (attenzione: un solo carattere!) espresso su 8 bit (1 byte) in codice ASCII.
• I valori sono interpretati come numeri interi con segno su 8 bit (-128 ÷ +127).
• Un carattere deve essere indicato tra apici, così:
‘a’
18© Piero Demichelis
int
• Il tipo int (integer) definisce i numeri interi con segno.
• La rappresentazione interna e l'intervallo dei valori assunti dipende dal compilatore e dalla macchina usata.
• Generalmente si tratta del complemento a 2 e i valori assunti sono compresi nell’intervallo -32768 ÷ 32767 su 16 bit oppure, per le macchine a 32 bit, nell’intervallo -2.147.483.648 ÷ 2.147.483.647.
• Vanno indicati semplicemente così come siamo abituati a scriverli sulla carta, col loro valore (senza il punto decimale):
-2453
19© Piero Demichelis
float e double
• Sia il tipo float che il tipo double sono rappresentazioni di numeri reali (frazionari).
• Sono rappresentati secondo la notazione floating-point, rispettivamente in singola (32 bit) e doppia (64 bit) precisione.
• I valori assunti (rappresentabili) sono:float ± 3.4E+38 (7 cifre decimali)double ± 1.7E+308 (16 cifre decimali)
• La rappresentazione è normalmente riferita allo standard IEEE P754.
20© Piero Demichelis
float e double
• I valori di tipo float o double vanno indicati con il punto decimale, ad esempio:
14.8743
• E’ ammessa anche una notazione simile alla notazione scientifica con il carattere E al posto di 10, così:
0.148743E-02
• In alternativa, si può ancora scrivere il numero senza punto decimale ma seguito dal suffisso F oppure f (ad esempio, 10F, 10f e 10.0 sono equivalenti). Il compilatore concepisce questi valori sempre come di tipo double.
21© Piero Demichelis
Modificatori dei tipi base
• Sono previsti dei modificatori, identificati da parole chiave, da premettere ai tipi base:
• short• long• signed• unsigned
22© Piero Demichelis
short / long
• Il qualificatore short si applica al tipo int e impone che la rappresentazione degli interi sia su 16 bit (valori assunti: -32768 ÷ 32767);
• il qualificatore long si applica sia al tipo int che al tipo double;
long int impone la rappresentazione degli interi su 32 bit (valori assunti: -2.147.483.648 ÷ 2.147.483.647);
long double forza la rappresentazione dei reali su 80 bit (± 1.7E+308 aumentando la precisione a 19 cifre decimali).
23© Piero Demichelis
signed / unsigned
• I qualificatori signed e unsigned si applicano ai tipi char e int.
• signed è ridondante e serve solo a ricordare che un valore è inteso con segno (ma per int e char è già così!);
• unsigned permette di estendere l'intervallo dei valori non-
negativi.
Il tipo unsigned char può assumere valori nell'intervallo 0 ÷ 255 e il tipo unsigned int valori nell'intervallo 0 ÷ 65535.
• I qualificatori possono apparire da soli: nel qual caso si assume che sia sottinteso il tipo int. E’ lecito, ad esempio, il tipo unsigned short che viene interpretato come unsigned short int, ecc.
24© Piero Demichelis
Altri valori interi
• Per un dato intero, i valori di variabili e costanti possono anche essere espressi in esadecimale (specificati col prefisso 0x oppure 0X, ad esempio, 0xFF = 25510) oppure ottale (prefisso 0 (zero), ad esempio 0377 = 25510);
• per il formato long si usa il suffisso L oppure l (255L o 255l esprimono entrambi un long int con valore 25510);
• per l'unsigned si usa il suffisso U oppure u (255U e 255u esprimono un unsigned int = 25510 ). I suffissi u ed l possono apparire entrambi, con ovvio significato.
25© Piero Demichelis
Valori speciali
• Il codice ASCII comprende alcuni caratteri non stampabili. Per rappresentarli viene utilizzata la sequenza di escape (backslash seguito da un altro carattere).
Sequenza
CarattereSequenz
aCarattere
\a allarme \’ apostrofo
\b backspace \” doppio apice
\f pagina nuova \\ backslash
\n new line \ddd ottale
\r return \xddd esadecimale
\t tabulatore orizz. \0 null
\v tabulatore vert.
26© Piero Demichelis
Tabella riassuntiva
Tipo Intervallo dei valori char, signed char -128 ÷ 127 int, signed, signed int -32768 ÷ 32.767 short, short int, signed short -32768 ÷ 32.767 signed short, signed short int -32768 ÷ 32.767
long, long int,2.147.483.648 ÷ 2.147.483.648
signed long, signed long int2.147.483.648 ÷ 2.147.483.648
unsigned, unsigned char, unsigned short
0 ÷ 255
unsigned int, unsigned short int 0 ÷ 65535 unsigned long, unsigned long int 0 ÷ 4.294.967.295 float 3.4E±38 (7 cifre) double 1.7E±308 (16 cifre) long double 1.7E±308 (20 cifre)
27© Piero Demichelis
Direttive
• Il C prevede che nel programma, oltre alle istruzioni, possano esserci anche delle direttive che devono essere interpretate ed eseguite dal compilatore stesso (inserzione di macro, compilazioni condizionate, inclusione di altri sorgenti, ecc.);
• il compilatore C esegue una preelaborazione del programma, detta Preprocessing, per riconoscere ed eventualmente eseguire le direttive;
• le direttive si distinguono dalle istruzioni perché sono inserite sempre in righe individuali e iniziano con il carattere # seguito da una parola chiave; ad esempio:
#include#define
28© Piero Demichelis
Definizione di variabili
• Sintassi:<tipo> <nome della variabile >;
• Più in generale (definizioni multiple):
<tipo> <lista dei nomi delle variabili >;
<nome> : l’identificatore che rappresenta il nome della variabile;
<lista dei nomi delle variabili> : lista di identificatori separati da , (virgola).
29© Piero Demichelis
Definizione di variabili
• Esempi:int x;char ch;long int x1 ,x2, x3;double pi;short int stipendio;long y,z;
• Usiamo nomi significativi!Esempi: int RitenuteOperate, StipendioBase; float OreLavorate;
• Esempi errati: float Ore Lavorate; /* c’è uno spazio */
int Stip?base; /* c’è un carattere speciale */
30© Piero Demichelis
Definizione di variabili
• E’ possibile “inizializzare” una variabile, ovvero attribuirgli un valore prima che venga utilizzata per la prima volta, in fase di dichiarazione della stessa.
• Esempio:
int x = 24;char ch = ‘m’;double pi = 124.654;
31© Piero Demichelis
Definizione di costanti
• Sintassi:
const <tipo> <nome della costante> = <valore>;
• Esempi:const double pigreco = 3.14159;const char separatore = ‘$’;const float aliquota = 0.2;
• Convenzione: Identificatori delle constanti tipicamente in MAIUSCOLO
(ma è una convenzione!).const double PIGRECO = 3.14159;
32© Piero Demichelis
La direttiva “define”
• E’ un'altra possibilità di definire valori costanti : si introduce un identificatore come sinonimo di una costante:
#define identificatore testo
• Deve comparire sempre in testa al programma, prima di main(), e all'inizio della riga.
• E’ elaborata dal preprocessore del compilatore,
che sostituirà in tutto il programma, ovunque appare l'identificatore, il testo di cui è sinonimo.
33© Piero Demichelis
La direttiva “define”
• Non essendo un'istruzione non termina con il punto e virgola.
Esempi:
#define PIGRECO 3.1415#define DOMENICA 7#define VERO 1#define Carattere ‘p’
34© Piero Demichelis
Stringa
• Definizione: sequenza di caratteri terminata dal carattere NULL (‘\0’);
• non è un tipo di base del C.
• memorizzata in posizioni adiacenti di memoria.
• Formato:“<sequenza di caratteri>“
Esempi:• “Ciao!”• “abcdefg\n”
INFORMATICA
Cenni sullaRappresentazione dei dati
Rappresentazione di dati numerici
37© Piero Demichelis
Sistemi numerici
• Si suddividono in:
Non posizionali : quali ad esempio il sistema di numerazione romano (i cui simboli sono: I, II, III, IV, V, X, L, C, D, M) oppure quello egiziano
Posizionali : quali ad esempio il sistema arabo (decimale) e il sistema maya (ventesimale).
• Nei sistemi posizionali le operazioni aritmetiche risultano molto agevoli mentre in quelli non posizionali sono alquanto complicate.
38© Piero Demichelis
Sistema posizionale a base fissa
• Nei sistemi numerici a base fissa, un numero N può essere rappresentato in uno del seguenti modi:
N = dn-1; dn-2 ........ d1; d0; d-1 ........ d-m
N = dn-1· rn-1 + ..... + d0· r0 + d-1· r-1 + ..... + d-m· r-m
1ni
ii m
N d r
39© Piero Demichelis
Sistemi numerici
• Proprietà di un sistema numerico a base fissa
è a rango illimitato : ogni numero intero vi può essere rappresentato;
è a rappresentazione unica : ad ogni numero intero corrisponde un solo insieme ordinato di cifre;
è irridondante : ad ogni insieme ordinato di cifre corrisponde un solo numero non rappresentato da altri insiemi ordinati.
40© Piero Demichelis
Sistema decimale
• r = 10
• cifre: { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
Esempio:
10110 = 1 × 102 + 0 × 101 + 1 × 100
= 100 + 0 + 1= 10110
41© Piero Demichelis
Sistema binario
• r = 2
• cifre: { 0, 1 }
Esempio:
1012= 1 × 22 + 0 × 21 + 1 × 20
= 4 + 0 + 1 = 510
42© Piero Demichelis
Sistema ottale
• r = 8
• cifre: { 0, 1, 2, 3, 4, 5, 6, 7 }
Esempio:
1018= 1 × 82 + 0 × 81 + 1 × 80
= 64 + 0 + 1 = 6510
• molto utile per scrivere in modo compatto i numeri binari (ad ogni 3 cifre binarie corrisponde una cifra ottale)
( 1 1 0 1 1 0 0 0 1) 2 = ( 6 6 1 ) 8
43© Piero Demichelis
Sistema esadecimale
• r = 16
• cifre: { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F }
Esempio:
101H = 1 × 162 + 0 × 161 + 1 × 160
= 256 + 0 + 1 = 25710
• anch’esso utile per scrivere in modo compatto i numeri binari (ad ogni 4 cifre binarie corrisponde 1 cifra esadecimale)
( 1 1 0 1 1 0 0 0 1) 2 = ( 1 B 1 ) 16
44© Piero Demichelis
Sistema base 5
• r = 5
• cifre: { 0, 1, 2, 3, 4 }
Esempio:
1015= 1 × 52 + 0 × 51 + 1 × 50
= 25 + 0 + 1 = 2610
45© Piero Demichelis
Sistema binario
• Caratteristiche su n cifre si rappresentano 2n numeri; ad esempio su 4
cifre:
Prime 16 potenze del 2:
0 ... 0 1000 ... 81 ... 1 1001 ... 910 ... 2 1010 ... 1011 ... 3 1011 ... 11100 ... 4 1100 ... 12101 ... 5 1101 ... 13110 ... 6 1110 ... 14111 ... 7 1111 ... 15
0 ... 0 1000 ... 81 ... 1 1001 ... 910 ... 2 1010 ... 1011 ... 3 1011 ... 11100 ... 4 1100 ... 12101 ... 5 1101 ... 13110 ... 6 1110 ... 14111 ... 7 1111 ... 15
20 ... 1 29 ... 512 21 ... 2 210 ... 1024 22 ... 4 211 ... 2048 23 ... 8 212 ... 4096 24 ... 16 213 ... 8192 25 ... 32 214 ... 16384 26 ... 64 215 ... 32768 27 ... 128 216 ... 65536 28 ... 256
20 ... 1 29 ... 512 21 ... 2 210 ... 1024 22 ... 4 211 ... 2048 23 ... 8 212 ... 4096 24 ... 16 213 ... 8192 25 ... 32 214 ... 16384 26 ... 64 215 ... 32768 27 ... 128 216 ... 65536 28 ... 256
46© Piero Demichelis
Sistema binario
• La cifra binaria è detta bit
parola che deriva dall’unione di due elisioni:
binary digit
• I bit estremi di un numero binario si chiamano:
1 0 1 1 1 0 0 1 0 0
MSB(Most Significant Bit)
LSB(Least Significant
Bit)
47© Piero Demichelis
Limiti del sistema binario
• Poiché su n bit si rappresentano 2n numeri, per rappresentare la stessa grandezza occorrono molte più cifre rispetto al sistema numerico decimale.
bit simboli val. minimoval. massimo
416 0 158256 0 25516 65,536 0 65,53532 4,294,967,296 0 4,294,967,295
48© Piero Demichelis
Conversione da binario a decimale
• Si applica direttamente la definizione effettuando la somma pesata delle cifre binarie:
1012 = 1 × 22 + 0 × 21 + 1 × 20
= 4 + 0 + 1 = 5
1101.12 = 1 23 + 1 22 + 0 21 + 1 20 + 1 2-1
= 8 + 4 + 0 + 1 + 0.5 = 13.510
49© Piero Demichelis
Conversione da decimale a binario
N = dn-1· rn-1 + ..... + d0· r0 + d-1· r-1 + ..... + d-m· r-m
• Consideriamo la sola parte intera e riscriviamo il numero binario nel modo seguente:
N = d0 + 2 · (d1 + 2 · (d2 + ...... + dn-1))
• Si può osservare che dividendo N per la base 2, si ottiene un
quoziente (d1 + r · (d2 + ...... + dn-1)) e un resto d0, che costituisce proprio la cifra meno significativa del numero nella base 2.
• Dividendo successivamente il quoziente per la base 2 si trova ancora un quoziente e un resto d1, che è la cifra di peso uno cercata, e così via.
50© Piero Demichelis
Esempio
• Esempio:
13 6 3 1 0 quozienti1 0 1 1 restid0 d1 d2 d3
1310 = 11012
51© Piero Demichelis
Conversione da decimale a binario
• Dato un numero frazionario:
N = a-1 2-1 + a-2 2-2 + ...... + a-m 2-m
• moltiplicando N per la base 2, si ricava come parte intera la cifra a-1, cioè la prima cifra binaria.
• Eliminata questa parte intera, moltiplicando quanto resta ancora per 2, si ricava come parte intera a-2, ecc.
• Le parti intere, scritte nel medesimo ordine con cui sono state ricavate, rappresentano il numero frazionario binario cercato.
52© Piero Demichelis
Esempio
• Regola: si moltiplica per due la parte frazionaria e si prende la cifra intera prodotta dal risultato proseguendo fino alla precisione richiesta.
Esempio: 0.34 x 2
0.68 x 0.3410 = 0.01012
2 1.36 x 2 0.72 x 2
1.44 ecc. 13.3410 = 1101.01012
53© Piero Demichelis
Conversioni tra sistemi in base qualsiasi
• E’ ovvio che le regole di conversione decimale-binario sono del tutto generali e valgono qualsiasi siano i sistemi numerici coinvolti.
• Ad esempio per convertire il numero decimale 365 in base 7 si divide per 7:
365 52 7 1 0 1 3 0 1
36510 = 10317
54© Piero Demichelis
Operazioni aritmetiche
• Le operazioni aritmetiche in un qualsiasi sistema numerico si possono eseguire nello stesso identico modo che conosciamo così bene per il sistema numerico decimale.
• L’avvertenza è solo quella di costruire la “tabellina” opportuna per quel particolare sistema numerico: si ricordi che la tabellina per il sistema numerico decimale ce la siamo studiata a memoria sin dall’infanzia!!!!
• Il nostro interesse è però particolarmente concentrato sul sistema numerico binario e sono proprio le operazioni aritmetiche in binario che affronteremo ora.
55© Piero Demichelis
Somma in binario
• Regole base:0 + 0 = 00 + 1 = 11 + 0 = 11 + 1 = 0 con riporto (carry) di 1
• Si effettuano le somme parziali tra i bit dello stesso peso, propagando gli eventuali riporti:
1 10 1 1 0 + 6 +
0 1 1 1 = 7 =1 1 0 1 13
56© Piero Demichelis
Somma completa
• La somma completa (full addition) tiene conto del riporto per cui si sommano due bit ed un carry ottenendo come risultato un bit di somma e un bit di riporto
A B Carry S Rip
0 0 0 0 0
0 1 0 1 0
1 0 0 1 0
1 1 0 0 1
0 0 1 1 0
0 1 1 0 1
1 0 1 0 1
1 1 1 1 1
57© Piero Demichelis
Sottrazione in binario
• Regole base:0 – 0 = 00 – 1 = 1 con prestito (borrow) di 1 1 – 0 = 11 – 1 = 0
• Si eseguono le sottrazioni bit a bit tenendo conto dei prestiti:
11 1 0 0 - 12 -
1 0 1 0 = 10 =0 0 1 0 2
58© Piero Demichelis
Sottrazione completa
• Analogamente alla somma, è possibile definire la sottrazione completa (sottrazione tra due bit ed un borrow )
A B Borrow
SPrest
0 0 0 0 0
0 1 0 1 1
1 0 0 1 0
1 1 0 0 0
0 0 1 1 1
0 1 1 0 1
1 0 1 0 0
1 1 1 1 1
59© Piero Demichelis
Moltiplicazione in binario
• Il prodotto tra due numeri binari si può calcolare con la tecnica già nota per i numeri in base 10, detta della somma e scorrimento.
Esempio: 1 0 1 1 x 11 x 1 0 1 = 5 = 1 0 1 1 55 0 0 0 0 1 0 1 1 1 1 0 1 1 1
• Nella pratica si usano accorgimenti particolari basati sull’operazione di scorrimento (shift ).
60© Piero Demichelis
Divisione in binario
• Come per le altre operazioni applichiamo le stesse regole che usiamo col sistema decimale:
Esempio:1 0 1 0 1 1 10 0 0 1 1 1 21 / 3 = 71 0 10 1 1 1 0 0 1 1
0 0 1 1 1 1 0 0
61© Piero Demichelis
L’operazione di shift
• Equivale ad una moltiplicazione o divisione per la base.
• Consiste nel “far scorrere ” i bit (a sinistra o a destra) inserendo opportuni valori nei posti lasciati liberi.
• In decimale equivale a moltiplicare (shift a sinistra) o dividere (shift a destra) per 10.
• In binario equivale a moltiplicare (shift a sinistra) o dividere (shift a destra) per 2.
62© Piero Demichelis
Shift a sinistra
• Si inserisce come LSB un bit a zero
• Equivale ad una moltiplicazione per due
0011 « 1 = 0110 ( 3 2 = 6 )0011 « 2 = 1100 ( 3 22 = 12 )0011 « 3 = 11000 ( 3 23 = 24 )
0 0 1 1
0 1 1 0
« 1 (shift a sinistra di 1 posizione)
0
63© Piero Demichelis
Shift a destra
• Si inserisce come MSB un bit a zero
• Equivale ad una divisione per due
0110 » 1 = 0011 ( 6 : 2 = 3 )0110 » 2 = 0001 ( 6 : 4 = 1 ) troncamento!
0 1 1 0
0 1 1 0
» 1 (shift a destra di 1 posizione)
0
64© Piero Demichelis
Moltiplicazioni
• Una qualsiasi moltiplicazione tra due numeri può essere trasformata in una serie di shift e di somme, operazioni che vengono eseguite molto velocemente dai microprocessori.
• Ad esempio il prodotto 14 x 13 diventa:14 · 13 = 14 · (8 + 4 + 1) = 14 · 8 + 14 · 4 + 14 · 11410 = 11102 1 1 1 1
1110000 +1110 « 3 + 1110 « 2 + 1110 111000 +
1110 = 10110110
65© Piero Demichelis
Limiti della rappresentazione
• Quando scriviamo sulla carta non ci preoccupiamo quasi mai della grandezza dei numeri (a meno di particolari necessità).
• Nelle macchine numeriche un numero deve essere rappresentato in un particolare dispositivo elettronico interno che si chiama registro ed è paragonabile ad una cella di memoria.
• Caratteristica fondamentale di questo dispositivo è la sua dimensione (numero di bit) stabilita in sede di progetto: ovvero in un elaboratore potremo rappresentare solo una quantità limitata di numeri.
66© Piero Demichelis
Limiti della rappresentazione
• Ad esempio se il nostro contenitore (registro) è lungo 5 bit:
potremo rappresentare solamente i numeri binari compresi tra 0
0 0 0 0 0 e 31 1 1 1 1 1
• Inoltre dovremo in qualche modo introdurre il segno dei numeri!
67© Piero Demichelis
I numeri con segno
• Oltre al problema relativo al valore del numero bisogna trovare il modo di rappresentare il segno.
• Il segno dei numeri può essere solo di due tipi:positivo ( + )negativo ( - )
• Sembrerebbe quindi facile rappresentarlo in binario, tuttavia la soluzione più semplice (1 bit riservato al segno) non è sempre conveniente.
• Per tener conto del segno anziché il sistema numerico binario si utilizzano dei codici binari che hanno tuttavia come base, ovviamente, il sistema numerico binario.
68© Piero Demichelis
Modulo e segno
• Su N bit, un bit è destinato al segno (in binario 0 = +,1 = -) e N-1 bit al valore assoluto (anche detto modulo)
S modulo
• E’ un codice che ricorda molto il nostro modo di rappresentare i numeri sulla carta.
• Presenta però gravi svantaggi dovuti alla doppia rappresentazione dello zero (esistono e sono leciti infatti sia + 0, che - 0) e alla complessità delle operazioni aritmetiche.
69© Piero Demichelis
Modulo e segno
• Esempi - usando una codifica su quattro bit: + 310 0011MS
310 1011MS
• Si ha una doppia rappresentazione dello zero: 0000MS + 010
1000MS 010
• In generale su N bit sono rappresentabili i valori:
- ( 2N-1 - 1 ) x + ( 2N-1 - 1 )
8 bit => [ -127 ÷ +127 ]16 bit => [ -32.767 ÷ +32.767 ]
70© Piero Demichelis
Complemento a 1
• Considerando numeri binari di n bit, si definisce complemento a uno di un numero A la quantità:
A = 2n - 1 – A
• Viene anche detto semplicemente complemento.
• Regola pratica:il complemento a uno di un numero binario A si ottiene
cambiando il valore di tutti i suoi bit (complementando ogni bit)
Esempio:
A = 1011 A 0100
71© Piero Demichelis
Complemento a 2
• Considerando numeri binari di n bit, si definisce complemento a due di un numero A la quantità:
A = 2n – A
Regola pratica:il complemento a due di un numero binario A si ottiene
sommando uno al suo complemento (a uno)
Esempio:
A = 1011 A = 0100 A0101
72© Piero Demichelis
Complemento a 2
• E’ usato per rappresentare numeri relativi:
( A 0 ) 0 A2 (= AMS)
( A < 0 ) complemento a 2 di A
• In questo modo l’MSB indica il segno: 0 = +, 1 = -
• Regola alternativa per la determimazione del complemento a due: si parte da destra, si lasciano inalterati tutti gli zeri fino al primo uno che si lascia inalterato, si complementano tutti gli altri bit
• Esempio:A = 001101001000; A = 110010111000
73© Piero Demichelis
Complemento a 2
• Esempio - usando una codifica su 4 bit:
+ 310 0 ( 32 ) 0011CA2
- 310 - 0011 1100 + 1 1101CA2
• In generale su N bit sono rappresentabili i valori:
- ( 2N-1 ) x + ( 2N-1 - 1 )
8 bit => [ -128 ÷ +127 ]16 bit => [ -32.768 ÷ +32.767 ]
74© Piero Demichelis
Somma e sottrazione in complemento a 2
• La somma si effettua direttamente, senza badare ai segni degli operandi, come fossero due normali numeri binari.
• La sottrazione si effettua sommando al minuendo il complemento a 2 del sottraendo:
A – B A + (- B) ovvero: A + B
• Esempio: 0 1 0 1 0 + 10 + 1 0 1 0 0 = - 12 = 1 1 1 1 0 - 2
75© Piero Demichelis
Overflow
• Si usa il termine overflow per indicare l’errore che si verifica in un sistema di calcolo automatico quando il risultato di un’operazione non è rappresentabile con la medesima codifica e numero di bit degli operandi.
• Nella somma in binario puro si ha overflow quando si opera con un numero fisso di bit e si genera un riporto (carry) sul bit più significativo (MSB, quello più a sinistra).
Esempio: somma tra numeri di 4 bit in binario puro
0 1 0 1 +1 1 1 0 =
overflow! 1 0 0 1 1
76© Piero Demichelis
Overflow in complemento a 2
1. Operandi con segno discorde: non si può mai verificare overflow!!!!!
2. Operandi con segno concorde: c’è overflow quando il risultato ha segno discorde da
quello dei due operandi
3. In ogni caso, si trascura sempre il carry (riporto) oltre il MSB
Esempi:0 1 0 1 + 1 1 1 0 +0 1 0 0 = 1 1 0 1 =1 0 0 1 1 1 0 1 1 = overflow! carry, risultato OK
77© Piero Demichelis
Fixed-point
• Si usa un numero fisso di bit per la parte intera e per quella frazionaria (e non si rappresenta la virgola!)
• Ad esempio (4 + 4 bit, binario puro):
15.9375 = 111111110.0625 = 00000001
virgola sottintesa
78© Piero Demichelis
Fixed-point
• Vantaggi: gli operandi sono allineati per cui le operazioni aritmetiche
risultano facili ed immediate; la precisione assoluta è fissa
• Svantaggi: l’intervallo di valori rappresentati è assai modesto la precisione dei numeri frazionari rappresentati molto
scarsa
• Utilizzo tipico: DSP (Digital Signal Processor) Sistemi digitali per applicazioni specifiche (special-purpose) Numeri interi nei calcolatori
79© Piero Demichelis
Rappresentazione di numeri interi
• A causa dell’estrema semplicità che presentano le operazioni aritmetiche in complemento a 2, in tutte le macchine numeriche i numeri interi vengono rappresentati in questo codice.
• Il numero di bit utilizzati dipende dalla macchina: si tratta generalmente di 16 bit (interi corti) o 32 bit (interi lunghi).
• La rappresentazione è nota col nome di fixed-point e il punto frazionario è supposto all’estrema destra della sequenza di bit (parte frazionaria nulla).
80© Piero Demichelis
Rappresentazione di numeri reali
• Le rappresentazioni fin qui considerate hanno il pregio di rappresentare esattamente i numeri (almeno quelli interi) ma richiedono un numero di bit esorbitante quando il numero da rappresentare ha valore elevato.
• La rappresentazione dei numeri frazionari che deriva dai codici precedenti, ovvero in fixed point, a causa delle forti approssimazioni che impone è usata raramente.
• Generalmente viene utilizzato un apposito codice noto come floating point che consente di rappresentare in un numero limitato di bit grandezze di qualsiasi valore anche se condizionate da approssimazioni più o meno elevate.
81© Piero Demichelis
Floating-point
• E’ basata sul formato esponenziale (notazione scientifica)
N = mantissa base esponente
Ricorda le notazioni:
standard 3.5 × 104 3.5E+4scientifico 0.35 × 105 0.35E+5
• Nei sistemi di elaborazione Base = 2 Mantissa ed esponente sono rappresentati in binario
82© Piero Demichelis
Floating-point
• Vantaggi: grande intervallo di valori rappresentabili errore relativo fisso
• Svantaggi: operandi non allineati per cui le operazioni aritmetiche
risultano molto complesse errore assoluto variabile e dipendente dal valore del
numero
• E’ la rappresentazione utilizzata da tutti i calcolatori elettronici per rappresentare i numeri frazionari ed è stata standardizzata dall’IEEE.
83© Piero Demichelis
Formato IEEE-P754
• Standard IEEE per il floating-point: Rappresentazione binaria di
mantissaesponente segno
• Singola precisione: 32 bit (float)
• Doppia precisione: 64 bit (double)
23 bit8 bit
esponentesegno mantissa
1 bit
52 bit11 bit
esponentesegno mantissa
1 bit
precisione: circa 7 cifre decimali
precisione: circa 17 cifre decimali
84© Piero Demichelis
Overflow e Underflow
• A causa della precisione variabile è possibile avere errori di rappresentazione: numeri troppo grandi: overflow numeri troppo piccoli: underflow
Esempio: IEEE P754
0-1038 -10-38 10-38 1038
overflow
underflow
85© Piero Demichelis
Rappresentazioni di dati non numerici
• Qualunque insieme finito di oggetti può essere codificato tramite valori numerici associando ad ogni oggetto un codice (ad esempio un numero intero).
• Nel sistema numerico binario per rappresentare K oggetti distinti occorre un numero minimo di bit pari a:
N = log2 K
86© Piero Demichelis
Caratteri
• E’ sicuramente il tipo di informazione più scambiata: occorre pertanto una codifica standard.
la più usata fa riferimento al codice ASCII (American Standard Code for Information Interchange)
in passato era molto diffuso il codice EBCDIC (Extended BCD Interchange Code)
codice UNICODE
87© Piero Demichelis
Codice ASCII
• E’ usato anche nelle telecomunicazioni.
• Usa 8 bit per rappresentare: i 52 caratteri alfabetici (a ÷ z , A ÷ Z) le 10 cifre (0 ÷ 9) i segni di interpunzione (,;:!?&%=+-/ ecc.) un gruppo di caratteri di controllo tra cui:
CR ( 13 ) Carriage ReturnLF,NL ( 10 ) New Line, Line FeedFF,NP ( 12 ) New Page, Form FeedHT ( 9 ) Horizontal TabVT ( 11 ) Vertical Tab
NUL ( 0 ) NullBEL ( 7 ) BellEOT ( 4 ) End-Of-Transmission
88© Piero Demichelis
Codice ASCII
• Ad esempio per rappresentare il messaggio “Auguri a tutti!” è necessaria la seguente sequenza:
01000001 A 00100000 spazio01110101 u 01110100 t01100111 g 01110101 u01110101 u 01110100 t01110010 r 01110100 t01101001 i 01101001 i00100000 spazio 00100001 !01100001 a
Fine Rappresentazione dei dati
90© Piero Demichelis
Visibilità delle variabili
• Ogni variabile è definita all’interno di un preciso ambiente di visibilità (scope).
• Variabili globali definite all’esterno al main sono visibili da tutti i
moduli.
• Variabili locali definite all’interno del main (sono visibili solo
all’interno del main); più in generale, definite all’interno di un blocco
(sono visibili solo all’interno del blocco).
91© Piero Demichelis
Struttura a blocchi
• In C è possibile aggregare gruppi di istruzioni in blocchi racchiudendole tra parentesi graffe;
• significato: delimitazione di un ambiente di visibilità di “oggetti” (variabili).
• Esempio:{
int a=2;int b;
b=2*a;}
a e b sono definitesolo all’interno del blocco!
92© Piero Demichelis
int n;double x;main() {
int a,b,c;double y;{
int d;double z;
}}
Visibilità delle variabili - Esempio
n, x: visibili in tutto il file a, b, c ,y: visibili in tutto il main d, z: visibili solo nel blocco
Le istruzioni
94© Piero Demichelis
Assegnazioni
• Sintassi:<variabile> = <espressione>;
• Non è un’uguaglianza! Significato: il risultato di <espressione> viene
assegnato a <variabile>; <variabile> e <espressione> devono essere
“compatibili” (ovvero dello stesso tipo); <variabile> deve essere stata precedentemente definita!
• Esempio:int x;float y;x = 3;y = -323.9498;
95© Piero Demichelis
Assegnazioni
• In realtà l’assegnazione (o assegnamento) non è un’istruzione (come accade in tutti gli altri linguaggi);
• il simbolo = è un operatore che assegna alla variabile che si trova a sinistra il valore calcolato sull’espressione di destra;
• nel caso più semplice l’espressione di destra è un semplice valore.
• Sono pertanto lecite assegnazioni “multiple”:<var1> = <var2> = <espressione>;
96© Piero Demichelis
Istruzioni di I/O
• Per ora consideriamo solo l’I/O interattivo, quello cioè che si realizza con tastiera e monitor.
• Sono disponibili diverse forme in base al tipo di informazione letta o scritta:
I/O formattato I/O di caratteri I/O “per righe”
97© Piero Demichelis
I/O formattato
• Standard output (scrittura su monitor)istruzione printf
• Standard input (lettura da tastiera)istruzione scanf
• L’utilizzo di queste funzioni richiede l’inserimento di una direttiva
#include <stdio.h>
all’inizio del file sorgente il cui significato è: “includi il file stdio.h ”
98© Piero Demichelis
L’istruzione printf
• Visualizza sul monitor.
• La printf opera utilizzando una stringa, detta <format>, nella quale si devono inserire i comandi che descrivono come devono apparire i dati sul monitor.
• Al <format> deve seguire la lista di variabili che si vuol visualizzare.
• Sintassi:
printf (<format>,<arg1>,...,<argn>);
99© Piero Demichelis
L’istruzione printf
• <format>: stringa che determina il formato di visualizzazione per ognuno dei vari argomenti.
• <arg1>,...,<argn>: lista degli argomenti da visualizzare. Gli argomenti (opzionali) possono essere costanti, variabili o espressioni.
• Se non ci sono argomenti (come quando si vuole visualizzare solo un messaggio) la funzione trasferisce sul video il testo della stringa di <format> e il cursore si posiziona subito dopo l'ultimo carattere.
100© Piero Demichelis
L’istruzione printf
• Affinché il cursore vada a capo, occorre inserire nella stringa di format il carattere new-line (\n).
• Esempio:
#include <stdio.h>
main()
{
printf ("Stampa di una riga\n");
printf ("Seconda riga\n");
}
101© Piero Demichelis
Specificatori di formato
• Generalmente nel format sono indicati gli specificatori di formato per le variabili della lista. I principali specificatori di formato sono:
%d o %i per il tipo int, stampa in notazione decimale; %o per il tipo int, stampa in ottale senza segno; %x per il tipo int, stampa in esadecimale senza segno; %u per il tipo int, stampa in decimale senza segno; %c per il tipo char, stampa un carattere; %f per il tipo float, stampa nella notazione virgola mobile
nel formato -d.dddddd (6 cifre dopo la virgola); %e o %E per il tipo float, stampa nella notazione virgola
mobile nel formato esponenziale -d.dddddde(E)±dd; %s per le sequenze di caratteri (stringhe).
102© Piero Demichelis
Specificatori di formato
• Gli specificatori di formato sono costituiti dal carattere % seguito da un altro carattere che indica il formato da utilizzare per la stampa dell'argomento corrispondente (carattere, numero intero o reale, stringa, ecc.).
• Quando incontra il primo specificatore di formato il C preleva il primo argomento, effettua la conversione dal formato interno del dato ad una sequenza di caratteri ASCII seguendo le indicazioni del descrittore ed esegue infine l'ouput dei caratteri sul video.
• Prosegue poi con la stringa del format, ripetendo le azioni prima descritte per ogni specificatore incontrato e così fino ad esaurire l'intero format: il numero di specificatori di formato deve essere quindi pari al numero di argomenti.
103© Piero Demichelis
Esempio
• L’associazione tra variabili e specificatori di formato è di tipo ordinale: 1° specificatore 1ª variabile;
2° specificatore 2ª variabile, ecc.
• Esempi:int x = 2;float z = 0.5;Char c = ‘a’;
printf (“%d %f %c\n”, x, z, c);
printf (“%f***%c***%d\n”, z, c, x);
2 0.500000 a_
0.500000***a***2_
104© Piero Demichelis
Specificatori di formato
• Tra il carattere % e quello di specificazione può esserci uno o più elementi aggiuntivi:
un intero, che fissa la larghezza minima (numero di caratteri) del campo su cui il dato è stampato;
un punto seguito da un intero, che stabilisce la precisione con cui visualizzare il dato (numero di cifre frazionarie);
uno di questi modificatori:
• h (per indicare che si tratta di un tipo short),• l (per indicare che si tratta di un tipo long),• L (per indicare che si tratta di un tipo long double).
105© Piero Demichelis
Esempio (printf)
#include <stdio.h>int a=-57, b=2, c=450, d=33;float e=1.22E7, f=-0.1234567, g=98765.4321, h=1.0;
main(){printf ("a=%4d b=%3d c=%8d d=%1d\n", a, b, c, d);printf (“e=%9.3f f=%9.3f g=%9.3f h=%9.3f", e, f, g, h);}
• Sul video apparirà: a= -57 b= 2 c= 450 d=33 e=12200000.000 f= -0.123 g=98765.432 h=
1.00
106© Piero Demichelis
L’istruzione scanf
• Permette la lettura di dati da tastiera.
• La scanf, come la printf, opera utilizzando un format, cioè un descrittore del formato che devono avere i dati in ingresso e accetta vari tipi di argomenti: interi, reali, caratteri, stringhe, ecc.
• Sintassi:
scanf (<format>,<arg1>,...,<argn>);
107© Piero Demichelis
L’istruzione scanf
• <format> : è una stringa di caratteri dove compaiono solo specificatori di formato (è bene evitare di inserire degli spazi tra gli specificatori), gli stessi utilizzati per la printf;
• <arg1>,...,<argn> : possono essere solo variabili il cui nome deve essere preceduto dal carattere &.
ATTENZIONE!!!MPORTANTEi nomi delle variabili vanno sempre precedute
dall’operatore & che indica l’indirizzo della variabile
• Esempio:int x; float z;scanf(“%d%f“, &x, &z);
108© Piero Demichelis
L’istruzione scanf
• Per comprendere il funzionamento della scanf si immagini che, man mano che vengono introdotti i caratteri dalla tastiera, il codice di ognuno venga accodato in un contenitore (un flusso).
• Si possono pensare così a delle sequenze di caratteri sulle quali il programma in esecuzione dispone di un cursore.
• Le modalità con cui opera la scanf sono alquanto complesse e dipendono dagli specificatori che compaiono nel <format>.
109© Piero Demichelis
L’istruzione scanf
• Quando deve leggere un numero intero o reale, il cursore avanza fino al primo carattere diverso da spazio.
• Vengono poi letti tutti i caratteri successivi (cifre) fino a raggiungere un carattere di spazio oppure un delimitatore di riga (comunque un carattere non numerico), sul quale il cursore si ferma.
• Se la sequenza di caratteri così isolata è corretta, viene convertita nella rappresentazione interna e il valore è attribuito alla variabile, altrimenti le operazioni della scanf si bloccano.
110© Piero Demichelis
L’istruzione scanf
• Nel caso che la stringa contenga più di un descrittore, per ognuno viene attivato l'opportuno meccanismo di lettura e conversione: affinché la scanf si comporti correttamente ci devono essere tanti descrittori quanti argomenti.
• Tra un numero e il successivo possono essere inseriti quanti caratteri di spazio si desidera: vengono automaticamente ignorati (come ce ne fosse uno solo!).
• Se invece si leggono dati di tipo char viene letto un solo carattere, quello su cui è posizionato il cursore, il quale avanza di una sola posizione!
111© Piero Demichelis
L’istruzione scanf
• Per i dati più comuni (numeri e stringhe di caratteri) i valori devono essere introdotti separandoli tra loro da almeno un separatore (spazio, invio, ecc.).
• Lo specificatore %*xx provoca il salto della prossima conversione: viene effettuata la lettura ma il valore non viene assegnato all'argomento.
• Lo specificatore %* può risultare utile in pratica solo nel caso di lettura di dati da file (come si vedrà più avanti).
112© Piero Demichelis
Esempio
#include <stdio.h>
int dato1, dato2, dato3;
main(){printf(“\nIntroduci tre numeri interi: ");scanf("%d%d%d", &dato1, &dato2, &dato3);}
113© Piero Demichelis
L’istruzione scanf
• I tre dati interi (da tastiera) possono essere introdotti indifferentemente separandoli tra loro con un semplice spazio oppure con il tasto di invio oppure ancora con il carattere tab, ecc.
• Ad esempio sono lecite ed equivalenti:
14 674 99000 (su una sola riga)
14 674 99000 (su una sola riga)
14674 (su tre righe distinte)99000
114© Piero Demichelis
I/O
• scanf e printf non sono le uniche possibilità che abbiamo per introdurre o visualizzare dati.
• Esistono numerose altre istruzioni di input sia per la lettura da tastiera, sia per leggere dati da altri periferici (come, ad es., il disco).
• Sono naturalmente diponibili le rispettive istruzioni di output.
• Il loro uso è però più complesso e verrà proposto più avanti.
115© Piero Demichelis
Espressioni
• Sono combinazioni di variabili e operatori.
• Esistono varie categorie di operatori, applicabili a tipi di dati diversi:
operatori aritmetici; operatori relazionali; operatori logici; operatori sui bit: ecc.
116© Piero Demichelis
Operatori aritmetici
• Quattro operatori comuni a tutti (numeri reali e interi):
+ - * /
• Per i numeri interi, esiste anche l’operatore % che ritorna il resto della divisione intera.
• Stesse regole di precedenza dell’aritmetica ordinaria:
( *, / ) > ( + , - )
le parentesi tonde alterano la gerarchia.
• Esempio:
int x = 5, y = 2, q, r;
q = x / y; /* (q = 2, variabili intere! troncamento) */
r = x % y; /* (r = 1) , resto di 5 / 2 */
q = x + (y * (x – r)); /* 5 + (2 * (5 – 1)) = 13 */
117© Piero Demichelis
Operatori aritmetici: esempi
const double ENEPER = 2.718281;
/* sezione variabili */int dato, divintero;double risul, inizio;
main(){ dato = 12 * 3 - 4 * 5; /* equivale a (12*3)-(4*5) = 16 */ dato = dato + 1; /* aggiunge 1 a dato: dato = 17 */ divintero = dato % 10; /* resto di 17 / 10 (= 7) */ inizio = dato; /* conversione di tipo */ risul = inizio / ENEPER; /* divisione tra numeri reali */}
118© Piero Demichelis
Conversione forzata di tipo (casting)
• Si può forzare la conversione di tipo anteponendo al dato che si vuole convertire il tipo posto tra parentesi, secondo questo schema:
(tipo) espressione
• Esempio:
int dato_1, dato_2;float dato_real;
dato_real = (float)dato_1 / (float)dato_2;
• L'effetto della conversione mediante l'operazione cast è limitato all'espressione in cui appare: il dato su cui opera resta immutato.
119© Piero Demichelis
Operatori di assegnamento composti
• E’ possibile combinare l’istruzione di assegnazione con gli operatori aritmetici.
• Sintassi:<variabile> <operatore>= <espressione>;
• Operatori:+= -= *= /= %=
Significato: assegnazione + operazione.
• Esempi:x += 5; /* equivalente a x = x + 5 */y -= x; /* equivalente a y = y – x */
120© Piero Demichelis
Operatori di incremento e decremento
• Per le assegnazioni composte più comuni sono previsti degli operatori espliciti:
++ --
• Significato: ++ +=1
-- -=1
• Esempi:
x++; /* equivale a x = x + 1 */valore--; /* equivale a valore = valore – 1 */
121© Piero Demichelis
Operatori di incremento e decremento
• Possono essere utilizzati sia in notazione prefissa che in notazione postfissa
• Prefissa: la variabile viene modificata prima di essere utilizzata nell’espressione
• Postfissa: la variabile viene modificata solo dopo averla utilizzata nell’espressione
• Esempio: assumendo x = 4: Se si esegue y = x++, si otterrà come risultato x = 5 e y
= 4; Se si esegue y = ++x, si otterrà come risultato x = 5 e y
= 5;
122© Piero Demichelis
Operatori relazionali
• Operano su quantità numeriche o di tipo char e forniscono un risultato logico o “booleano”.
< <= > >= == !=
• Il risultato è sempre di tipo int: risultato = 0 significa FALSO risultato 0 significa VERO
• In C (C89) non esiste un tipo logico o “booleano” !
123© Piero Demichelis
Esempio
main(){ float dato1, dato2; int inter1, inter2; short int switch1, flag; dato1 = 10.5; dato2 = 3.7; inter1 = 2; inter2 = 1; switch1 = dato1 < (dato2 * 0.5); /* switch1 = 10.5 < 1.85 = FALSO (= 0) */ flag = inter1 != inter2; /* flag = VERO ( 0) */}
124© Piero Demichelis
Operatori logici
• Operano su espressioni “booleane” e forniscono un risultato logico o “booleano”.
! && ||NOT AND OR
• Equivalenti agli operatori Booleani di base. Stesse regole di precedenza
• NOT > AND > OR
• Esempi: (x > 0) && (x < 10) (x compreso tra 1 e 9) (x1 > x2) || (x1 == 3)
125© Piero Demichelis
Esempio
#define FALSO 0#define VERO 1main(){int dato1, dato2;short int test, flag, condiz;
dato1 = 5;dato2 = 3;flag = VERO;test = !flag; /* test = NOT flag cioè FALSO (= 0)
*/condiz = (dato1 >= dato2) && test;/*condiz = VERO AND FALSO cioè FALSO (= 0) */}
126© Piero Demichelis
Operatori di manipolazione dei bit
• Il C possiede una serie di operatori che possono agire direttamente sui bit delle variabili e costanti di tipo intero o carattere, dichiarate nel programma.
• Si tratta di 4 operatori derivati direttamente dalle operazioni booleane di base e di altri 2 che eseguono l’operazione di shift (destra e sinistra) di un certo numero di bit.
• I primi si prestano a “mascherare” o “commutare” i bit, i secondi possono essere utili nelle operazioni di divisione e moltiplicazione per 2.
• Tranne uno, sono tutti operatori binari, che agiscono cioè su due espressioni.
127© Piero Demichelis
Richiamo: operatori Booleani
A B
0 1
0 0 1
1 1 1
A B
0 1
0 0 0
1 0 1
A AND B
A 0 1
1 0
A B
0 1
0 0 1
1 1 0
A OR B
NOT A A XOR B
128© Piero Demichelis
Operatori su bit
• Operatori di manipolazione dei bit:
AND bit a bit & Binario
OR bit a bit | Binario
XOR bit a bit ^ Binario
NOT bit a bit (complemento a 1)
~ Unario
Shift a sinistra << Binario
Shift a destra >> Binario
Operazione Operatore tipo
129© Piero Demichelis
Operatori su bit: esempi
unsigned char z, x = 3, y = 13;
z = x & y
z = ~ x
0 0 0 0 0 0 1 1
0 0 0 0 1 1 0 1
x
y
0 0 0 0 0 0 1 1
0 0 0 0 1 1 0 1
0 0 0 0 0 0 0 1
0 0 0 0 0 0 1 1
1 1 1 1 1 1 0 0
y
x
z
x
z
AND
NOT
130© Piero Demichelis
Operatori su bit: esempi
z = x | y
z = x ^ y
0 0 0 0 0 0 1 1
0 0 0 0 1 1 0 1
0 0 0 0 1 1 1 1
0 0 0 0 0 0 1 1
0 0 0 0 1 1 0 1
0 0 0 0 1 1 1 0
NOTA: Il significato decimale non è rilevante!
OR
EXOR
131© Piero Demichelis
Operatori di shift
• Equivalenti alla divisione/moltiplicazione per le potenze di 2.
• Sintassi:<operando> >> <num. posizioni>
<operando> << <num. posizioni>
• Significato: fai scorrere <operando> a destra/sinistra di un numero di bit pari a <num. posizioni>
• Sia <operando> che <num. posizioni> devono essere valori interi.
132© Piero Demichelis
Operatori di shift
• I due operatori operano diversamente a seconda del tipo numerico
• Dati unsigned: equivale allo shift logico;
<< inserisce degli ‘0’ nelle posizioni meno significative >> inserisce degli ‘0’ nelle posizioni più significative
• Dati con segno: equivale allo shift aritmetico;
<< aggiunge degli ‘0’ nelle posizioni meno significative, e mantiene inalterato il bit più significativo (segno)
>> inserisce un valore uguale al bit più significativo (bit di segno) mantenendo pertanto inalterato il segno;
133© Piero Demichelis
Operatori di shift
• Esempio:
unsigned char x = 15; /* x = 00001111 */x = x << 2 /* x = 00111100 (15 x 22 = 60) */x = x >> 2 /* x = 00000011 (15 / 22 = 3) */
char x = -15 /* x = 11110001 */x = x << 2 /* x = 11000100 (-15 x 22 = - 60)
*/x = x >> 2 /* x = 11111100 (-15 / 22 = - 4) */
• Anche per questi operatori è consentita la scrittura abbreviata:
x <<= 2 equivale a x = x << 2
134© Piero Demichelis
Operatori di manipolazione dei bit
• Con questi operatori si possono eseguire operazioni complesse sui singoli bit delle variabili dei programmi.
• Esempio:
unsigned char car = ‘m’, val = 1;
.................... car = car & ~ (val << 5 );
AND NOT left shift
provoca la trasformazione del carattere ‘m’ (il cui codice ASCII è 109) nel valore intero 77 corrispondente, in codice ASCII al carattere ‘M’.
135© Piero Demichelis
Operatori bit-a-bit: esempio riassuntivo
car = car & ~ ( val << 5 )
Codice binario del numero 1 su 8 bit (variabile val)
05 4 3 2 167
0 0 0 00 10 0
136© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operazione di shift a sinistra di 5 posizioni sulla variabile val (risultato = 32).
0 0 0 00 10 0
0 0 0 00 00 1
137© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operazione NOT sul risultato del precedente shift (risultato = 223 in binario puro).
0 0 0 00 10 0
0 0 0 00 00 1
1 1 1 11 11 0
138© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
In car vi è il codice di ‘m’, cioè 109.
0 0 1 01 11 1
1 1 1 11 11 0
139© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operatore AND (&): esegue l’operazione logica AND tra i bit corrispondenti delle due variabili interessate.
bit 0
0 0 1 01 11 1
1 1 1 11 11 0
car
(val << 5)
1
140© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operatore AND (&): esegue l’operazione logica AND tra i bit corrispondenti delle due variabili interessate.
0 0 1 01 11 1
1 1 1 11 11 0
car
(val << 5)
0 1
bit 1
141© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operatore AND (&): esegue l’operazione logica AND tra i bit corrispondenti delle due variabili interessate.
0 0 1 01 11 1
1 1 1 11 11 0
car
(val << 5)
01 1
bit 2
142© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operatore AND (&): esegue l’operazione logica AND tra i bit corrispondenti delle due variabili interessate.
0 0 1 01 11 1
1 1 1 11 11 0
car
(val << 5)
1 01 1
bit 3
143© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operatore AND (&): esegue l’operazione logica AND tra i bit corrispondenti delle due variabili interessate.
0 0 1 01 11 1
1 1 1 11 11 0
car
(val << 5)
0 1 01 1
bit 4
144© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operatore AND (&): esegue l’operazione logica AND tra i bit corrispondenti delle due variabili interessate.
0 0 1 01 11 1
1 1 1 11 11 0
car
(val << 5)
0 1 01 10
bit 5
145© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operatore AND (&): esegue l’operazione logica AND tra i bit corrispondenti delle due variabili interessate.
0 0 1 01 11 1
1 1 1 11 11 0
car
(val << 5)
0 1 01 11 0
bit 6
146© Piero Demichelis
Operatori bit-a-bit: esempio
car = car & ~ (val << 5 )
Operatore AND (&): esegue l’operazione logica AND tra i bit corrispondenti delle due variabili interessate.
0 0 1 01 11 1
1 1 1 11 11 0
car
(val << 5)
0 0 1 01 11 0
bit 7
147© Piero Demichelis
Operatori bit-a-bit: esempio
Valore finale di car
car = car & ~ (val << 5 )
In pratica si è “spento” il bit in posizione 5 di car
05 4 3 2 167
0 0 1 01 11 1
1 1 1 11 11 0
car
(val << 5)
0 0 1 01 11 0
149© Piero Demichelis
Istruzione composta
• Una sequenza di istruzioni può essere racchiusa tra le parentesi graffe per costituire quella che è nota come
istruzione composta• Il C considera il blocco di istruzioni che costituiscono
l'istruzione composta come se si trattasse di una sola istruzione.
..........................printf (“\nIntroduci due dati interi da elaborare:");scanf ( "%d%d", &dato1, &dato2);{coeff = 10.5; scala = 3;} • Lo stesso corpo di un programma può essere considerato
come un'unica istruzione composta.
150© Piero Demichelis
Operatore sizeof
• Quando si realizzano programmi per i quali “deve” essere garantita la trasportabilità, può sorgere la necessità di conoscere quanti byte occupa un certo tipo di dato su una particolare macchina: ad esempio, il tipo int può impegnare 2, 4 o 8 byte.
• L'operatore sizeof può agire o su un tipo, ad esempio,
sizeof (double)
o su una variabile, un vettore, un’espressione, una struct, ad esempio,
sizeof (dato_real)
in ogni caso restituisce un intero corrispondente al numero di byte occupato dall‘argomento.
• In seguito vedremo numerose e importanti applicazioni di
questo operatore.
151© Piero Demichelis
Operatore sizeof
• Esempio: programma che visualizza il numero di bit sui quali è rappresentato un carattere, un numero intero, un numero reale, un numero double.
#include <stdio.h>int num_bitmain(){num_bit = sizeof ( char ) * 8;printf (“\nSu questa macchina un char e' su %d bit", num_bit);printf (“\n un intero su %d bit", (sizeof (int) * 8));printf (“\n un float su %d bit", (sizeof (float) * 8));printf (“\n un double su %d bit", (sizeof (double) * 8));}