Teoria Informatica - Linguaggio C

(vero/falso): non esistono in linguaggio c (a meno di includere alcune librerie)

Valori booleani

Problema della rappresentazione: Vengono sostituiti da numeri interi sotto la convenzione:

Traduzione di un programma c in una sequenza numerica Zero codifica falso

eseguibile da un processore (dove tutto é descritto come bit: Qualunque valore diverso da 0 codifica vero

1, 0)

Definizione del linguaggio attraverso regole generali VARIABILE

Locazione di memoria che contiene un valore tipo che

Il c, come qualsiasi altro linguaggio, rappresenta dati secondo tipi può cambiare nel corso della computazione (il tipo é

invariante)

TIPI Può essere associata ad un che permette di

nome,

Ogni valore ha un tipo. É caratterizzato da: riferirsi alla variabile senza doverne specificare

Insieme dei valori che rappresenta l’indirizzo fisico di memoria

Insieme delle operazioni che si possono eseguire sui suoi valori

Tipi nel linguaggio c:

approssima caratteri (256 caratteri del codice ASCII)

Char: NOME: é una sequenza arbitraria di caratteri

approssima numeri interi (Z). Con o senza segno (0 o numeri

Int: alfabetici e numerici:

positivi) Il primo carattere non può essere un numero

Introduzione al linguaggio c La sequenza ha una lunghezza arbitraria, ma il

# (numero) di byte: variabile a seconda del calcolatore compilatore non distingue tra nomi che non

es. interi con segno su 4 byte=32 bit (cifra binaria che vale 1 o 0) differiscono sui primi 32 caratteri

Char

& ↳ 1 bit può

[-23%23^-1] 232 É il tipo più piccolo usato e nella

numeri interi → assumere due maggioranza dei casi è usato per

valori identificare simboli di particolari Variabile: ente intrinseco dotato di una propria identità

approssimano numeri razionali (Q) in formato floating point

