Il linguaggio C

(1)

1 Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio

Il linguaggio C

- Sviluppato da Ritchie sulla base di due linguaggi di programmazione esistenti: BCPL e B

- Nel 1990 è stato standardizzato da ANSI (American National Standards Institute). Chiamato C89.

- Nel 1999 è stato aggiornato con l'introduzione di alcune caratteristiche innovative. Chiamato C99.

- Usato per sviluppare ed implementare il sistema operativo UNIX

- Il code del linguaggio è indipendente dalla piattaforma hardware (portabilità) - Esistenza di alcuni ‘dialetti’

Alcune parole chiavi del linguaggio C

(2)

Linguaggio C

Tipi definiti dal linguaggio

… per ora solo i tipi atomici INTERO int

costituito da numeri interi compresi tra -2^(N-1) a 2^(N-1) - 1 dove N è il numero di bit usato per rappresentare un numero intero (valori tipici sono 16 e 32).

Oltre a int si hanno i tipi interi short int e long int per rappresentare numeri interi con un numero di bit minore o maggiore di N (tipicamente short int usati 16 bit mentre per long int 32 bit, 16 o 32 bit per int)

Principali operatori (interni) del tipo somma +

sottrazione - moltiplicazione *

divisione (intera) / (il risultato è un numero intero - con troncamento) resto della divisione %

Linguaggio C

2³¹ - 1 -2³¹

4 int

long int short int

Tipo Tipo

4 2

Dimensione Dimensione

(byte) (byte)

2¹⁵- 1 +32767 -2¹⁵

-32768

-2³¹ Valore Valore minimo minimo

2³¹ - 1 Valore Valore massimo massimo

… riepilogando ...

(3)

Possibile aggiungere il qualificatore unsigned alla definizione di tipo, che consente alla variabile di contenere solamente numeri positivi

+2³² - 1 0

4 unsigned int

unsigned long int unsigned short int

Tipo

4 2

Dimensione (byte)

65535 0

0

Valore minimo

+2³² - 1 Valore massimo

Linguaggio C

REALE float

costituito dall sottinsieme dei numeri reali rappresentabile dall’elaboratore.

Si hanno anche i tipi double e long double per rappresentazioni in doppia precisione e maggiori.

Principali operatori (interni) del tipo somma +

sottrazione - moltiplicazione * divisione (intera) /

Tipicamente per il tipo float sono usati 4 byte con una precisione di 6 cifre decimali, per il double 8 byte e 10 cifre decimali

Linguaggio C

±1.710⁺³⁰⁸

±2.210^-308 8

double float

precisione singola Tipo (IEEE 754)

4

Dimensione (byte)

±3.410⁺³⁸

± 1.17.210^-8 Valore minimo

Valore massimo

(4)

Esistono due notazioni per scrivere/visualizzare numeri reali

<parte intera> < punto> <parte decimale>

4.34 notazione esponenziale

<parte intera> <e> o <E> <esponente con segno>

-3E3 rappresenta -310

³

cioè –3000 5e-2 rappresenta 510

^-2

cioè 0.05

Linguaggio C

CARATTERE char

costituito dall’insieme dei caratteri di stampa.

In realtà, in C è assunto come tipo carattere il sottinsieme dei numeri interi compresi tra 0 e 255, ovvero dai valori numerici del codice ASCII con cui sono codificati i caratteri.

i valori di tipo char sono racchiusi tra apici, es.:

'A' 'b' ';' '&'

caratteri non stampabili (caratteri speciali per il controllo di dispositivi) vengono indicati con la sequenza (sequenza di escape):

\ <carattere convenzionale>

Es.:

'\n' indica il ritorno a nuova linea (a capo) '\t' tabulazione

'\’’ ' doppio apice

Linguaggio C

(5)

Operazioni su char

Ad ogni carattere corrisponde una rappresentazione numerica univoca I caratteri sono totalmente ordinati

