Corso di Laboratorio di Linguaggi

Corso A
Andrea Grosso
grosso@di.unito.it, 011-6706824

Corso di Laboratorio di LinguaggiCorso A – p.1/28

Sommario
Organizzazione del corso.
Corso di linguaggio C.
Motivazioni.
Organizzazione.
Introduzione al C.
Struttura di un programma.
Tipi fondamentali.
Dichiarazione di variabili.
Funzioni.
Array e stringhe.

Corso di Laboratorio di LinguaggiCorso A – p.2/28

 Introduzione al C
Struttura di un programma C.
Al livello più alto sono presenti:
direttive al precompilatore/definizioni di macro.
dichiarazioni di variabili (globali);
dichiarazioni/definizioni di funzioni;
definizioni di tipi.
I commenti possono essere
su più righe, tra /* e */
if( i!= j ) { ...
c=3;/* Queste righe non saranno
considerate dal compilatore */
fino a fine riga, dopo //
for(i=0; i<n; i++) { // Parte non compilata
Corso di Laboratorio di LinguaggiCorso A – p.3/28

Introduzione al C
Direttive del precompilatore.

Non fanno parte del linguaggio C.

Contraddistinte dal carattere # a inizio riga.
Operano attraverso meccanismi di sostituzione e/o
inclusione di file.
#include <filename>
sostituisce nel testo questa riga con l’intero contenuto
del file filename.
Usato per l’accesso alle librerie standard.
Esempio:
#include <stdio.h> /* Accesso alle funzioni
di I/O fondamentali. */
Corso di Laboratorio di LinguaggiCorso A – p.4/28
 Introduzione al C
Direttive del precompilatore.

#define hsymi htexti

sostituisce al nome simbolico hsymi il testo htexti in
tutto il resto del file.

Esempio.
#define MAX_IDX 100
...
for(i=0; i<MAX_IDX; i++) { ... }

Corso di Laboratorio di LinguaggiCorso A – p.5/28

Introduzione al C
La sintassi del C è molto simile alla sintassi Java.
Costrutti di controllo fondamentali (for, while,
do . . . while) e operatori comuni.
Dichiarazioni di variabili simili.
Blocco: sequenza di istruzioni delimitata da {. . . }.
Regione di visibilità/validità di una variabile (scope);
locale al blocco nella quale essa è dichiarata,
oppure
globale (dal punto di dichiarazione in poi) se non è
dichiarata in un blocco.
Le dichiarazioni di variabile possono apparire
all’inizio dei blocchi (non ovunque);
fuori da ogni blocco (scope globale).
Corso di Laboratorio di LinguaggiCorso A – p.6/28
 Introduzione al C
Assegnazione.

hlvaluei=hexpri

hlvaluei — un’espressione che costituisce un

riferimento a variabile (nome variabile, array-posizione,
ecc.).
hexpri — espressione valutabile, e di tipo compatibile
con la variabile referenziata da hlvaluei.
Attenzione: l’assegnazione stessa è un’espressione!
if( a=3 ) {...} /* Corretto! */
a=2*(b=4); /* Corretto! */

Corso di Laboratorio di LinguaggiCorso A – p.7/28

Introduzione al C
Nota sui tipi booleani.
In C non esiste un tipo booleano.
Un’espressione qualunque, nel contesto opportuno,
viene considerata
VERA, se ha un valore diverso da 0,
FALSA, se ha valore 0.
Gli operatori di confronto ritornano valori 0/1 se hanno
risultato falso/vero.
if( a==b ) {...} /* Se a==b ... */
if( a=3 ) {...} /* Corretto! Sempre vero. */
if( 0 ) {...} /* Corretto! Mai eseguito. */
a= (2>3); /* Corretto! a=0. */
b= (3==3); /* Corretto! b=1. */
Corso di Laboratorio di LinguaggiCorso A – p.8/28
 Introduzione al C
Costrutti di controllo: if . . . else . . .

if(hexpri) hBloccoi1 else hBloccoi2

Valuta hexpri;
Se hexpri è “vera”, esegui hBloccoi1 ,
altrimenti esegui hBloccoi2 .
hBloccoi1 , hBloccoi2 possono anche essere istruzioni
singole, senza {}. La parte

else hBloccoi2

è opzionale.
if( a%2==0 ) printf( "Pari\n" );
else printf( "Dispari\n" );
Corso di Laboratorio di LinguaggiCorso A – p.9/28

Introduzione al C
Costrutti di controllo: for.

for(hexpri1 ;hexpri2 ;hexpri3 ) hBloccoi

hBloccoi può anche essere un’istruzione singola, senza {}.

1. Valuta hexpri1 ;
2. SE hexpri2 è “vera”
esegui hBloccoi;
valuta hexpri3 ;
torna a (2);
ALTRIMENTI (hexpri2 “falsa”) vai alla prima istruzione
che segue hBloccoi
for(i=0; i<5; i++) printf( "Hello\n" );
Corso di Laboratorio di LinguaggiCorso A – p.10/28
 Introduzione al C
Costrutti di controllo: while.

while(hexpri) hBloccoi

1. Valuta hexpri;
2. SE hexpri è “vera”, esegui hBloccoi;
3. Torna a (1).
i=0;
while( i<5 ) {
printf( "Hello\n" );
i=i+1;
}

Corso di Laboratorio di LinguaggiCorso A – p.11/28

Introduzione al C
Costrutti di controllo: do . . . while.

do hBloccoi while(hexpri);

1. Esegui hBloccoi;
2. Valuta hexpri;
3. SE hexpri è “vera” torna a (1), altrimenti prosegui.
i=0;
do {
printf( "Hello\n" );
i=i+1;
} while( i<4 );

Corso di Laboratorio di LinguaggiCorso A – p.12/28

 Introduzione al C
Tipi fondamentali.
Numeri interi.
( ) ( ) ( )
unsigned short char
signed long int
opt opt

Reali in virgola mobile.

( )
float
longopt
double

Corso di Laboratorio di LinguaggiCorso A – p.13/28

Introduzione al C
Lo standard definisce range minimi per i vari tipi.
Type Size Range
unsigned char 8 bits 0 to 255
char 8 bits -128 to 127
unsigned int 16 bits 0 to 65,535
short int 16 bits -32,768 to 32,767
int 16 bits -32,768 to 32,767
unsigned long 32 bits 0 to 4,294,967,295
long 32 bits -2,147,483,648 to 2,147,483,647
float 32 bits ±1.17549435 · 10−38 to 3.40282347 · 10+38
double 64 bits ±2.2250738585072014 · 10−308 to 1.7976931348623157 · 10+308
long double 80 bits ±3.4 · 10−4932 to 1.1 · 104932

Corso di Laboratorio di LinguaggiCorso A – p.14/28

 Dichiarazioni di variabili
Hanno la seguente struttura.

hstorage-classiopt htype-namei hdichiaratorii;

hstorage-classi è opzionale; specifica alcune peculiarità
delle variabili dichiarate (per ora, non verrà usato);
htype-namei è un nome di tipo;
hdichiaratorii è una sequenza di uno o più dichiaratori
separati da virgole.

Corso di Laboratorio di LinguaggiCorso A – p.15/28

Dichiarazioni di variabili
Dichiaratore
il più semplice è un identificatore di variabile;
può contenere operatori che specificano tipi particolari
— aggregati (array), puntatori, ecc. . .
può specificare anche un valore iniziale, preceduto da
‘=’.
int i, x=3; /* Crea gli interi i e x */
/* x ha valore iniziale 3 */
double x, y, z; /* x, y, z sono variabili
reali in doppia precisione */
int k=3; /* k e‘ intero,
e al momento della creazione varra‘ 3 */
char lettera=’A’, num=80;
Corso di Laboratorio di LinguaggiCorso A – p.16/28
 Dichiarazioni di variabili
hstorage-classi, se specificato, può essere uno tra
extern specifica che la variabile è definita in un altro file.
static dipende dal contesto (vedi oltre).
auto è la classe di default; la variabile ha validità limitata al
blocco corrente – tipicamente si omette.
register indica al compilatore che alla variabile deve
essere garantito, se possibile, un accesso “veloce”.
typedef crea un nuovo nome di tipo.
Nota. La definizione del linguaggio non obbliga i compilatori ad allocare le variabili
register in modo particolare.

Corso di Laboratorio di LinguaggiCorso A – p.17/28

Storage class: static

L’effetto di static in una dichiarazione

static T x;

dove T è un nome di tipo e x (un dichiaratore di) una

variabile, dipende dal contesto in cui appare.

Se appare all’interno di un blocco: specifica che la vita

della variabile x si estende all’esecuzione dell’intero
programma; la sua validità non si esaurisce al blocco
corrente (ma la visibilità è comunque limitata).
Se appare nello scope globale: specifica che la
variabile x è privata per questo file sorgente (=modulo),
e la sua visibilità non può essere esportata ad altri
moduli, neanche per mezzo di una extern.
Corso di Laboratorio di LinguaggiCorso A – p.18/28
 Dichiarazioni di variabili
Regole di inizializzazione.
Nella dichiarazione di una variabile x di tipo T :
se la dichiarazione specifica un valore iniziale v , x è
impostato a v al momento della sua creazione.
se la dichiarazione non specifica alcun valore iniziale, al
momento della sua creazione x contiene
il valore nullo del tipo T (es. 0 per tipi numerici)
solo se x risiede nello scope globale o se ha storage
class static;
altrimenti x ha valore indefinito (“sporco”).
Alcuni compilatori inizializzano a valore nullo tutte le variabili auto, ma questo non è
imposto dalla definizione del linguaggio.

Corso di Laboratorio di LinguaggiCorso A – p.19/28

Funzioni
Sono le unità nelle quali è suddiviso il codice eseguibile
all’interno di un file sorgente.
Sono caratterizzate da
un nome che le identifica e premette di richiamarle;
una lista di parametri passati esclusivamente per
copia;
tipo del risultato.
Non c’è polimorfismo.
double func(double x) { ... }
int func(unsigned char t) { ... }
/* Errore! */

Corso di Laboratorio di LinguaggiCorso A – p.20/28

 Funzioni
Definizione di funzioni. Hanno la seguente sintassi.

htypenamei hfunction-namei (hparam-listi) hbloccoi

htypenamei è un identificatore di tipo che determina il

tipo di valore ritornato dalla funzione;
hfunction-namei è il nome della funzione;
hparam-listi è una lista di una o più dichiarazioni di
parametri
htypename1 i hparam1 i, htypename2 i hparam2 i, . . .
| {z }
dichiaratore

hbloccoi è il corpo della funzione, nel quale sono

racchiusi definizioni di eventuali variabili locali e
istruzioni da eseguire.
Corso di Laboratorio di LinguaggiCorso A – p.21/28

Funzioni
In qualunque punto del corpo di una funzione,
l’istruzione

return hespressionei;

fa terminare l’esecuzione della funzione e passa al

chiamante il valore di hespressionei.
Eventuale codice che segue il return nel corpo viene
ignorato quando questo viene eseguito.
Il tipo di hespressionei deve essere compatibile con il
hreturn-typei specificato per la funzione.
Se hreturn-typei = void, la funzione non ritorna alcun
risultato (eventali return non hanno argomento).
Se hparam-listi = void, la funzione non riceve
parametri. Corso di Laboratorio di LinguaggiCorso A – p.22/28
 Funzioni
Esempio.
double power(int base, int expo)
{
double res=1.0; /* Variabile locale */
if( (expo==0) && (base==0) ) {
printf( "Indeterminato\n" );
return 0.0;
printf( "Mai stampato\n" );
}
while(expo>=1) {
res=res*base;
expo=expo-1;
}
return res;
}
Corso di Laboratorio di LinguaggiCorso A – p.23/28

Funzioni
Se a e b sono due espressioni di tipo int,

power(a,b)

è un’espressione di tipo double.

I parametri sono variabili locali, il cui scope corrisponde
al corpo della funzione.
La valutazione dell’espressione power(a,b) causa
la valutazione di a e b;
la copia di tali valori in base ed expo;
l’esecuzione del codice di power;
power(a,b) assume il valore specificato dalla
return eseguita nella chiamata.
Il valore di ritorno si può scartare!
Corso di Laboratorio di LinguaggiCorso A – p.24/28
 Funzioni
Esempio. Per fare emettere un “bip” al terminale (ipotesi: si
usa il codice ASCII).
void beep(void)
{
putchar(7);
}
Per effettuare n “bip”:
void beeps(int n)
{
if(n<0)
return;
for(;n>0;n--)
putchar(7);
}

Corso di Laboratorio di LinguaggiCorso A – p.25/28

Funzioni
Programma principale.

Ogni programma ha una (e una sola) funzione

chiamata main.
Alla funzione main viene trasferito il controllo quando il
sistema operativo pone in esecuzione il programma.
Per main, hreturn-typei può essere solo void o int.
Se main è dichiarata con hreturn-typei=int, è possibile
restituire al sistema operativo un codice di errore
utilizzando return.

Corso di Laboratorio di LinguaggiCorso A – p.26/28

 Funzioni
Esempio. Stampa la tabella dei valori ak , per a = 2, 3, 4, 5 e
k = 0, 1, 2, 3, e fa quattro “bip”.
#define NUM 4
int main(void)
{ int a, k, from=2, to=5;
double p;
for(a=from; a<=to; a++) {
for(k=0; k<NUM; k++) {
p=power(a, k);
printf( "\t%g", p );
}
printf( "\n" ); beep();
}
return 0;
}
Corso di Laboratorio di LinguaggiCorso A – p.27/28

Funzioni
Prototipo di una funzione.
Riproduzione dell’intestazione, seguita da ‘;’.
Sintatticamente analogo a una dichiarazione di
variabile;
scope: dalla dichiarazione a fine file;
i nomi dei parametri sono facoltativi;
dà visibilità alla funzione, anche prima della sua
definizione. Es.:
double power(int base, int expo);
void beeps(int n);
oppure
double power(int, int);
void beeps(int); Corso di Laboratorio di LinguaggiCorso A – p.28/28