Fondamenti di informatica - Riassunto completo

Istruzioni dichiarative

I dati che finora abbiamo visto sono di natura numerica intera (CP2) o frazionaria (float), oppure sono caratteri. Per dichiarare una variabile intera si utilizza l'istruzione int a; dove int sta per intero e permette un'allocazione di 2 byte nell'area di memoria.

Questo comando alloca una cella di memoria che andrà ad essere occupata da una variabile a di tipo intero (CP2). Per accedere all'indirizzo di a, se fossimo interessati a saperlo, dovremo utilizzare il comando &a;.

Si possono inserire più variabili da allocare con una sola istruzione ed esse possono assumere un nome qualsiasi: int a, b, c, var;

Se si vogliono allocare variabili in floating point: float d, e, f; Ad ogni variabile in floating point vengono associati 4 byte.

I caratteri si appoggiano alla codifica ASCII, quindi ci saranno 256 caratteri diversi di dimensione 1 byte ciascuno. Per allocare questi caratteri si utilizza il comando: char g;

Per capire che tipo di

codifica è contenuta in una cella basta quindi considerare su quanti byte si estende la sua codifica. A volte è necessario utilizzare un numero maggiore di bit per la codifica dei valori, al fine di ottenere la correttezza della rappresentazione. Usiamo il costrutto long int a; per assegnare alla codifica di un numero intero il doppio dei bit utilizzati normalmente (quindi 32 bit). La stessa operazione può essere svolta per le codifiche in floating point: long float b; ad esse verranno assegnati 64 bit. Quando il comando long viene utilizzato su macchine potenti può variare il coefficiente moltiplicativo. Esiste un costrutto che coincide con il che sta per “double precision”: long float: double b;.

ISTRUZIONI ESECUTIVE

Per poter utilizzare le istruzioni esecutive, i dati devono prima essere allocati in apposite celle di memoria. Vediamo un esempio:

load A, #3
int a, b;
store A, ind b
b=3;

In Assembler:

load A, #7
a=b+7;

diventerebbe:

load B, ind b
addstore A, ind

Operatori aritmetici in CP2:

algebra C+ +- -⋅ */ /resto %

Es. int a, b, c=0; (è possibile assegnare valori direttamente nella fase di allocazione)

a=c+3; (a=3)

a=(a*c+c-7)/2; (a=-3)

b=(a+9)%3; (b=0)

Operatori in floating point:

algebra C+ +- -⋅ */ /

Es. float e,t=3.2;

e=7;

e=e*f+f*f*f;

Cosa succederebbe se dovessimo comporre tipi di dati diversi? Per esempio:

int a,b;

float c,d;

a=2;

b=-1;

c=1.0;

d=3.2;

a=a+b; (a=1 in CP2)

c=c+a; (c=1.0 in floating point)

In questi casi il compiler passa a considerare tutte le variabili in virgola mobile, poiché essa è un superinsieme del CP2. Il CP2 entra in un dispositivo detto CAST, nel quale viene effettuata la trasformazione (per esempio, 1 in CP2 verrebbe trasformato in 1.0 in floating point), dopodiché vengono immessi i due operandi nella ALUF, che restituisce il risultato.

a=c*b; (-2.0)

Ora è necessario tornare alla rappresentazione intera: il compilatore elimina la parte frazionaria e dà un segnale di warning,

ovvero di possibile incompatibilità tra dati e quindi di possibili errori di approssimazione.

Caratteri ‘c’, ‘1’.

Il valore di un carattere è tra apici: il carattere costante c verrebbe indicato con 'c' oppure la cifra 1 con '1'.

int a;

a=2;

'0';

char b;

b= verifica in questo caso un’incompatibilità

b=b+2; (si tra tipi. Questo tipo di operazione è, comunque, ammissibile: infatti la somma del numero 2 (25) avviene sulla codifica del carattere considerato e ‘2’ ‘;’) il risultato restituito è il carattere corrispondente alla codifica 25+2, per esempio 'A' oppure 'B'.

Espressioni logiche “vero” o “falso” quindi non è possibile allocare memoria specificamente a

In C non esiste la variabile logica

questo proposito, ma esiste una convenzione: se una variabile numerica contiene il valore 0 allora questa variabile viene associata al valore logico di Falso, altrimenti a quello di Vero.

Operatore

int numero;

scanf("%d", &numero);

printf("Il numero inserito è: %d", numero);

Queste istruzioni, per la loro complessità, non appartengono al linguaggio standard che il compilatore è in grado di tradurre immediatamente. Il linker andrà quindi a leggere le librerie per poterle decodificare.

La prima istruzione è composta da due parti: formato del dato e indirizzo della cella nella quale è contenuto. Il significato è: scansiona la tastiera (RDP) e acquisisci un dato da salvare nella cella in un determinato formato. Quando avrò digitato 1,2,3, invio dalla tastiera, questi CARATTERI saranno contenuti nel buffer e andrà convertito in un altro formato e poi salvato in una cella. Per esempio: scanf("%d", &a); (converte il dato presente nel RDP in CP2 e lo salva nella cella a)

