#include <stdio.h>
main()
{
printf (“ciao”);
printf (“mondo!”);
}
L’esecuzione inizia da main()
Il corpo del programma è racchiuso da
parentesi graffe
#include <stdio.h>
main()
{
printf (“ciao”);
printf (“mondo!”);
}
Il programma è composto da una serie di
istruzioni printf che vengono eseguite in
sequenza.
#include <stdio.h>
main()
{
printf (“ciao”);
printf (“mondo!”);
}
Ogni istruzione deve terminare con un punto e
virgola
L’istruzione printf permette la stampa su video
di ciò che è racchiuso tra parentesi tonde e
doppi apici.
printf (“tre”);
Visualizza sullo schermo
tre
E’ un’istruzione che dice al calcolatore che nel
programma si useranno le funzioni contenute
nel file stdio.h (standard input-output)
Sono le funzioni che permettono di:
-inviare messaggi sul video
-di leggere valori dalla tastiera
• Il C distingue tra lettere maiuscole e
minuscole
• Le istruzioni sono tutte scritte in minuscolo
• Sono sequenze di caratteri con funzioni speciali.
• Quelle più usate:
\n
va a linea nuova
\t
salta di una tabulazione
\b
ritorna di un carattere indietro
\\
stampa il carattere \
\”
stampa il carattere “
printf (“ciao”);
printf (“mondo”)
visualizza ciaomondo
carattere come gli altri)
printf (“ciao\n”);
Printf(“mondo”);
Visualizza: ciao
mondo
(anche lo spazio è un
La sequenza \n fa andare il cursore a riga nuova
Per lasciare una linea vuota si deve inserire un
ulteriore \n
Se si desidera lasciare una riga prima della
visualizzazione si fa precedere da \n
Printf (“\nAREA RETTANGOLO\n\n”):
/* Calcolo area rettangolo */
•Inizia con /* e finisce con */
•Può estendersi su più linee
•Può apparire in qualsiasi parte del
programma
•E’ possibile farla precedere da // ma in questo
caso deve terminare a fine linea
/* calcolo area rettangolo*/
#include <stdio.h>
main()
{
int base;
int altezza;
int area;
base = 3;
altezza = 7;
area = base*altezza;
printf(“%d”, area);
}
• Il formato della dichiarazione di una variabile
è:
tipo nome-variabile;
• Il tipo di una variabile ne definisce la sua
dimensione e l’insieme di operazioni che si
possono effettuare su di essa
• Il nome di una variabile la identifica
Tipo
Uso
Dimensione in
bit
char
caratteri di testo ASCII
8
short int
numeri interi piccoli da -32768 a + 32767
16
unsigned short int
numeri interi positivi piccoli da 0 a 65535
16
int
numeri interi da -2147483648 a 2147483647
32
unsigned int
numeri positivi da 0 a 4294967295
32
float
Numeri a virgola mobile (precisione singola)
32
double
Numeri a virgola mobile (precisione doppia,
notazione scientifica)
64
E’ possibile fare con le variabili ogni tipo di
operazione matematica elementare:
Addizione (+)
Sottrazione (-)
Moltiplicazione (*)
Divisione (/)
Resto della divisione (%)
Le variabili possono essere dichiarate:
- Sia all’inizio del programma (dopo main() e la
parentesi graffa)
- Sia prima di main()
Le dichiarazioni delle variabili dello stesso tipo
possono essere effettuate in sequenza separate
da una virgola
int base, altezza, area;
I nomi delle variabili devono:
- Iniziare con una lettera o con il carattere _
- Possono contenere lettere, cifre e .
- Le lettere maiuscole sono considerate diverse
dalle corrispondenti minuscole
- Non può essere usata una parola chiave del
linguaggio né può essere uguale a un nome di
funzione
Alla dichiarazione di una variabile corrisponde
anche la sua definizione la quale fa si che le
venga riservato uno spazio in memoria
centrale.
L’istruzione:
base = 3;
Assegna alla variabile base il valore 3, inserisce,
cioè, il valore 3 nello spazio di memoria
riservato alla variabile
Tra i doppi apici il simbolo % stabilisce che il
carattere che lo segue definisce il formato di
stampa della variabile.
d (decimal) indica che si desidera la
visualizzazione di un intero nel sistema
decimale
E’ possibile visualizzare il valore delle variabili
nel seguente modo:
printf(“Base: %d\n”, base);
printf(“Altezza: %d\n”, altezza);
printf(“Area: %d”, area);
Base: 3
Altezza: 7
Area: 21
Quando un valore è ripetuto in modo ricorrente
è opportuno rappresentarlo con un nome
simbolico
La definizione delle costanti, posta all’inizio del
programma, avviene attraverso la macro
seguente:
#define NOME-COSTANTE valore-costante
#define BASE 3
/* Calcolo area rettangolo */
#include <stdio.h>
#define BASE 3
#define ALTEZZA 7
main()
{
int area;
area = BASE * ALTEZZA;
printf (“Base: %d\n”, BASE);
printf(“Altezza: %d\n”, ALTEZZA);
printf(“Area: %d\n”, area);
}
Scanf (“%d”, &base)
L’esecuzione di questa istruzione fa si che il
sistema attenda in input un dato da parte
dell’utente.
Il simbolo & deve precedere il nome della
variabile
&base indica l’indirizzo di memoria in cui si
trova il valore della variabile base
/* Calcolo area rettangolo*/
#include <stdio.h>
int base, altezza, area;
main ()
{
printf (“Valore base: “);
scanf (“%d”, &base);
printf (“Valore altezza: “);
scanf (”%d”, &altezza);
area = base* altezza;
printf (“Base: %d\n”, base);
printf (“Altezza: %d\n”, altezza);
printf (“Area: %d”, area);
}
Printf (“%d %d %d”, base, altezza, area);
10 13 130
Printf (“%d\n %d\n %d\n”, base, altezza, area);
10
13
130
Printf (“%d\n %d\nArea: %d” base, altezza, area);
10
13
Area: 130
printf (“%5d\n%5d\n%5d, base, altezza, area);
1 0
1 3
1 3 0
printf (“%-5d\n%-5d\n%5d, base, altezza, area);
1 0
1 3
1 3 0
Assumono valori alfanumerici che comprendono:
•
•
•
•
Lettere minuscole
Lettere maiuscole
Cifre decimali
Caratteri speciali (.,;:@+-*/%..........)
char x, y, z;
La parola chiave char specifica che gli
identificatori x, y e z si riferiscono a variabili di
tipo carattere
x = ‘A’;
y = ‘%’;
z = ‘&’;
Per assegnare un valore costante ad una
variabile char lo si deve racchiudere tra apici
%c specifica il formato di stampa carattere.
printf(“%c%c%c”, x, y, z);
l’esecuzione dell’istruzione produce:
A%&
mentre l’istruzione:
printf(“%c %c %c”, x, y, z);
produce:
A%&
Si possono stampare valori di tipi diversi
all’interno della stessa printf. Se n e m sono
variabili int si può essere scrivere:
x = ‘a’;
y = ‘b’;
n = 100;
m = 50;
printf(“%c = %d %c = %d”, x, n, y, m);
che restituisce:
a = 100 b = 50
scanf(“%c”, &x);
Con l’istruzione scanf si possono inserire i
caratteri durante l’esecuzione
Esistono altre due funzioni, contenute sempre
nella libreria stdio.h, che permettono di leggere
e scrivere caratteri:
getchar e putchar
x =getchar();
Con questa istruzione il programma si blocca in
attesa di un carattere introdotto da tastiera.
Per visualizzare
funzione:
x =putchar();
il
carattere
abbiamo la
#include <stdio.h>
#include <stdio.h>
main()
main()
{
char x, y, z;
printf(“digita tre caratteri: “);
scanf(“%c%c%c”, &x, &y, &z);
}
{
char x, y, z;
printf(“digita tre caratteri: “);
x = getchar();
y = getchar();
z = getchar();
printf(“hai digitato: “);
putchar(x);
putchar(y);
putchar(z);
}
Una variabile di tipo char permette di
memorizzare un singolo carattere.
Per memorizzare invece una sequenza di
caratteri occorre utilizzare gli array o le
stringhe.
L’array è un insieme di variabili tutte dello stesso
tipo, cui si fa riferimento mediante un stesso
nome. L’accesso ad un determinato elemento si
realizza mediante un indice.
int a(10);
char b(20);
Indicano rispettivamente una struttura formata da
10 elementi interi e una struttura formata da 20
elementi di tipo char
a[2] = 71
71
0
1
2
3
4
Assegna al secondo elemento dell’array il
valore 71
b[3] = ‘r’
r
0
1
2
3
4
Assegna al terzo elemento il carattere r
Una stringa consiste in una sequenza di caratteri.
char nome[10]; stringa di nove caratteri più carattere null
char negozio[] = “Zara s.p.a.”
Definisce una stringa di caratteri di nome
negozio e il cui numero di elementi dipende dal
numero di elementi presenti tra apici più uno, il
carattere null (\0) che chiude la stringa
La stringa è un array di char dove un insieme di
caratteri è trattato come una singola unità
Quando si parla di caratteri, infatti, può essere
interessante manipolare l’intero insieme di
caratteri appartenenti ad un array, in quanto
costituiscono nel loro insieme un vocabolo o
un’intera frase
char d = ‘r’;
char d[2] = ‘r’;
char d[] = “r”;
La prima assegna a d il carattere r, la seconda
assegna al terzo elemento dell’array il carattere
r , la terza assegna a d la sequenza di caratteri r
e \0.
Per visualizzare il contenuto di una stringa si
utilizza %s:
printf(“%s”, negozio);
visualizza:
Zara s.p.a
Per inserire da tastiera si usa scanf:
scanf(“%s”, negozio);
Copia l’input in negozio senza usare &
Per poter copiare il contenuto di una stringa in
un’altra occorre utilizzare la funzione strcpy
contenuta nella libreria <string.h>
strcpy(nome1,nome2);
Il contenuto della stringa nome2 viene copiato
nella stringa nome1
E’ possibile assegnare ad una variabile un
valore iniziale al momento della sua
dichiarazione
int a = 0, b = 50, c = 100;
Per gli array (se definiti prima di main):
int voti[5] = {6, 7, 8, 10, 5,3};
Per le stringhe occorre porre il valore tra doppi
apici:
char frase[] = “esempio variabili”;
oppure:
Char frase[30] = {‘e’,’s’,’e’,’m’,’p’,’i’,’o’,’ ‘,’v’,’a’,’r’,’i’,’a’,’b’,’i’,’l’,’i’,’\0’};
Una funzione è costituita da un insieme di
istruzioni che realizzano un compito: a partire
da uno o più valori presi in input, essa
restituisce un determinato valore di output
w = abs(j); valore assoluto
L’insieme delle istruzioni che la compongono è
contenuto nella libreria standard math.h
Per poter utilizzare tale funzione occorre
inserire prima di main:
#include <math.h>;
stdio.h
funzioni di input/output
math.h
funzioni matematiche
string.h
funzioni che operano su stringhe
Quando si desidera eseguire un’istruzione, al
verificarsi di una condizione, si utilizza
l’istruzione if.
if (espressione) istruzione;
Dove se espressione è vera viene eseguita
istruzione;
if i < 100
printf(“minore di 100”);
La valutazione dell’espressione i < 100 può
restituire solo i valori vero o falso che in C
corrispondono ai valori 1 e 0.
if(i>100) printf(“maggiore di 100”);
L’esempio precedente è identico alla successiva
espressione dove a assume valore 1 o 0 a
seconda che l’espressione sia vera o falsa
a = i>100;
if(a!=0)
printf(“maggiore di100”);
a=i>100;
if(a)
printf(“maggiore di 100”);
iiii
La sintassi completa dell’istruzione if è:
If(espressione) istruzione1;
{else istruzione2};
Dove istruzione1 viene eseguita se espressione
risulta vera, altrimenti, se è falsa, viene
eseguita istruzione2.
#include <stdio.h>
main()
{
int i;
printf(“dammi un intero: “);
scanf(“%d”, &i);
if(i>100)
printf(“maggiore di 100\n”);
else
printf(“minore o uguale a 100”);
if (i<100)
printf(“minore di 100”);
printf(“prossima istruzione”);
La
seconda
printf
viene
eseguita
indipendentemente dalla valutazione di i<100.
Lo stesso avviene per la clausola else nelle
istruzioni seguenti:
if (i<100)
printf(“minore di 100”);
else
printf(“maggiore o uguale a 100);
printf(“istruzione successiva”);
#include <stdio.h>
int i, mag_100, min_100;
main()
{
mag_100 = 0;
min_100 = 0;
printf(“digitare un intero: “);
scanf(“%d”,&i);
if (i>100) {
printf(“maggiore di 100\n”);
mag_100 = 1;
}
else {
printf(“minore o uguale a 100”);
min_100 = 1;
}
}
Un if può comparire all’interno di un altro if
if (i<100)
if (i>0)
printf(“minore di 100 e maggiore di 0”);
else
printf(“minore di 100 ma non maggiore di 0);
else
printf(“maggiore o uguale a 100”);
if (i<100) {
if (i>0)
printf(“minore di 100 e maggiore di 0”);
}
else
printf(“maggiore o uguale a 100”);
if (i<100)
if (i>0)
printf(“minore di 100 e maggiore di 0”);
else
printf(“minore di 100 ma non maggiore di 0);
else
if (i==100)
printf(“uguale a 100”);
else
printf(“maggiore di 100”);
Quando si desidera ripetere un’operazione un
determinato numero di volte si può riscrivere
sequenzialmente l’istruzione corrispondente.
somma = 0;
somma = somma + 4;
somma = somma + 4;
somma = somma + 4;
Lo stesso risultato si può ottenere con un ciclo
in cui l’istruzione si ripete:
somma = 0;
for(i=1; i<=3; i = i+1)
somma = somma + 4;
somma = 0;
for(i=1; i<=3; i = i+1)
somma = somma + 4;
Alla variabile somma viene assegnato il valore 0.
L’istruzione for assegna il valore 1 alla variabile i
(inizializzazione). Successivamente:
1. i<=3 allora vai al passo 2 altrimenti termina
2. somma = somma + 4
3. i = i+ 1, vai al passo 1
Il formato è il seguente:
for(esp1; esp2; esp3)
istruzione
Il ciclo non viene eseguito neppure una volta se
esp2 risulta falsa.
Il ciclo viene eseguito fino a che esp2 non risulti
essere falsa.
Se istruzione è costituita da un gruppo di
istruzioni, questo deve essere racchiuso tra
parentesi graffe:
somma = 0;
for(i=1; i<=3; i=i+1) {
scanf(%d”, &numero);
somma = somma + numero;
}
#include <stdio.h>
main()
{
int i, somma, numero;
printf(“Somma 5 numeri \n“);
somma = 0;
for(i=0; i<=5; i=i+1) {
printf(“inserire intero “);
scanf(“%d”, &numero);
somma = somma + numero;
}
printf(“Somma: %d\n”, somma);
}
Anche l’istruzione while permette la ripetizione
di un’istruzione o di un gruppo di istruzioni:
while (esp)
istruzione
Viene eseguita l’istruzione finchè esp risulta
vera. Il ciclo termina non appena il valore di esp
risulta falso.
i = 1;
while (i<=4) {
printf(“inserire intero: “);
scanf(“%d”, &numero);
somma = somma + numero;
i = i + 1;
}
for (i=1;i<=4; i=i+1){
printf(“inserire intero: “);
scanf(“%d”, &numero);
somma = somma + numero;
}
•Con while non si ha la garanzia che l’istruzione
o gruppo di istruzioni vengano eseguiti almeno
una volta perché, se esp risulta subito falsa, si
passa direttamente all’istruzione successiva al
while.
•Con while non è sempre noto a priori il
numero il numero di volte che occorre ripetere
l’istruzione o gruppo di istruzioni
L’istruzione do……while valuta la condizione
alla fine del ciclo stesso: per questo il corpo del
ciclo viene eseguito almeno una volta.
do
istruzione/i
while (esp)
#include <stdio.h>
main()
{
int n;
do
{
printf(“inserire un intero compreso tra 10 e 20: “);
scanf(“%d”, &n”);
} while (n<10 || n>20);
printf (“il numero inserito è: %d”, n);
}
L’incremento unitario di una variabile si ottiene
con l’istruzione :
somma = somma + 1
In C è possibile ottenere lo stesso risultato con
l’operatore ++
++somma
Somma = somma – 1;
Equivale a
--somma;
c = ++a + b;
La variabile a viene incrementata di un’unità e
sommata alla variabile b; il risultato viene poi
assegnato a c
Gli operatori di incremento e decremento
possono sia precedere sia seguire la variabile
++somma equivale a somma++
Se gli operatori vengono usati all’interno di
espressioni valgono le seguenti regole:
•se l’operatore ++(--) precede la variabile, prima il
valore della variabile incrementato (decrementato)
e poi viene valutata l’intera espressione
•se l’operatore ++(--) segue la variabile, prima viene
valutata l’intera espressione e poi il valore della
variabile viene incrementato (decrementato)
int a, b, c;
a = 5;
b = 7;
c = a++ + b;
printf(“%d\n”, a);
printf(“%d\n”, b);
printf(“%d\n”, c);
a += 5
equivale a
a=a+5
a *= 2
equivale a
a=a*2
a -= b
equivale a
a=a–b
a*= 4+b
equivale a
a = a * (4 + b)
! - ++ -* / %
• + > >= < <=
== !=
&&
||
?:
=
+=
-=
*=
/=
%=