IL LINGUAGGIO C
IL CALCOLATORE E I
SUOI LINGUAGGI
DATI INIZIALI
PROGRAMMA
DATI FINALI
IL CALCOLATORE ELABORA I DATI
PROBLEMA
ALGORITMO
PROGRAMMA
L’INSIEME DI QUESTE ISTRUZIONI PRENDE
IL NOME DI PROGRAMMA
LINGUAGGIO AD ALTO LIVELLO
COMPILATORE
LINGUAGGIO A BASSO LIVELLO
(BINARIO)
IL LINGUAGGIO DI PROGRAMMAZIONE AD
ALTO LIVELLO
LINGUAGGIO AD ALTO LIVELLO
COMPILATORE
LINGUAGGIO A BASSO LIVELLO
(BINARIO)
COME SI SCRIVE UN PROGRAMMA IN C
IL PROBLEMA
“L’IDEA”
IL PROGRAMMA
REALIZZAZIONE DI UN PROGRAMMA IN C
EDITING DEL PROGRAMMA PROGRAMMA SORGENTE IN C
PROGRAMMA ESEGUIBILE
(EXE)
EDITING DI UN PROGRAMMA
ESECUZIONE
(TESTING E
DEBUGGING)
Esempio: hello.cpp
# include <stdio.h>
# include <stdlib.h>
/* programma */
main ()
{ printf("hello mondo !\n");
system("PAUSE");
return 0;
}
Direttiva al preprocessor:
include il file (del compilatore) stdio.h che
serve per l’utilizzo delle funzioni di input e di
output
Commento: viene ignorato
Funzione main: tutto comincia da qui. Corpo
della funzione main
Istruzioni con il
commento Ritorno a capo
(CR,ASCII 0x0A)
{ Alt 123 Ctrl+Alt+Shift+[ Shift+Alt+[
} Alt 125 Ctrl+Alt+Shift+] Shift+Alt+]
Parentesi graffe
Il linguaggio "C" è strutturato a functions;
una function che sarà sempre presente è la "main".
Una definizione di function è così costituita:
nomefunzione (parametri) {
corpo della funzione
}
Una chiamata a function viene effettuata nel seguente modo:
nomefunzione (parametri);
Il valore restituito da una function, se non specificato diversamente, è di tipo:
int
Esempio: Esercizio printf 1B.cpp
Stampa il valore ricavato.
%d =specifica di conversione.
Commento: viene ignorato .
Definizione intera della variabile
area,latoA,latoB.
Calcola l’area.
Assegnazione del valore 10 e 5.
#include <stdio.h>
#include <stdlib.h>
main() {
int area; // dichiarazione delle variabili int latoA;
int latoB;
latoA = 10; // inizializzazione delle variabili latoB = 5;
area = latoA * latoB; // calcolo dell'area printf("valore dell'area= %d",area);
printf("\n\n");
system("PAUSE");
return 0;
}
TIPI DI DATI
Il linguaggio C è un linguaggio tipizzato, ovvero è necessario specificare il tipo associato a ciascuna variabile e costante.
NOMI DI VARIABILI: SINTASSI
I nomi delle variabili devono essere identificatori validi.
Convenzioni:
1 ) Lettere minuscole per i nomi delle variabili….
Esempio:
int numero1; //definizione (creazione) di una variabile int numero2;
2 ) caratteri tutti maiuscoli per i nomi delle costanti…
Esempio:
#define LIMITE 28
Una variabile è un area della memoria del calcolatore destinata
a contenere il dato che viene distinta per mezzo di un “nome”
int : intero con segno (rappresentato con 2 byte);
short int : intero con segno (rappresentato con 2 byte);
long int : intero con segno (rappresentato con 4 byte);
long long int : intero con segno (rappresentato con 4 byte);
TIPI DI DATO INTERI
Esempi: int num1; int num1,num2,num3;
int num1=10; int num1=5,num2=10;num3=7;
Esempio di una riga di programma:
totale= num1*num2; //assegnazione di un espressione
ALTRI TIPI DI VARIABILI
float: valori numerici reali in singola precisione, compresi tra 10^-39 e 10^38.
char : è un singolo carattere dell’alfabeto ed occupa un singolo byte.
double: valori numerici reali in doppia precisione.
E’ possibile “eseguire operazioni aritmetiche solo tra variabili dello stesso tipo”, altrimenti il compilatore segnala errore.
#include <stdio.h>
main ()
{ int area; //dichiarazione delle variabili int latoA;
int latoB;
latoA=10; //inizializzazione delle variabili latoB=5;
area=latoA*latoB; //calcolo dell’area
…… ……
}
TIPI DI DATO IN VIRGOLA MOBILE
In C sono disponibili tre tipi di dato in virgola mobile:
float: rappresentato su almeno 4 byte;
double: rappresentato su 8 byte, con 11 bit per l’esponente (doppia precisione);
long double: rappresentato su 10-12 byte, con 15 bit per l’esponente (quadrupla precisione);
Il punto decimale (non la virgola) separa la parte intera da quella
frazionaria; la lettera e (oppure E) separa la mantissa dall’esponente;
Esempi: float x,y;
double z;
x=1.0;
y=3.0e8;
z=3.1415926535897932;
INPUT E OUTPUT DEI DATI
Il programma ha la possibilità di “comunicare” con l’utente tramite due modalità: di input e di output.
L‘input (dati in ingresso) consente al programma di ricevere dati e informazioni dall’esterno allo scopo di poterli elaborare.
L’output (dati in uscita) consiste nel comunicare all’utente dei dati e delle informazioni elaborate.
L’input della funzione scanf();
scanf(“ %X %Y “, &varX,& var Y);
L’output della funzione printf():
printf (“ xxxxxx ”);
printf (“ xxxxxx %X %Y %Z ”, varX, varY, varZ );
Esempio 1
#include <stdio.h>
#include<stdlib.h>
main ()
{ int num1,num2,tot; //dichiarazione delle variabili scanf (“ %d %d”, &num1,&num2 ); //input dei dati
tot=num1*num2; //calcolo
printf(“%d \n ”,tot); //output del da system(“pause”);
return 0;
}
Esempio 2
#include <stdio.h>
#include<stdlib.h>
main ()
{ int num1,num2; //dichiarazione delle variabili printf(“programma che calcola il prodotto di due interi”);
printf(“\n Inserisci il moltiplicando : “);
scanf(“%d” , &num1);
printf (“Inserisci il moltiplicatore : “);
scanf(“%d”,&num2 );
printf(“Il prodotto calcolato e\’ :%d,num1*num2);
system(“pause”);
return 0;
}
% d dati numerici interi
% f dati numerici in virgola mobile
% c dati formati da un solo carattere
% s dati di stringa
Specificatori di formato
Elementi di tabulazione
All’interno delle stringhe di output è possibile aggiungere elementi di tabulazione, che prendono il nome di sequenze di escape.
\n : new line
\t : tabulazione orizzontale
\\: backslash
\’: apice singolo
\”: doppi apici
Esempio:
printf(“ \n Leonardo Pisano, detto il \” Fibonacci “\ “);
Leonardo Pisano, detto il “ Fibonacci ”
\ n a capo new line
\ t tabulazione tab
\ r ritorno a capo della stessa riga carriage return
\ ” doppi apici double quote
\\ barra contraria backslash
\ b una battuta indietro backspace
\ ’ apice singolo single quote
\ ? punto di domanda question mark
\ a segnalazione acustica bell
\ 0 fine end of string
\ f salto pagina form fedd
SEQUENZE DI ESCAPE
Specificatore di formato
%d interi decimale
%i interi decimale
%c carattere singolo
%s stringa di caratteri
%o numero ottale
%x numero esadecimale
%u intero senza segno
%f numero reale (float)
%lf numero reale (double)
%e formato scientifico
%% visualizza il carattere %
Formati di stampa
printf (“%d \n”, a); 5
printf (“%15d \n”, a); 5
printf (“%015d \n”, a); 000000000000005
printf (“%f \n”, b); 3.456700
printf (“%15.2f \n”, b); 3.46
printf (“%10d %15.2f \n”, a, b); 5 3.46 printf (“%-10d %- \n”, a, b); 5 3.46
printf (“%s \n”, nazione); Italia
printf (“%20s \n”, nazione); Italia
printf (“%-20s \n”, nazione); Italia
printf (“%-20s %15.2f \n”, nazione, b); Italia 3.46
ISTRUZIONE IN SEQUENZA E COMMENTI
La prima caratteristica di un programma C (e dei linguaggi chiamati
“imperativi”) è quella di eseguire una istruzione di seguito all’altra, nello stesso identico ordine con cui il programmatore le ha scritte.
Questo schema operativo, prende il nome di
esecuzione sequenziale, descritto graficamente dallo schema a blocchi della figura.
La freccia indica il flusso di esecuzione, cioè la sequenza con cui le istruzioni vengono eseguite.
Uno specifico linguaggio di programmazione implementa un modo di pensare: il processo di
computazione prende anche il nome di paradigma di computazione.
Il C rientra tra i linguaggi con paradigma imperativo.
continua >
istruzione
istruzione
istruzione
ISTRUZIONE IN SEQUENZA E COMMENTI
In C l’inizio e la fine di una sequenza di istruzioni (blocco o corpo) vengono indicati mediamente parentesi graffe { }:
corpo = { dichiarazione_variabili lista istruzioni }
Oltre alle dichiarazioni delle variabili e alla lista delle istruzioni, nel
programma è possibile inserire delle righe con la spiegazione delle istruzioni stesse, in modo da renderlo facilmente comprensibile.
Tali righe prendono il nome di commenti .
In C i commenti possono essere scritti nelle due seguenti modalità:
//questa è una riga di commento singola /*questa è una riga di commento
che può andare su più righe */
DIVISIONE TRA NUMERI INTERI E TRA NUMERI REALI
Nel linguaggio C, se viene eseguita una divisione tra due numeri interi, come risultato si ottiene solo la parte intera del quoziente, mentre si ha il
troncamento della eventuale parte decimale.
In tabella si vede il risultato ottenuto utilizzando l’operatore di divisione / tra due numeri reali (float) con quello ottenuto nel caso in cui i numeri di
partenza siano di tipo (int).
DIVISIONE TRA DUE NUMERI REALI
float num1,num2 DIVISIONE TRA DUE NUMERI INTERI
int num1,num2
5/2=2,5 5/2=2
9/2=4,5 9/2=4
10/3=3,333 10/3=3
15/4=3,75 15/4=3
20/6=3,333 20/6=3
#include <stdio.h>
#include<stdlib.h>
main()
{ int numero1, numero2, numero3;
float numero4;
// Leggi i numeri
printf("\nIntroduci il dividendo :");
scanf ("%d", &numero1);
printf("Introduci il divisore :");
scanf ("%d", &numero2);
// Esegui i calcoli
numero3=numero1/numero2; // risultato nella variabile intera numero4=numero1/numero2; // risultato nella variabile reale // Comunica i risultati
printf ("\nRisultato nella variabile intera : %d", numero3);
printf ("\nRisultato nella variabile reale :%6.2f", numero4);
printf("\n\n");
system("PAUSE“);
}
ESEMPIO
Il risultato contenuto nelle due variabili è identico, è stata troncata la parte decimale.
Si può convertire una variabile da un tipo in un altro: ad esempio, è possibile trasformare una variabile int in una variabile float, questo tipo di operazione prende il nome di casting.
La promozione automatica si verifica quando si passa da una variabile “inferiore”, più piccola come occupazione di spazio di memoria, ad una più grande, e non comporta nessuna perdita di dati.
//Promozione da int a float int numero1;
float numero2;
num1=3;
num2=num1; //premozione senza perdita di dati printf(“%d %f “, num1,num2);
CASTING
La coercizione si verifica si verifica quando si passa da una variabile “superiore”, cioè più grande come occupazione di spazio di memoria, ad una più piccola, e generalmente
comporta una perdita di dati.
//Coercizione da float ad int float num1;
int num2;
num1=3.21;
num2=num1; //coercizione con perdita di dati printf(“%f %d”, num1,num2);
OPERATORI ARITMETICI IN C
a=b*c+d; //espressioni matematiche a=(b+c*(d-e);
a=a+b; a+=b; // somma ad a la variabile b a++ ; a=a+1; //incrementa di 1
b--; b=b-1 //decrementa di 1
continua >
+ operatore somma - operatore sottrazione
* operatore prodotto / operatore quoziente
% operatore modulo
= operatore assegnazione
OPERATORI ARITMETICI IN C
Il linguaggio C mette a disposizione del programmatore, oltre ai quattro operatori
matematici fondamentali (+ , - , * , / ), l’operatore %, chiamato operatore modulo: deve essere usato solo su variabili di tipo int e restituisce come valore il resto della divisione.
RESTO DELLA DIVISIONE TRA INTERI
int num1,num2,num3 DIVISIONE TRA INTERI VERIFICA DEI RISULTATI
5 % 2= 1 5 / 2 = 2 2*2 = 4+1 = 5
9 % 2 = 1 9 / 2 = 4 2*4 = 8+1 = 9
12 % 5 = 2 12 / 5 = 2 5*2 = 10+2 = 12
15 % 4 = 3 15 / 4 = 3 4*3 = 12+3 = 15
20 % 6 = 2 20 / 6 = 3 6*3 = 18+2 = 20
23 % 9 = 5 23 / 9 = 3 9*2 = 18+5 = 23
L’operatore % (modulo) non può essere usato su variabili di tipo float e double, ma solo su numeri interi.
CALCOLO DELLA SOMMA DI FRAZIONI
Una frazione viene di solito rappresentata con: a / b con b diverso da 0 dove:
a è il numeratore b è il denominatore
Il denominatore b di una frazione deve essere diverso da zero, altrimenti non sono soddisfatte le condizioni di esistenza della frazione
TABELLA DI EQUIVALENZA TRA I VARI OPERATORI DI ASSEGNAMENTO
++ incremento unitario x++; x=x+1;
-- decremento unitario x--; x=x-1;
+= incremento x+=y; x=x+y;
-= decremento x-=y; x=x-y;
*= moltiplicazione x*=y; x=x*y
/= divisione x/=y; x=x/y;
%= resto della divisione intera x%=y; x=x%y;
LA SELEZIONE SEMPLICE
condizione
istruzione
L’istruzione di selezione semplice permette di far eseguire al calcolatore alcune istruzioni solamente quando il valore di una istruzione di test (o condizione) ha esito positivo (o VERO); nell’altro caso, cioè quando il risultato ha valore FALSO, non viene eseguita nessuna istruzione.
VERO FALSO
In base al valore della condizione si ha:
Condizione VERA si esegue il ramo sinistro e quindi l’istruzione;
Condizione FALSA si esegue il rampo destro, senza fare nulla.
continua
OPERATORI DI RELAZIONE E LOGICI
operatori di confronto == per uguale
> per maggiore
< per minore
<= per minore uguale
>= per maggiore uguale
!= per diverso
connettivi logici && operazione di congiunzione AND
| | operazione di disgiunzione OR ! operazione di negazione NOT
LA SELEZIONE SEMPLICE
La condizione è una espressione del linguaggio rappresentata da due elementi messi a confronto da un operatore relazionale. Nella tabella alla pagina
precedente sono riportati i principali operatori relazionali del linguaggio C.
if (condizione) { istruzione;
}
if (condizione) { istruzione; }
Esempio: calcolo del valore assoluto di un numero
Scriviamo un programma che stampa a video il numero letto senza segno: se il numero è negativo lo moltiplica per -1, mentre se è positivo il numero rimane invariato.
Il diagramma di flusso è riportato a lato.
inizio
leggi
Numero<0
Numero=- 1*nuero
stampa
fine
falso vero
#include <stdio.h>
#include<stdlib.h>
main ()
{ int numero; //variabili locali alla funzione main printf(“Introduci il numero con segno : “);
scanf(“%d”,&numero); //leggi il numero if(numero<0) //esegui il confronto numero=-1*numero; //cambiagli il segno
printf(“valore assoluto del numero letto : “); //risultato printf(“%d”,numero);
system(“pause”);
return 0;
}
LA SELEZIONE DOPPIA
condizione
istruzione
L’istruzione di selezione doppia permette di far eseguire al calcolatore
alternativamente alcune istruzioni in base al valore della istruzione di test (o condizione): se l’esito è positivo (VERO) si eseguono le istruzioni presenti nel ramo di sinistra, se invece è negativo, cioè quando il risultato ha valore FALSO, si eseguono le istruzioni presenti nel ramo di destra.
VERO FALSO
In base al valore della condizione si ha:
Condizione VERA si esegue il ramo sinistro e quindi l’istruzione;
Condizione FALSA si esegue il rampo destro e quindi l’istruzione.
istruzione
LA SELEZIONE DOPPIA
La condizione è una espressione del linguaggio rappresentata da due elementi messi a confronto da un operatore relazionale.
if (condizione) { Istruzione;
} else
{ Istruzione;
}
if (condizione) { istruzione; } else { istruzione; }
esempio: determinare se il numero è positivo o negativo
Leggiamo un numero da tastiera e indichiamo se il numero è positivo o negativo.
#include <stdio.h>
#include<stdlib.h>
main ()
{ int numero; //variabili locali alla funzione main printf(“Introduci il numero : “);
scanf(“%d”,&numero); //leggi il numero printf(“numero inserito: %d”,numero)
if(numero<0) //confrontalo con 0 printf(“\n si tratta si un numero positivo”);
else
printf(“\n si tratta di un numero negativo”);
system(“pause”);
return 0;
}
LA SELEZIONE CON GLI OPERATORI LOGICI &&, ||, e !
La condizione logica è una istruzione che ha come risultato due possibili
alternative, VERO o FALSO. Nei linguaggi di programmazione è possibile definire un tipo di variabile dedicata alla memorizzazione di questo tipo di dati, cioè solo dei valori VERO e FALSO (true e false): si tratta delle variabili di tipo bool (o
boolean).
#include <stdio.h>
#include<stdlib.h>
main ()
{ bool piove; //variabili locali alla funzione main piove=true; //istruzione della funzione main if(piove) //piove è vero
printf(“apri l’ombrello ”);
system(“pause”);
return 0;
}
esempio: due programmi che utilizzano gli operatori logici
I due programmi producono gli stessi risultati.
#include <stdio.h>
#include<stdlib.h>
main ()
{ bool piove; //variabili locali alla funzione main piove=true; //istruzione della funzione main if(piove!=false) //piove è vero printf(“apri l’ombrello ”);
system(“pause”);
return 0;
}
esempio: prodotto logico “&&”
Tabella della verità che riassume tutte le combinazioni dei valori di ingresso e il corrispondente valore del risultato dell’operazione logica.
#include <stdio.h>
#include<stdlib.h>
main ()
{ int anni; //variabili locali alla funzione main printf(“quanti anni hai?”);
Scanf(“%d”,&anni);
If((anni>10) &&(anni<80)) printf(“devi pagare il biglietto ”);
else
printf(“hai l’ingresso gratuito”);
system(“pause”);
return 0;
}
B A A && B
FALSO FALSO FALSO
FALSO VERO FALSO
VERO FALSO FALSO
VERO VERO VERO
esempio: somma logica “||”
Tabella della verità che riassume tutte le combinazioni dei valori di ingresso e il corrispondente valore del risultato dell’operazione logica.
#include <stdio.h>
#include<stdlib.h>
main ()
{ int anni; //variabili locali alla funzione main printf(“quanti anni hai?”);
Scanf(“%d”,&anni);
If((anni<10) || (anni>80)) printf(“hai l’ingresso gratuito”);
else
printf(“devi pagare il biglietto”);
system(“pause”);
return 0;
}
B A A && B
FALSO FALSO FALSO
FALSO VERO VERO
VERO FALSO VERO
VERO VERO VERO
LA SELEZIONE CON BLOCCHI DI ISTRUZIONI
condizione istruzione
Blocchi annidati nella istruzione di selezione. Nell’istruzione di selezione è possibile far eseguire, all’interno di ogni ramo, anche più di una istruzione, come nel diagramma che segue.
VERO FALSO
In base al valore della condizione si ha:
Condizione VERA si esegue il ramo sinistro e quindi l’istruzione;
Condizione FALSA si esegue il rampo destro e quindi l’istruzione.
istruzione istruzione
istruzione istruzione istruzione
LA SELEZIONE DOPPIA
La condizione è una espressione del linguaggio rappresentata da due elementi messi a confronto da un operatore relazionale.
if (condizione) { istruzione1;
istruzione2;
istruzione3;
istruzione “n”;
} else
{ istruzione1;
istruzione2;
istruzione3;
istruzione “n”;
}
esempio: ordinamento di due numeri
Leggiamo due numeri interi e visualizziamoli sullo schermo dal più piccolo al più grande.
#include <stdio.h>
#include <stdlib.h>
main()
{ //variabili locali alla funzione main int numero1,numero2;
//istruzioni della funzione main
printf("inserisci i numeri da ordinare\n");
scanf("%d",&numero1); //inserimento dei numeri da ordinare scanf("%d",&numero2);
if(numero1<numero2) //confronto sui numeri { //se condizione vera
printf("i numeri sono gia' ordinati. \n"); //visualizzazione numeri in ordine printf("il piu' piccolo e' %d",numero1); //di inserimento
printf("\nil piu' grande e' %d",numero2);
} else //se condizione falsa
{ //visualizzazione numeri in ordine invertito printf("i numeri sono da ordinare. \n");
printf("il piu' piccolo e' %d",numero2);
printf("\nil piu' grande e' %d",numero1);
} printf("\n\n");
system("PAUSE");
}
esempio: ordinamento di due numeri con scambio
Leggiamo due numeri interi e visualizziamoli sullo schermo dal più piccolo al più grande.
#include <stdio.h>
#include <stdlib.h>
main()
{ // variabili locali alla funzione main int numero1,numero2,tempo;
// istruzioni della funzione main
printf("inserisci i numeri da ordinare\n");
scanf("%d",&numero1); //inserimento dei numeri da ordinare scanf("%d",&numero2);
if(numero1<numero2) //confronto sui numeri printf("i numeri sono gia' ordinati. \n");
else
{ printf("i numeri sono da ordinare. \n");
tempo=numero1; //i numeri vengono scambiati
numero1=numero2; //usando una variabile temporanea numero2=tempo;
} printf("il piu' piccolo e' %d",numero1);
printf("\nil piu' grande e' %d",numero2);
printf("\n\n");
system("PAUSE");
}