Float: codifiche (caratteri alfabetici, che le deriva dall’unicità delle locazioni di memoria

(virgola mobile) punteggiatura, caratteri speciali.

approssimano numeri razionali in formato floating point

Double: Usato per dichiarare variabili che Riferimento a variabile: ad una variabile é possibile fare

con precisione doppia (uso il doppio del numero di bit (64, invece possono contenere un singolo riferimento in modi diversi, tra i quali il più semplice e

di 32) rispetto al float carattere (lettera, cifra, simbolo) diretto é il nome

tipo nullo, quando la sintassi chiede di specificare un dato che

Void:

non esiste realmente Il nome viene associato alla variabile per il tramite di

Indirizzo a partire dal quale sono memorizzati i dati una dichiarazione, che ne specifica il tipo e ne riserva

Nome della funzione #dati lo spazio di memoria

int calcola Max (int*v, int size);

- int A; Dichiara una variabile di nome A e di

Modo in cui si passa un

insieme di dati

Tipo del valore restituito tipo int

void stampa (int*v, int size)

Quando ho una funzione che non deve

restituire un numero

Variabile Array ESPRESSIONI E OPERATORI

É un insieme di variabili dello stesso tipo che possono Un’espressione è una combinazione di variabili e costanti attraverso operatori. È

essere referenziate attraverso un nome collettivo e un caratterizzato da:

indice numerico che le identifica Valore restituito

Side effects prodotti sulle variabili: ciò che permette di realizzare le computazioni

Dichiara un Array di 10 variabili di

int A[10]; a=10; Un’espressione seguita da ; è un’istruzione

tipo int il cui nome collettivo è A Denotano l’offset della É un’espressione che restituisce il valore 10 e che,

A[0] : riferimento alla prima variabile dell’Array I particolare locazione come side effects, assegna tale valore alla variabile a

A[9] : riferimento all’ultima variabile dell’Array dall’inizio dell’Array

L Nome Array Gli operatori sono classificati per tipo di operazione:

Indirizzo di partenza dell’Array Operatori aritmetici: +, -, * (prodotto), / (divisione), % (modulo).

Indirizzi espressi in byte: intero=4 byte [Il % restituisce il resto della divisione intera

a%2 é un’espressione che restituisce 0 se il valore della variabile a é pari, 1 se é dispari]

A[0] si trova a partire dall’indirizzo A+0 Operatori relazionali: <, >, <=, >=, == (uguaglianza), ! (diverso)

A[1] si trova a partire dall’indirizzo A+1x4 byte

A[2] si trova a partire dall’indirizzo A+2x4bute

COSTANTE Dichiarazione di una variabile

É un valore (di un qualche tipo) che non cambia nel int a, b;

corso della computazione. É rappresentata in modo ...

diverso a seconda del tipo: a>b é un’espressione che restituisce 0 se il valore di a non è maggior di b, mentre restituisce un valore diverso da 0

int: 1, 7, 31... (numeri interi) (di solito 1) in caso contrario

float: 125.7F (numeri con la virgola e la ‘F’ finale) (5>4)+1 restituisce 2

double: 125.7 (numeri con la virgola) a=10+4

Direttiva che definisce una costante

#define TRUE 1 É un’espressione che assegna il valore restituito dall’espressione 10+4 alla variabile di nome a

pari a 1 (sostituisce tutte le costanti Operatori logici: && (congiunzione), ! (negazione), || (disgiunzione)

TRUE con 1) espr1 && espr2–>Restituisce vero se entrambe le espressioni sono vere, sennò falso

#define FALSO 0 espr1 || espr2–> Restituisce vero se almeno una delle due espressioni é vera

L Trova e sostituisci !espr—> Restituisce vero se espr é falsa

int a; //dichiara una variabile di tipo int e nome a int a,b;

a=10; //assegna ad a il valore 10; a=10;

L Riferimento alla variabile a attraverso il suo b=(a==10); //assegna 1 a b

nome b=!(a==10); //assegna 0 a b

// commento Operatori di incremento e decremento: ++, - -

/* commento su più righe Incrementano e decrementano di 1 il valore della variabile alla quale sono applicate

*/ Operatori di assegnamento: =

if

ISTRUZIONI int a, b;

Servono a dirigere il flusso dell’esecuzione. I dati sono elaborati attraverso side effects ( )

→ valore

FALSO pari 0

a

b

a >

...

prodotti dal calcolo delle espressioni e il ruolo delle istruzioni é quello di determinare (

if (a>b): )

=/

valore

l’ordine con cui le espressioni sono eseguite. VERITA o

- -

- _

,

{ 1

Il fatto che il significato risieda nel controllo del flusso fa si che diventi conveniente ; i

10

=

a

1 I

1 I

a=10;

descriverle usando i flow charts (diagrammi di flusso) i ' viene restituito

→

,

b

b=20;

La i ;

20 i

=

i :

Evidenziano in maniera intuitiva il modo } i. -

_ -

-

;

_

.

con cui le diverse istruzioni sequenzializzano

l’esecuzione delle espressioni ✓

int a,b;

Espressione seguita da ; ... FALSO

b

a > {

L’esecuzione consiste nel calcolare l’espressione, produrre if (a>b)

side effects e passare il controllo all’istruzione successiva VERO

a=10, L restituisce b

solo

falso

-

se e

10 ;

a =

b=20; :

Diagramma di flusso: rappresentazione in flow-charts di istruzioni elementari del c falsa

sia

sia

sia

sia

eseguita che

che

ma

b vera

;

20

=

t

int a; f- ;

7

a

a=7; permette di avere due corpi alternativi, eseguiti a seconda che la guardia

if-else:

v restituisca vero o falso

Sequenza: la ripetizione della composizione in sequenza permette di avere

un’istruzione composta da un numero arbitrario di istruzioni Istruzioni int a, b;

...

int a, b; 7 ;

=

a FALSO

if (a>b) b

a > t

a=7; a=10; -

- - - - ,

/ v

b=14; VERO

b ;

14 l

= else 1 20

a ;

=

✓ l

l

;

no

a -

- !

{ a=20;

v ✓

| 1

Compound: istruzione entro parentesi graffe b 30 ;

=

i |

b=30; ! '

Consiste nell’esecuzione dell’istruzione che sta entro la parentesi e poi passare -

-

- -

-

} i

all’istruzione successiva

Rilevanti rispetto alle istruzioni condizionali e di iterazione Iterazione (LOOP): permettono di eseguire ripetutamente un corpo di istruzioni fino

- -

1- - - - -

int a, b; , al verificarsi di una qualche condizione sui valori delle variabili del programma.

1 7 ; l

=

a

l l

{ a=7; ' l Esistono tre diverse istruzioni di iterazione:

' l

b=14; ' l

b for

' ; ;

14

=

;

} while

1- -

- - -

-

e

-

- do-while

Condizionali: permettono di decidere direzioni diverse nel flusso di esecuzione in

base al valore restituito da un’espressione e condizionano l’esecuzione di

un’istruzione detta corpo al valore restituito da un’espressione detta guardia stessa sintassi del while con la differenza che l’espressione di guardia è in coda al

do-while:

un corpo di istruzioni é eseguito ripetutamente sotto il controllo di una guardia

for: corpo di istruzioni

costituita da tre espressioni:

1. Inizializzazione int count, sum;

2. Guardia (condizione) Counter ;

count=1; SUMÌO

3. Incremento ;

sum=0;

do { - -

- - ,

Calcolare la somma dei primi 9 numeri interi a partire da 1 sum=sum+count; sumtcount ;

sum

i __ |

' l

✓

count=count+1; ' Counter

Counter |

;

int count; ! i

} while (count<10); -

j -

-

-

- -

-

int sum;

sum=0; countcrofaso

for (count=1; count<10; count++)

→ sum=sum+count; VERO

Il corpo di istruzioni é eseguito almeno una volta ✓

for (count=1, sum=0; count<10; count++) {

LA sum=sum+count;

...

} for si usa quando è noto il numero di interazioni da eseguire

sum o

- É possibile il caso in cui l’espressione while quando non é noto, infatti si parafrasa come “ripeti il ciclo

carità ; di condizione risulta falsa al fintantoché resta vera la condizione C”

Istruzioni

✓ momento della prima esecuzione e il do-while quando siamo sicuri che il corpo debba essere eseguito

FALSO

> country o controllo passa all’istruzione almeno una volta

VERO

✓ successiva senza aver mai eseguito il

sumtcount

sum -

_ corpo

courittt

;

~ successiva

all' iscrizione

passa

un corpo di istruzioni é eseguito ripetutamente fintanto che un’espressione di

while:

guardia restituisce un valore vero count 1

= ,

int count, sum; SUMÌO

count=1; ;

✓

sum=0; FALSO

while (count<10) { cantaro

)

sum=sum+count; VERO

count=count+1; 1- - -

- - - -

- -

- l

✓

} ' i

sumtcount

;

sum -

, 1

Éountti

I Court i

-_ ,

| !

1- -

- - - .

-

v

Il corpo di istruzioni potrebbe non essere mai eseguito

Scrittura di un programma c che calcola in fattoriale di un intero (lo int: tipo del valore restituito dalla funzione

scriviamo su un file con estensione .c) main: funzione che riceve il controllo quando il programma va in

esecuzione: prima funzione a ricevere il controllo e ultima a

restituirlo (ogni programma é organizzato in più funzioni).

Il valore che la funzione main restituisce fa capire se la funzione é

terminata correttamente ed è sempre un valore intero Scanf: funzione che fa parte della

libreria (insieme di funzioni) standard di

#include <stdio.h>

.h file di intestazione: nella libreria input e output del linguaggio c

int main ( ) {

standard si trova la dichiarazione “‰d” sequenza di caratteri che indica il

int N; // N contiene il valore di cui vogliamo calcolare il fattoriale

delle costanti delle funzioni ecc.. tipo di dato da acquistare (‰d int, ‰f,

int count;

File sorgente .c (definizione delle float)

int face;

funzioni) &N indirizzo a partire dal quale deve

N=10; Scanf (“‰d”, &N); essere memorizzato il dato

fact=1;

for (count=2; count<=N; count++)

printf: stampa a video fact=fact*count; Istruzione che restituisce alla

“fattoriale=‰” è una stringa: sequenza di funzione chiamante (quella che

caratteri printf (“fattoriale=‰”, fact); invoca main) il controllo e un

‰d é un segnaposto che nella stampa sarà return 0; valore

sostituito dal valore di fact }

Potrebbero esserci dei parametri

void myFunction ( ); {

... if (...)

} return; (opzionale) return; //restituisce il controllo alla funzione

int main ( ){ chiamante

... Trasferisce il controllo a

myFunction ( ); //invoca la funzione my Function quella funzione

...

}

int myFunction2 ( ){ int calcolaMax ( ) {

... Riferimento a variabile

int max;

return100; ...

} return max;

}

Espressione che restituisce un valore di tipo int int main ( ) {

int m; L’ invocazione di una

...

Se non mette nessun ritorno il funzione é un’espressione

Assegna alla variabile m il m=calcolaMax ( );

compilatore da errore valore restituito dalla ...

funzione calcolaMax }

Esistono due tipi di dati che occorre rappresentare nella codifica di un programma: i tipi Algoritmi di conversione della base di rappresentazione

che codificano testo e quelli che codificano valori numerici Si possono fare i calcoli nella base di partenza e nella base di arrivo:

Algoritmo che impiega l’aritmetica della base di arrivo

In c esistono tre diversi tipi dedicati a rappresentare valori numerici: 1. Sviluppo polinomiale nella base di partenza

int 2. Conversione di coefficienti e potenze nella base di arrivo

float 3. Svolgere somme e prodotti nella base di arrivo

double Base 2 Base 10

E

I caratteri sono rappresentati con il tipo char, che poi é esso stesso codificato nella forma

di un numero. ]

[

[ 1.2°

]

[ +1.25+1.22=64+32+4 ] 100

1100100 =

= yo

,

,

NUMERI Base 10 Base 2

•

Un numero é un ente dotato di un suo significato intrinseco, del quale è possibile dare

rappresentazioni diverse che variano per: [ [

] -102+2.10^+5.10%0=[1-10.10+2.10+5]

1 =

125 =

, ,o

o

Posizionalitá della codifica: il valore che una cifra assume dipende dalla posizione che [0001.10101010+0010.10101-0101] =

occupa = ,

Base di numerazione si

1 bit numeri {0, 1}

•

#cifre della rappresentazione 2 bit numeri {0, 1, 2, 3}

22

☒

Codifica del segno 3 bit numeri {0, 1,..., 7}

} 1

2

☒ 0001T

Rappresentazione di parti frazionarie e valori razionali 4 bit numeri {0, 1,..., 15}

24

☒ 0001

Rappresentazione dei dati =

Codifica posizionale 001 0

Il peso di ciascuna cifra dipende dalla posizione che essa occupa [ ]

[1100100+10100+0101] 1111101

= 2

,

743--7.10=+4.10^+3 10° 1010

. .

È " Sviluppo polinomiale (determina il

B

]

[ an

=

i "

= 1010

an ora

an =

ao

2 B

e valore codificato)

- , ,

- .

, . ,

. n o

= +

0000

Most significant Least significant 1010 t

/

digit digit Base di rappresentazione t

0000 /

/

1010

Rappresentazione sul calcolatore: BIG ENDIAN/LITTLE ENDIAN 1100100

Base 16

Dal byte più significativo a quello meno significativo {0, 1,..., 9, A, B,..., F}

Base di numerazione Gli indirizzi di memoria si esprimono solitamente in base 16

Il calcolatore usa la base 2: é la minima base che include cifre diverse (0 e 1) e la minima [

[

base con cui é possibile contare in modo posizionale. Questo semplifica algoritmi ] ]

ABDF =

g

, 2

.

.

.

- 16 bit

implementati nell’unitá aritmetico logica ↳

4 cifre 16 cifre binarie

esadecimali

Parti frazionarie

Algoritmo che impiega l’aritmetica della base di partenza Sono numeri razionali inferiori all’unitá

Base 10 Base 2

Da Algoritmo di conversione della base di rappresentazione che impiega l’aritmetica

della base di arrivo:

-2%091<+1

[

[ "

] "

" "

1- =

AN -2

2 aot jak aot

AN ando Ak -2

= -

= =

1 .

2

- 1. Sviluppo polinomiale nella base di partenza

. .

. . .

. ,

1<=0

Resto della divisione intera A/2 2. Conversione di coefficienti e potenze nella base di arrivo

È É un numero pari 3. Operazioni nella base di arrivo

"

Artu

2

t 2

ao

= '

. 1<=0

Quoziente della divisione intera Base 10 Base 2

b

vale 1 se e solo se A é dispari

ao 10=[7.10-1]

7)

[ [7/10]^0=[0111/1010] 2=[0-10110]

a. =

é il resto della divisione intera A/2 .io 2

QO

Iteriamo il procedimento: 1010

0111.00000000

: i

È 0.10110

[

È "

" "

"

"

/ 0000

9kHz

A aktz -

an

2 -2

+ 2 =p

= a +

- =

e.

,< .

+ ,

1<=0 1<=0

1<=1 i

01110 - Non é detto che una parte

1010 .

01000

[ frazionaria rappresentata su un

" A :3

7 QUOZIENTE

2

2- aktz

= ar t - 0000

-

1<=0 numero finito di cifre in base 10

10000

2=7/2

/

A 1010 abbia una rappresentazione finita

)

( ao

RESTO 1

: 1100 in base 2

1010

00100

Questo procedimento identifica un algoritmo chiamato algoritmo delle divisioni 000

Rappresentazione dei dati

successive che termina quando il quoziente della divisione é 0 Il numero é periodico

1000

[ ]

[ ] 1111101

125 - ,

» 1010 é contenuto in 0111? No, perché la cifra significativa é maggiore.

2

2

72