Possibili operazioni:

restituire il carattere che segue/precede;

operazioni di uguaglianza/disuguaglianza;

chiedersi se un carattere è maggiore/minore di un altro

…

Linguaggio C

LOGICO non esiste in C

E’ assunto in sua vece il tipo intero, assumendo il valore 0 per falso e il valore 1(o più in generale un valore diverso da 0) per vero.

Quindi, se una operazione di relazione non è verificata da come risultato il valore 0; se la relazione è verificata il risultato è 1 (o un valore diverso da 0).

Gli operatori logici sono:

NOT ! OR ||

AND &&

Linguaggio C

(6)

Nomi degli identificatori (variabili)‏

devono iniziare con un carattere alfabetico (una lettera, il

carattere _ è considerato una lettera) seguito da altre lettere o cifre;

non possono contenere il carattere <spazio> né altri caratteri.

E’ fatta distinzione tra maiuscolo e minuscolo, per cui il nome ris è diverso da Ris o RIS (ovvero ris, Ris e RIS sono tre variabili diverse).

I nomi non possono essere uguali a parole chiavi del linguaggio Linguaggio C

Dichiarazione dei Nomi degli identificatori (variabili)‏

Deve essere indicato il tipo di ogni variabile prima di un utilizzo della stessa

<nome tipo> <lista variabili>;

Es.

float area_quadrato, lato_quadrato;

int nro_studenti, ore_lezioni;

char sigla;

double radice_equazione;

Quando viene dichiarata, una variabile può essere inizializzata con un valore

Es. int nro_studenti, ore_lezioni = 20;

Linguaggio C

(7)

Operatori Aritmetici

somma + sottrazione - moltiplicazione * divisione (intera) / resto della divisione % Relazionali

uguaglianza = = diverso !=

maggiore >

minore <

maggiore o uguale >=

minore o uguale <=

Alcune funzioni Aritmetiche

valore assoluto - tipo intero - abs(int n) quoto e resto divisione intera div(int m, int n) Trigonometriche

seno sin(x) coseno cos(x) tangente tan(x)

Esponenziali e logaritmiche e elevato alla x exp(x) log. in base e di x log(x) log. Base 10 di x log10(x) Altre

elevazione a potenza pow(x, y) radice quadrata sqrt(x)

Linguaggio C

Tipi Atomici

int - short int - long int - unsigned float - double - long double char

Struttura di un programma in linguaggio C

Un programma in linguaggio C è tipicamente strutturato nel seguente modo:

[<direttive di inclusione>]

main ( ) {

<sezione dichiarativa>

<corpo del programma>

}

(8)

I commenti in C

• preceduti da // (se il commento è scritto su una sola riga)

• oppure racchiusi tra /* */ (se il commento è scritto su più righe)

// questo è un commento (su una sola linea) [<direttive di inclusione>]

main ( ) {

/* questo è un commento disposto su più linee */

<sezione dichiarativa>

/* altro commento */

<corpo del programma>

}

... Ovviamente i commenti non sono presi in considerazione dal compilatore ...

Esempio:

Operazioni di calcolo e assegnazione

<identificatore> = <espressione>;

<espressione> può essere semplice come una singola costante o può essere una combinazione di variabili, operatori, …

Semantica:

calcola il valore di un’espressione (lato destro, rispetto a segno =) ed assegnalo ad una variabile (lato sinistro)

L’eventuale valore memorizzato precedentemente nella variabile viene sostituito dal nuovo valore

Es.

A = 26;

perimetro_quadrato = lato_quadrato * 4;

Linguaggio C

(9)

Operazioni di ingresso e uscita

Un programma C comunica con l’esterno tramite uno o più flussi (stream).

Esistono:

• un flusso standard di ingresso, per le operazioni di ingresso ed associato alla tastiera,

• un flusso standard di uscita, per le operazioni di uscita ed associato al monitor.