Vi sono i seguenti tipi di formato:

• %d CP2
• %f floating point
• %c char
• %lf long float
• %s stringa (sequenza di caratteri)

La seconda istruzione è l'estensione dell'istruzione write ind e la sua sintassi è la

seguente:printf("testo"); vediamo alcuni esempi:printf("saluti viene visualizzato "saluti a Voi" nel primo spazio disponibile.a Voi"); sullo schermoprintf("\n saluti a Voi"); Va a capo e scrive il testoprintf("\t saluti a Voi"); Avanza di una tabulazione e scrive il testoprintf("\nEs. \n \t Ciao \t 1");Lo schermo va inteso come una linea continua che va a capo in corrispondenza della fine fisica del monitor, manon si spezza a livello ideale.l'inserimento diIl printf supporta anche un formato di scrittura.Es. float b;b=7.32;printf("\n ", il simbolo "%" si intende che in quel punto va inserito un\n \t b vale: %f b); (scrivendovalore numerico di un formato specifico. La variabile corrispondente al valore va scritta subito dopo,una volta chiusi i doppi apici. Questa operazione svolge la decodifica del valore di b e mostra sulloschermo i caratteri da noi interpretabili).Scriviamo un primo

programma.
#include <stdio.h>
main( ){
    int a,b;
    printf(“\n a”);
    Fornirescanf(“%d”, &a);
    printf(“\n b”);
    Fornirescanf(“%d”, &b);
    a=a+b;
    printf(“La %d”, a);
    somma a+b;
}
/*main*/

Questo programma somma due variabili e visualizza il risultato sullo schermo. Focalizziamo sul modulo principale le nostre osservazioni: /*main*/ indica che la parentesi precedente è quella di chiusura del main, ma non verrà letto dal compilatore, è semplicemente un promemoria del programmatore. Ogni qual volta si voglia scrivere all'interno del programma un promemoria o un'etichetta da non far tradurre al compilatore, bisogna inserirla all'interno dei simboli "/*" e "*/". La prima istruzione si rivolge ad un dispositivo, detto precompilatore, che interroga il file "stdio.h", il quale contiene le istruzioni

ammissibili che il compilatore non comprende nel suo pacchettostandard e che verranno utilizzate durante la scrittura del file sorgente. Queste istruzioni non saranno tradotte in

Il formato “h” di questo file significaAssembler, operazione che toccherà al linker. header (intestazione).

ALTRE ISTRUZIONI DI C

Ricordando che gli spazi e le linee vuote non sono considerati dal compilatore, li utilizzeremo come strumentiper rendere più semplice ed intuitiva la lettura da parte nostra del linguaggio.

Teorema di Böhm-Jacopini

Avendo tre tipi qualsiasi di istruzioni (per esempio: assegnamento, if e while) si può risolvere qualunquealgoritmo (non solo informatico).

Istruzione di selezione semplice: if

Struttura:

if(condizione logica)
{
    Ist vero
}
else
{
    Ist falso
}

Funzione:

falso vero
Cond. logica
Ist. Vero Ist. Falso

Esempio:

int a,b,c;
…
if((a>b)||((c-1)==(b+3)))
{
    a=7+c
    b=3*a+d
}
else
{
    printf(“\n Fornire a”);
    scanf(“%d”, &a);
}

scrittura “else”

In alcuni casi la non è specificata, quindi se la condizione logica non viene soddisfatta il programma prosegue come se il comando if non fosse stato inserito.

Quando i blocchi associati a Ist Vero o Ist Falso sono una sola operazione, non è necessario inserire le parentesi graffe:

if(a>3) b=a+1
else c=a+2

Vediamo un’istruzione ciclica a condizione iniziale: while

Struttura:

while(condizione logica soddisfatta){
    Ist
}

Funzione: fin tanto che la condizione logica non è soddisfatta si vero falso

Cond. logica

Ist. Vero

Esempio: supponiamo di voler ripetere 100 volte la produzione di un lotto

int i;
i=0;
while(i<100){
    produci lotto i-esimo;
    i=i+1;
}

Istruzione di selezione multipla: switch

Struttura:

switch(variabile o espressione){
    case val1: Ist 1;break;
    case val2: Ist 2;break;
    ...
    case valn: Ist n;break;
    default: Ist_default;
}

Funzione: data una variabile che può assumere un valore finito di valori (vocali, consonanti),

se la variabile assume un determinato valore (case val1), allora il programma esegue un determinato set di istruzioni (Ist 1). Il comando break rende esclusivo un valore rispetto a un altro. Se non ci fosse questo comando, il programma eseguirebbe le istruzioni per tutti i valori. Esempio: vogliamo contare le vocali e le consonanti.
voce = 0, ...
int voca = 0, cons = 0;
char c; ... char z;
switch(c) {