Ai flussi sono associate delle funzioni predefinite che si trovano in una specifica libreria di ingresso/uscita chiamata <stdio.h>

La libreria <stdio.h> va indicata nelle direttive di inclusione

Linguaggio C

Operazioni di ingresso:

scanf‏(“<formato1> ... <formatoN>”‏,‏&<argomento1>,..., &<argomentoN>);

“<formato i>‏”‏:‏stringa indicante il formato in cui sarà inserito il valore dell’ argomento i-esimo

&< argomento1>, ..., &<argomentoN>: nomi di variabili, preceduti dal carattere &, cui saranno assegnati i valori inseriti

Alcuni formati:

%d : interi decimale %f : float %c : carattere

%o : interi ottale %e : float esponenziale %s : stringa

Linguaggio C

Esempi:

scanf("%d", &x) legge il valore di x con formato intero scanf(“%f‏%f”,‏&base, &altezza)

legge i valori di base ed altezza con formato reale

(10)

Operazioni di uscita

printf(“<formato>‏”‏,‏<argomento1>,..., <argomentoN>);

<formato > : stringa che deve essere visualizzata, comprensiva dei riferimenti ai formati relativi ai tipi delle variabili i cui valori saranno visualizzati

<argomenti> : variabili i cui valori devono essere visualizzati

Alcuni formati:

%d : interi decimale %f : float %c : carattere

%o : interi ottale %e : float esponenziale %s : stringa

Linguaggio C

Operazioni di uscita

Alcuni caratteri per il controllo della stampa

\n indica il ritorno a nuova linea (a capo)

\t tabulazione

\’’ doppio apice

Linguaggio C

Es:

printf (“%d”, x); visualizza il valore di x con formato intero printf (“%d %d %f”, x, y, z);

visualizza i valori di x e y con formato intero, quello di z con formato reale

la corrispondenza tra formato e argomento è in base alla posizione

printf (“ ERRORE !”); visualizza la stringa ERRORE ! Sul video

(11)

….‏Esempi‏….

Operazioni di uscita Esempio:

…. si vuole visualizzare il messaggio:

Imponibile = …. Al IVA = ….. Importo IVA = ……

dove al posto dei …. vanno visualizzati i valori delle 3 variabili IMP, ALIVA, IMPIVA

… l’istruzione avrà il seguente formato:

printf ("Imponibile = %f Al IVA = %d Importo IVA = %f \n”, IMP, ALIVA, IMPIVA);

Ad ogni simbolo di formato sarà sostituito il valore della corrispondente variabile (la corrispondenza è in base all’ordine della posizione)

….‏Esempi….

Operazioni di uscita Esempio:

Se: IMP = 32.4 ALIVA = 22 IMPIVA = 6.48

printf ("Imponibile = %f Al IVA = %d Importo IVA = %f \n”, IMP, ALIVA, IMPIVA);

…. visualizza il seguente messaggio:

Imponibile = 32.4 Al IVA = 22 Importo IVA = 6.48

(12)

#include<stdio.h>

main ( )

/* questo programma calcola l’area di un rettangolo */

{

float base, altezza, area;

printf (“immetti base \n”);

scanf (“%f” , &base);

printf(“immetti altezza \n “);

scanf(“%f” , &altezza);

area = base * altezza;

printf (“Area= %f \n”,area);

}

LDP

Intestazione

C

Commento

Sezione dichiarativa

Program area_rettangolo;

// calcola l’area di un rettangolo FLOAT base, altezza, area;

begin

write (‘immetti valore della base’);

read (“%f” base);

write (‘immetti valore della altezza ‘);

read (“%f” altezza);

write‏(‘Area= ‘,‏“%f”‏area);

end.

Corpo del programma

Un semplice programma esempio

main ( )

/* questo programma calcola l’area di un rettangolo */

{

printf ("immetti base \n");

scanf ("%f" , &base);

printf("immetti altezza \n ");

scanf("%f" , &altezza);

printf ("Area= %f \n",area);

}

Direttiva di inclusione per la libreria stdio, input/output standard

(13)

Operatori di incremento e decremento

Per incrementare di 1 il valore di una variabile, ad es:

a = a + 1;

in C è possibile usare l’ operatore di incremento ++

che incrementa di 1 la variabile a cui è applicato, ovvero:

a++ ; è equivalente alla istruzione a = a + 1;

Analogamente l’operatore di decremento -- decrementa di 1 la variabile a cui è applicato:

a-- ; è equivalente alla istruzione a = a - 1;

Linguaggio C

Operatori di incremento e decremento Forma prefissa e postfissa

prefissa

++a la variabile è incrementata prima di essere utilizzata --a la variabile è decrementata prima di essere utilizzata

postfissa

a++ la variabile è incrementata dopo essere utilizzata a-- la variabile è decrementata dopo essere utilizzata

Attenzione ! Gli effetti di forma pre- o postfissa possono essere differenti

Linguaggio C

(14)

Le espressioni:

y = a++ ed y = ++a producono risultati diversi per y Esempi:

Linguaggio C

y=a++

equivale alla sequenza di istruzioni y=a;

a=a+1;

se a=3 dopo l’esecuzione di y=a++

si ha: y=3 a=4

y= ++ a

equivale alla sequenza di istruzioni a=a+1;

y=a;

se a=3 dopo l’esecuzione di y=++a si ha: a=4 y=4

Esempi:

Posto a=4 ed i=6

Linguaggio C

k = ++a * i; equivale a:

a = a + 1;

k = a * i;

ovvero a = 5; k = 30;

k = a++ * i; equivale a: k = a * i;

a = a + 1;

ovvero k= 24; a = 5;

(15)

Altri operatori di assegnazione Forme di assegnazione del tipo

<identificatore> = <identificatore> <op> <espressione>;

Es. x = x - 5 * k;

a = a + p * (r + j);

possono essere scritte nella forma

<identificatore> <op> = <espressione>;

Es. x - = 5 * k;

a + = p * (r + j);

Linguaggio C

C - Strutture di controllo

Sequenza o blocco

{

<istruzioni>

}

{ printf("Immetti un numero intero: ");

scanf("%d", &i);

a = i * 4 + b - c;

printf("%d", a);

} Esempio:

(16)

C - Strutture di controllo

Selezione

if (<condizione>)

<istruzione>;

se <condizione> è vera è eseguita <istruzione>

dove <istruzione> è formata da 1 sola istruzione altra forma:

if (<condizione>) {

<istruzioni>;

}

se <condizione> è vera sono eseguite le <istruzioni>

dove <istruzioni> è più di 1 istruzione

N.B. < condizione> è un’espressione di tipo intero (in C non esiste il tipo logico) ed essa è falsa se ha un valore uguale a zero

………

if (i<100) {

a = b - i;

printf(”%f”, a);

} ………

C - Strutture di controllo

Esempi : Selezione

………

if (a>100)

………

(17)

main ( )

/* questo programma calcola l’area di un rettangolo */

{

printf ("immetti base \n");

scanf ("%f" , &base);

printf("immetti altezza \n");

scanf("%f" , &altezza);

if ((base > 0) && (altezza > 0)) { area = base * altezza;

printf("Area= %f \n", area);

} }

Un semplice programma esempio

C - Strutture di controllo

Selezione

if (<condizione>)

<istruzione1>;

else

<istruzione2>;

se <condizione> è vera è eseguita <istruzione1> (è 1 sola istruzione) altrimenti, se <condizione> è falsa, è eseguita <istruzione2> (è 1 sola istruzione)

(18)

C - Strutture di controllo

Selezione altra forma:

if (<condizione>) {

<istruzioni1>;

} else {

<istruzioni2>;

}

se <condizione> è vera sono eseguite le <istruzioni1>

altrimenti se, <condizione> è falsa, sono eseguite le <istruzioni2>

dove <istruzioni1> e <istruzioni1> sono formate da più di 1 istruzione

C - Strutture di controllo

Esempio : Selezione

………

if (numero > 1000) {

a = b * numero;

} else

c = b - numero;

………

(19)

main ( )

/* questo programma calcola l’area di un rettangolo */

{

printf (“immetti base \n”);

scanf (“%f” , &base);

printf(“immetti altezza \n“);

scanf(“%f” , &altezza);

if ((base > 0) && (altezza > 0)) {

area = base * altezza;

printf(“Area= %f \n”, area);

} else

printf(“Errore: base o altezza = <0 \n”);

}

Un semplice programma esempio

Selezione a più vie in C Struttura switch in C:

switch (<espressione>) {

case c1:

S1;

break;

case c2:

S2;

break;

…

case cN:

Sn;

break;

[ default: S_default; break;

] }

semantica

Valuta valore <espressione>

caso valore c1 esegui S1; esci dalla struttura switch (break);

caso valore c2 esegui S2; esci dalla struttura switch (break);

…

caso valore cN esegui Sn; esci dalla struttura switch (break);

[caso valore diverso da c1 ,..., cN )

esegui S_default; esci dalla struttura switch (break);

] …. (è opzionale)

N.B. :break provoca l’uscita immediata dalla struttura switch

(20)

main ( )

/* questo programma stampa da 1 a 3 stelle o un ! */

{ ...

scanf("%d", &num);

switch (num) {

case 1: {printf("*\n"); break;}

case 2: {printf("**\n"); break;}

case 3: {printf("***\n"); break;}

default: {printf("!\n"); break;}

} }

Esempio: stampa da 1, 2, o 3 stelle in base al numero (compreso tra 1 e 3) immesso , altrimenti stampa un ‘!’

Selezione a più vie in C Struttura switch in C:

main ( )

/* questo programma stampa da 1 a 3 stelle o un ! */

{ ...

if(num==1) printf("*\n");

else

if(num==2) printf("**\n");

else

if(num==3) printf("***\n");

else

printf("!\n");

}

Esempio: stampa da 1, 2, o 3 stelle in base al numero (compreso tra 1 e 3) immesso , altrimenti stampa un ‘!’

Selezione a più vie in C

La struttura switch può essere sostituita con una serie di strutture if else if

(21)

main ( )

/* questo programma stampa da 1 a 3 stelle o un ! */

{ ...

if(num==1) printf("*\n");

else

if(num==2)

printf("**\n");

else

if(num==3)

printf("***\n");

else

printf("!\n");

}

Selezione a più vie in C

main ( )

/* questo programma stampa da 1 a 3 stelle o un ! */

{ ...

switch (num) {

case 1:{printf("*\n");

break;}

case 2: {printf("**\n");

break;}

case 3: {printf("***\n");

break;}

default: {printf("!\n");

break;}

} }

Esercizio:

Scrivere un programma che letto un carattere in ingresso stampa un messaggio indicante se il carattere immesso è una lettera minuscola o maiuscola

… LPD …

// stampa se il carattere immesso è una cifra o una lettera minuscola o maiuscola

…..

char c;

read(“%c”, c);

switch ( c ) begin

case '0' : case '1' : case ’2' : case ’3' : case ’4' : case ’5' : case ’6' : case ’7' : case ’8' : case '9' : write( ‘Cifra ‘); break;

case 'a' : ...… : case 'z' : write( ‘ Lettera minuscola ‘); break;

case 'A' : ...… :case 'Z' : write( ‘ Lettera maiuscola ‘ ); break;

default : write( ‘ Altro Carattere ‘);

end

Selezione: switch

(22)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 43

Program cifra_Lettera;

// stampa se il carattere immesso è una cifra o una lettera minuscola o maiuscola

char c;

begin read(“%c”, c);

if ((c >= ‘0’) and (c <= ‘9’)) then

write ( ‘Cifra’);

else

if ((c >= ‘a’) and (c <= ‘z’)) then

write( ‘ Lettera minuscola‘);

else

if (c >= ‘A’ and c <= ‘Z’) then

write( ‘ Lettera maiuscola ‘ );

else

write( ‘ Altro Carattere\n ‘);

endif endif endif end.

Soluzione con if then else if LPD

La struttura switch può essere sostituita con una serie di strutture if else if

#include <stdio.h>

main()

{// stampa se il carattere immesso è una cifra o una lettera minuscola o maiuscola char c;

scanf(“%c”, &c);

if ((c >= ‘0’) && (c <= ‘9’)) printf( "Cifra \n”);

else

if ((c >= ‘a’) && (c <= ‘z’))

printf( ‘ Lettera minuscola\n ‘);

else

if (c >= ‘A’ && c <= ‘Z’)

printf( ‘ Lettera maiuscola \n‘ );

else

printf( ‘ Altro Carattere\n ‘);

}

Soluzione con if else if in C

(23)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 45

#include <stdio.h>

main() {

// stampa se il carattere immesso è una cifra o una lettera minuscola o maiuscola char c;

scanf(“%c”, c);

if ((c >= ‘0’) && (c <= ‘9’)) printf( ‘Cifra\n ‘);

else if ((c >= ‘a’) && (c <= ‘z’))

{ printf( ‘ Lettera minuscola\n ‘);

}

else if (c >= ‘A’ && c <= ‘Z’)

{ printf( ‘ Lettera maiuscola\n ‘ );

}

else printf( ‘ Altro Carattere\n ‘);

}

Soluzione con if else if

H

Lettera maiuscola

Schermo del video l’utente digita H

c = H

FALSO

Vero

C - Strutture di controllo

while (<condizione>) {

<istruzioni>;

} Cicli iterativi

<Istruzione/i> sarà eseguito tante volte fintantoché <condizione> risulta vera

N.B. < condizione> è un’espressione di tipo intero (in C non esiste il tipo logico) ed essa è verificata se ha un valore diverso da zero

a condizione iniziale while (<condizione>)

<istruzione>;

(24)

#include <stdio.h>

main () {

int Num;

printf( "immetti un numero \n”);

scanf(“%d” , &Num);

while (Num<=100) Num=Num+10;

printf ( ”Numero= %d \n”, Num);

}

Esempio Ciclo while

C - Strutture di controllo

do {

<istruzioni>;

}

while <condizione>;

Cicli iterativi

<Istruzione/i> sarà eseguito tante volte fintantoché <condizione> risulta vera

N.B. < condizione> è un’espressione di tipo intero (in C non esiste il tipo logico) ed essa è verificata se ha un valore diverso da zero

a condizione finale do

<istruzione>;

while <condizione>;

(25)

main () {

int Num;

scanf(“%d” , &Num);

do

Num=Num+10;

while (Num <=100);

printf ( ”Numero= %d \n”, Num);

}

Esempio Ciclo do … while

C - Strutture di controllo

Ciclo ripetitivo (a conteggio)

for (<espressione1>; <condizione>; <espressione2>) <istruzione>;

for (<espressione1>; <condizione>; <espressione2>) {

<istruzioni>;

}

<espressione1>: è l’espressione usata per inizializzare la variabile di controllo del ciclo

<condizione>: è l’espressione logica per verificare la terminazione del ciclo

<espressione2>: è l’espressione usata per determinare il passo di incremento della variabile di controllo

Es:

for (i=1; i<100; i++) printf(“%d “, i);

(26)

main () {

int Num;

scanf(“%d” , &Num);

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

printf ( “%d \n”, Num*i);

}

Esempio Ciclo for