Fondamenti di Informatica: Esercizi e Quiz, Appunti di Fondamenti di informatica

Scarica Fondamenti di Informatica: Esercizi e Quiz e più Appunti in PDF di Fondamenti di informatica solo su Docsity!

Fondamenti di

Esmeralda Palazzo

I

• 1. ALGORITMI ED ESECUTORI Indice
  • 1.1 INFORMATICA
  • 1.2 ALGORITMO
  • 1.3 ESECUTORE................................................................................................................................................
• 2. CODIFICA DEI DATI
  • 2.1 MEMORIZZAZIONE DEI DATI E DELLE ISTRUZIONI
  • 2.2 PROBLEMA DELLA CODIFICA
  • 2.3 CODIFICA DELLE ISTRUZIONI
  • 2.4 RAPPRESENTAZIONE DEI CARATTERI
  • 2.5 RAPPRESENTAZIONE DEL SEGNALE CONTINUO
  • 2.6 RAPPRESENTAZIONE DELLE IMMAGINI
• 3. RAPPRESENTAZIONE DEI NUMERI
  • 3.1 RAPPRESENTAZIONE DEI NUMERI INTERI (BASE 10 - > BASE 2)
  • 3.2 RAPPRESENTAZIONE DEI NUMERI REALI
• 4. ELEMENTI DI ARCHITETTURA DEL CALCOLATORE
  • 4.1 ORGANIZZAZIONE DELLA MEMORIA CENTRALE
  • 4.2 TIPOLOGIE DI MEMORIA (A LIVELLO ELETTRONICO)
  • 4.3 SISTEMI DI MEMORIA IN UN CALCOLATORE
  • 4.4 LA CPU
• 5. ELEMENTI DI SISTEMI OPERATIVI
  • 5.1 SISTEMA OPERATIVO E SERVIZI.....................................................................................................................
  • 5.2 STRUTTURA DEL SISTEMA OPERATIVO
• 6. LINGUAGGI DI PROGRAMMAZIONE........................................................................................................
  • 6.1 IL GAP SEMANTICO E I LINGUAGGI
  • 6.2 PROGRAMMI TRADUTTORI
  • 6.3 AMBIENTE DI SVILUPPO
• 7.LE BASI DEL C++
  • 7.1 RAPPRESENTAZIONE DELLE INFORMAZIONI
  • 7.2 RAPPRESENTAZIONE DELLE ISTRUZIONI
• 8.STRUTTURE DI CONTROLLO
  • 8.1 SEQUENZA
  • 8.2 SELEZIONE
  • 8.3 COSTRUTTI DI CICLO
  • 8.4 ISTRUZIONI DI SALTO
• 9. SOTTOPROGRAMMI
  • 9.1 DEFINIZIONE E ATTIVAZIONE
  • 9.2 FUNZIONI
  • 9.3 PROCEDURE
  • 9.4 PROTOTIPI
  • 9.5 SCAMBIO DI PARAMETRI
• 10. MODULARITÀ E VISIBILITÀ DELLE VARIABILI
  • 10.1 COMPILAZIONE SEPARATA I
  • 10.2 VISIBILITÀ
  • 10.3 CLASSI DI MEMORIZZAZIONE
• 11. ARRAY
  • 11.1 ARRAY MONODIMENSIONALI
  • 11.2 ARRAY BIDIMENSIONALI
• 12. ALGORITMI SU ARRAY.............................................................................................................................
  • 12.1 RICERCA DI UN VALORE...........................................................................................................................
  • 12.2 INSERIMENTO DI UN VALORE
• 13 STRUTTURE
  • 13.1 STRUCT..................................................................................................................................................
  • 13.2 DICHIARAZIONE DI TIPI, ENUMERAZIONI E UNIONI
• 14. PUNTATORI
  • 14.1 COS’È UN PUNTATORE.............................................................................................................................
  • 14.2 ARITMETICA DEI PUNTATORI
  • 14.3 TIPOLOGIE DI PUNTATORI
• 15. ALLOCAZIONE DINAMICA
  • 15.1 OPERATORE NEW
  • 15.2 ALLOCAZIONE E DEALLOCAZIONE
  • 15.3 PROBLEMI..............................................................................................................................................
  • 15.4 NEI SOTTOPROGRAMMI
• 16. RECORD DI ATTIVAZIONE
  • 16.1 SPAZIO DI INDIRIZZAMENTO
• 17. LE STRINGHE.............................................................................................................................................
  • 17.1 GESTIONE DELLE C STRING
  • 17.2 INPUT/OUTPUT
  • 17.3 LA LIBRERIA
• 18. RICORSIONE
  • 18.1 COSA SUCCEDE SULLO STACK?
  • 18.2 ALGORITMI RICORSIVI
• 19. ABSTRACT DATA TYPE
  • 19.1 INSIEME (SET)
  • 19.2 PILA (STACK)
  • 19.3 CODA (QUEUE)
  • 19.4 LISTA (LIST)
• 20 LISTE COLLEGATE
  • 20.1 IMPLEMENTAZIONE DEL NODO
  • 20.2 NUOVA IMPLEMENTAZIONE DELLA LISTA
• 21 INPUT/OUTPUT DEL C++
  • 21.1 GLI STREAM
  • 21.3 GETLINE
  • 21.4 I/O FORMATTATO
  • 21.5 I/O CON LE STRUCT
• 22. VARI ASPETTI DEL C++ I
  • 22.1 DIRETTIVE AL PREPROCESSORE
  • 22.2 PARAMETRI DI DEFAULT
  • 22.3 OVERLOADING DEGLI OPERATORI
• 23 INTRO ALLA PROGRAMMAZIONE A OGGETTI
  • 23.1 CLASSE E INCAPSULAMENTO
  • 23.2 COSTRUTTORI E DISTRUTTORI
• 24 COSTRUTTORI DI COPIA E OVERLOADING DEGLI OPERATORI
  • 24.2 VARIABILI MEMBRO
  • 24.3 OVERLOADING DEGLI OPERATORI (METODI)
• 25 OVERLOADING OPERATORI, USO DI CONST E CLASSE STRING
  • 25.1 OVERLOADING DI OPERATORI PARTICOLARI
  • 25.2 USO DI CONST......................................................................................................................................
  • 25.3 CLASSE STRING.....................................................................................................................................
• 26 EREDITARIETÀ
  • 26.1 MODIFICATORI DI ACCESSO...................................................................................................................
  • 26.2 EREDITARIETÀ E PUNTATORI
  • 26.3 COSTRUTTORI, DISTRUTTORI, COSTRUTTORI DI COPIA E OPERATOR =
• 27 POLIMORFISMO
  • 27.1 FUNZIONI VIRTUALI
  • 27.2 CLASSI ASTRATTE
  • 27.3 I GRAFI
• 28 PROGRAMMAZIONE GENERICA
  • 28.1 TEMPLATES
  • 28.2 COMPILAZIONE DI TEMPLATE
• 29 STANDARD TEMPLATE LIBRARY (STL)......................................................................................................
  • 29.1 CONTENITORI (CONTAINERS)
  • 29.2 ITERATORI
  • 29.3 ALGORITMI
  • 29.4 CLASSE VECTOR
  • 29.5 CLASSE LIST
  • 29.6 CLASSE MAP
• 30 ARRAY MULTIDIMENSIONALI
  • 30.1 ARRAY BIDIMENSIONALI
  • 30.2 ARRAY MULTIDIMENSIONALI....................................................................................................................

III

1.2 Algoritmo

• da applicare ai dati in ingresso affinché possa produrre quelli in uscita

Bisogna trovare un procedimento risolutivo sistematico per problemi generici che

prevede:

• un insieme finito di operazioni - > arrivare a una soluzione in tempi finiti;
• istruzioni eseguibili - > scriverlo sottoforma di operazioni che la macchina sa

fare;

• istruzioni precise (non ambigue);

L’algoritmo è del tutto generale, ma, in qualsiasi caso, il procedimento avrà termine

e fornirà una risposta precisa in un numero finito di passi.

Dev’essere perfettamente definito: quale operazione si debba compiere e anche

il momento in cui il procedimento si debba ritenere concluso.

La descrizione dell’intero procedimento è presentata in termini finiti, anche se può

essere applicata a numeri naturali di dimensioni illimitate.

Bisogna definire:

• dati di ingresso che fornisce l’utente ( input )
• (algoritmo) - > si definisce in sequenze di istruzioni che si possono espandere

per renderlo più operativo (sottoprogrammi)

• il risultato del computer ( output )

Esempio

Problema:

Si vuole suddividere un rettangolo AxB in quadrati aventi il lato della maggiore

lunghezza possibile e diverso da 1. Tutte le dimensioni sono numeri interi.

Definire i dati:

• Dati di input : dimensioni del rettangolo
• Dati di output : lato del quadrato se è possibile il taglio.

Ridefinire il problema:

1. Calcolare il Massimo Comune Divisore (MCD) dei due numeri interi A e B
2. Se il MCD è diverso da 1, il taglio è possibile e la misura del quadrato è data

dal MCD.

3. Se il MCD è uguale a 1, il taglio non è possibile

Algoritmo risolutore:

1. Leggi il valore di A e di B
2. Calcola il MCD di A e di B e scrivilo in C
3. Se C=1 comunica che il taglio non è possibile; altrimenti comunica che il

taglio è possibile e che la misura del lato del quadrato è C

4. Termina

Un programma può essere suddiviso in sottoprogrammi per facilitarne l'esecuzione,

consentendo al codice di essere più generale e applicabile in diverse situazioni

Calcolo MCD

Algoritmo Euclide

1. Leggi due numeri X e Y, con X > Y
2. Dividi X per Y e ottieni il resto R
3. Se R=0, termina: il MCD è Y
4. Sostituisci X con Y
5. Sostituisci Y con R
6. Torna al punto 2.

Esempio: x=48 y=28 r=

x=28 y=20 r=

x=20 y=8 r=

x=8 y=4 r=

In questo modo abbiamo espanso l’algoritmo e possiamo riutilizzare i sotto-algoritmi

ogni volta che sono necessari.

Come programmatore, è importante considerare tutti i possibili scenari di dati ed

errori, in modo da gestirli.

L’algoritmo dev’essere espresso in un linguaggio comprensibile all’esecutore.

1.3 Esecutore

Una volta definito, l’algoritmo deve essere sottoposto ad un esecutore, che deve

essere in grado di:

• interpretare correttamente la sequenza di comandi;
• eseguire ognuno dei comandi forniti;
• memorizzare le informazioni su opportuni supporti che permettano di

accedere alle informazioni memorizzate e modificarle.

N.B. L’esecutore non è necessariamente consapevole di quello che sta facendo.

Infatti questi linguaggi sono imperativi, poiché contengono comandi che

l’esecutore si limita a eseguire, senza capirli.

L’esecutore umano svolge funzioni di:

• controllo - > legge l’istruzione, la interpreta, accede ai dati in memoria
• esecuzione - > la esegue

Calcolo del resto R

1. Leggi due numeri M e N
2. Se M<N termina: il resto è M
3. Sostituisci M con M-N
4. Ritorna al punto 2.

Esempio: m=48 n=

m=20 n=

resto=

nb: non sempre sono possibili entrambe le operazioni

registro di memoria

• supporto per la memorizzazione di un’informazione;

• insieme di n celle elementari, che può assumere uno tra 2

𝑛

stati possibili;

• i più piccoli sono formati da 8 bit ( un byte );

• operazioni: si leggono 8 bit/tensioni per volta

si scrivono contemporaneamente/si caricano 8 tensioni

2.2 Problema della codifica

• corrispondenza biunivoca

si possono associare:

• sequenze di bit (dati memorizzati nella macchina)
• a delle informazioni nel mondo reale (dato reale)

Si associa il valore di un tipo di dato (una categoria: numeri, testo, immagini, suoni…)

alle sequenze binarie. Se cambio il formato, sto cambiando il modo in cui associo il

bit alle informazioni (modo in cui codifico il formato).

La macchina interpreta i bit in base alle informazioni che gli vengono passate

dall’ utente.

Per rappresentare informazioni metto i bit in sequenza : se uso n bit ho 2

𝑛

informazioni

(stati) che posso rappresentare.

La più piccola unità di informazione che legge la macchina è il byte.

La codifica è:

• limitata dal numero di bit: il numero di bit

limita il valore da rappresentare;

• discreta nel caso di numeri reali: non si può

rappresentare una grandezza continua in

maniera completa poiché le sequenze di bit

sono numerabili

2.3 Codifica delle istruzioni

Oltre ai dati, bisogna memorizzare le istruzioni

- > le singole azioni elementari che l’unità centrale

può eseguire

- > si specifica l’ operazione da compiere e i dati

coinvolti

Il numero delle istruzioni possibili è finito, pertanto si può rappresentare con un

certo numero di bit (codice operativo): ogni operazione viene associata a un

codice operativo (sequenza di bit).

L’istruzione è rappresentabile da una sequenza di bit

divisa in due parti:

1. codice operativo - > le operazioni 2. campo operandi - > i dati (variabili, costanti…)

NB: al processore non interessano i dati in sé, bensì l’indirizzo in cui sono contenuti.

Il processore conosce tutto quello che gli serve per eseguire l’istruzione.

2.4 Rappresentazione dei caratteri

Ogni tasto corrisponde a una sequenza di bit che viene inviata alla macchina

la tastiera è un dispositivo di input che si adatta alla lingua.

Codifica ASCII

• A merican S tandard C ode for I nformation I nterchange

È un sistema di codifica dei caratteri alfanumerici a 7 bit.

Estensione ad 8 bit per raddoppiare il numero di caratteri rappresentabili ( extended

ASCII ). In questo caso sono codificati simboli speciali per i diversi alfabeti quali

lettere greche, lettere accentate, ecc.

Si ha uno standard code che permette di identificare univocamente un carattere:

• Codifica: ogni singolo carattere è codificato da un byte;
• Decodifica: si decompone la sequenza di bit in gruppi di byte e si determina

il carattere corrispondente ad ogni byte.

Il numero di caratteri codificati è 2

8

Codifica Unicode

• è stata introdotta per estendere il numero di bit associato a ogni carattere

(256 erano pochi)

È un sistema di codifica che assegna un una combinazione di bit a ogni carattere

in maniera indipendente dal programma, piattaforma e dalla lingua.

È compatibile col codice ASCII e codifica i simboli di quasi tutti gli alfabeti moderni.

Inizialmente era un codice a 16 bit (corrispondenti a 65536 caratteri diversi).

Oggigiorno si basa su tre tipi di codifiche diverse: a 8 bit (byte), a 16 bit (word) e a

32 bit (double word), per rappresentare la totalità dei caratteri.

Un esempio è l’utf8 (una codifica Unicode a 8 bit).

2. Quantizzazione riduce il numero di grandezze rappresentabili in base alle

sequenze di bit disponibili

• si discretizzano i valori rappresentabili (insieme di cardinalità finita)

Si assegna un valore numerico a ogni campione:

uno tra N valori (livelli di quantizzazione)

Gli intervalli di quantizzazione Q sono scelti in base

alle caratteristiche del segnale.

Quantizzatore uniforme:

𝐹𝑆

𝑁

• dove FS = MaxVal - MinVal (fondo scala) - > dove N sono i livelli di quantizzazione

Il quantizzatore tira fuori una serie di valori associate a sequenze numeriche.

ERRORI:

• La frequenza di campionamento non dev’essere eccessiva altrimenti

occupa troppo spazio in memoria (acquisisce troppi valori);

• Errore di quantizzazione: la differenza tra due valori numerici successivi;

poiché si misura una grandezza e si associa un altro valore alla stessa,

pertanto tanto è piccolo l’intervallo di quantizzazione tanto lo è l’errore.

3. Codificatore trasforma i valori numerici forniti dal quantizzatore in bit.

La scelta del codice dal tipo di informazione che si rappresenta

Esempio: ho un codificatore da 8 bit (può rappresentare 256 numeri) - > il

quantizzatore prende la forma d’onda e divide l’intervallo in 256 valori.

2. 6 Rappresentazione delle immagini

(Rappresentazione discreta di segnale continuo)

• non è presente la dimensione temporale ma sono presenti

due dimensioni spaziali.

Per rappresentare una fotografia bisogna conoscere la posizione esatta di ogni

singolo oggetto e dei colori.

Si rappresentano attraverso una serie di pixel - > si utilizzano per la codifica delle

immagini

Si associa a un pixel una sequenza di bit:

• in alcuni casi si rappresenta la forma
• in altri si rappresentano immagini raster

  • rappresentazione a quadratini (si memorizza

l’informazione relativa al colore nel

quadratino)

Immagini in bianco e nero

• si suddivide l’immagine attraverso una griglia, i cui quadratini sono i pixel

(picture elements), cioè le unità costituenti

l’immagine

• si associa il bianco allo zero e il nero all’uno
• si prende un punto di partenza (in basso a sx)

La qualità della rappresentazione dipende da:

• la risoluzione dell’immagine - > il numero di pixels che la definisce, espresso

attraverso una coppia di numeri.

Aumentando il numero di pixel si definisce meglio la forma.

• i colori

Sfumature di grigio

Per ogni pixel viene misurato il livello medio di intensità luminosa (il livello di grigio)

• 8 bit associati a ogni pixel: si possono rappresentare 2

8

= 256 livelli di grigio

Immagini a colori

Si individua un certo numero di sfumature di colore differenti e si codifica ogni

sfumatura mediante un'opportuna sequenza di bit

• Il numero di bit è detto profondità di colore , misurata in bpp.

La rappresentazione di un’immagine mediante la codifica diretta dei pixel viene

chiamata bitmap.

Il numero di byte memorizzati per un’immagine dipende dalla risoluzione e dal

numero di colori che ogni pixel può assumere.

La rappresentazione di solito è su tre colori - > sintesi additiva : tramite i colori primari

si possono rappresentare tutti gli altri ( RGB ) cambiando le tonalità/gradazioni dei

singoli colori. Ogni sfumatura di colore primario è rappresentabile da 1 byte.

Oggi si usano rappresentazioni a 16 bit che permettono di essere molto precisi, a

discapito dell’occupazione di memoria.

Aritmetica dei registri

I registri di memoria sono supporti di

lunghezza finita , ciò impone delle

restrizioni all’insieme di numeri

rappresentabili e, di conseguenza,

impone dei vincoli all’aritmetica.

• Registro a n bit:

𝑛

valori diversi rappresentabili

Intervallo di rappresentazione [0, 2

𝑛− 1

].

Non ci sono problemi nel caso in cui

l’operazione produce un risultato

rappresentabile nel registro.

Overflow - > la macchina non riesce a

rappresentare il numero su 9 bit,

poiché è la rappresentazione è

limitata. - > ERRORE

Se il risultato non è rappresentabile, si

produce un riporto uscente dal

registro, all’interno rimane una parte

della rappresentazione del risultato

La congruenza è di mod 2

𝑛

: R mod 2

𝑛

Numeri con segno (SIGNED) - > relativi

1.Rappresentazione in segno e modulo

(per avere compatibilità con i +)

• Primo bit - > lo dedico alla rappresentazione del segno, poiché grazie al bit

posso rappresentare due informazioni.

• Restanti bit - > numero in valore assoluto

L’intervallo di rappresentazione è [− 2

𝑛− 1

𝑛− 1

− 1 , ] - > n = 8 bit [-127, +127]

Esempio:

Il modulo è lo stesso dell’altra rappresentazione.

Svantaggio : si rappresenta lo zero con il segno ( doppia rappresentazione dello zero )

Le operazioni diventano alquanto complicate. Somma e sottrazione sono

operazioni nettamente diverse.

2.Rappresentazione in complemento alla base (complemento

a due)

• Si lascia i positivi invariati (si mantiene la compatibilità)
• Si modifica la rappresentazione numeri negativi:

sono rappresentati come complemento a 2 del numero

rappresentato

• Bit più significativo - > rappresenta il segno (0 - > + ; 1 - > - )

R(x)=

𝑛

𝑛

Sommo la potenza massima che posso avere con n bit al

numero e “tolgo” le cifre oltre gli n bit (con il modulo).

(n - > numero di bit disponibili)

Si rende circolare la rappresentazione: arrivati a un certo punto

le sequenze si ripetono.

L’intervallo di rappresentazione è [− 2

𝑛− 1

𝑛− 1

− 1 ] - > [- 128 , 127]

Esempio n = 8

8

= 293 la conversione si fa su questo numero!

• scrivo il modulo di 37
• completo il registro
• aggiungo 2

8

• a questo punto elimino il nono bit (non è overflow!!!)

modulo di 𝟐

𝒏

• si buttano via i bit fuori dal registro

8

Vantaggi:

• Uguaglianza tra operazioni di somma e differenza:

o Le somme sono somme di rappresentazioni R(x+y) = R(x) + R(y)

o Le differenze non esistono, sono somme di negativi R(x-y) = R(x) + R(-y)

• Non c’è la doppia rappresentazione dello zero:

00000000 - > 0; 10000000 - > il più piccolo negativo

Svantaggi:

• Si potrebbe avere un overflow nel caso

in cui si ecceda la rappresentabilità del

registro (anche con i num negativi!)

• non sono disposti in ordine crescente

NB trucchetto - > calcolo rapido per negativi!

00100101 rappresento +

11011010 inverto i bit 1 a 1 (operazione di negazione/complemento)

1 sommo 1

11011011 ottengo - 37

3. 2 Rappresentazione dei numeri reali

Base 2 - > base 10

La rappresentazione dei numeri reali in base 2 è analoga a quella in base 10:

Parte intera.parte frazionaria

La parte frazionaria è formata da cifre che pesano le potenze di 2 a esponente

negativo:

Base 10 - > base 2

Si convertono separatamente le due parti:

• parte intera
• parte decimale - > si moltiplica per 2 e si considera la parte intera, presa

nell’ordine in cui compare

Per rappresentare i numeri reali nel registro è necessario codificare la posizione del

punto frazionario (per esempio per le operazioni):

1. Codifica esplicita - > si prefissa la posizione esatta del punto 2. Codifica implicita - > rappresenta un fattore di scalo tramite cui si può

spostare il punto

Con la codifica esplicita dovremmo rappresentare sia il numero che il suo fattore

di scala - > antieconomico e complicato

Rappresentazione in virgola fissa (FIXED POINT)

Numeri senza segno

Nel registro fisso il punto in fase di costruzione del processore, dividendo il registro

in due parti:

• una per la parte intera (n)
• una per la parte decimale/frazionaria (p)

(non c’è bisogno sapere a memoria gli svantaggi)

C’è un problema legato alla precisione di rappresentazione.

Si vuole rappresentare il valore X , che nel registro equivale a 𝐾 × 2

−𝑝

, dove K è il

valore che otterremmo se interpretassimo come intero il contenuto del registro.

N - > numero di bit del registro

L’intervallo di rappresentabilità per K sarebbe [0, 2

𝑁

− 1 ].

L’intervallo di rappresentabilità per X è [0, ( 𝟐

𝒏

− 𝟏) × 𝟐

−𝒑

].

Esempio

N = 8, p = 4

X [0, ( 2

8

− 1 ) × 2

− 4

] = X [0, 255 x

1

16

] = X [0, 15.9375]

La rappresentabilità del numero dipende da dove posiziono la virgola:

si limitano entrambi le parti - > bisogna trovare un equilibrio tra le due parti

È chiaro che i numeri rappresentati sono sempre 256, ma si rappresentano a

intervalli di 2

−𝑝

• I numeri sono rappresentati con una certa approssimazione : la macchina è

incapace di rappresentare un numero perché è compreso tra due valori

consecutivi rappresentabili ( mancanza di rappresentazione ).

Tutti i valori compresi tra 0.03125 e 0.09375 sono rappresentati da 0.

• Underflow - > rappresentare un intervallo di numeri come zero: il risultato è

troppo piccolo per essere rappresentato nella memoria dell'elaboratore e

viene confuso con lo zero.

Tutti i valori compresi tra 0 e 0.03125 sono rappresentati da 0.

E assoluto =

2

−𝑝

2

per diminuirlo si aumenta p

Il vero problema riguarda

E relativo =

𝐸 𝑎𝑠𝑠𝑜𝑙𝑢𝑡𝑜

𝑚𝑜𝑑𝑢𝑙𝑜 𝑑𝑖 𝑋

Avvicinandosi allo zero E relativo - > ∞

Allontanandosi E relativo - > 0

Bisogna trovare un compromesso tra la

precisione e il range (intervallo):

aumento p - > aumenta la precisione;

aumento n - > aumento il range;

Di solito si preferisce la rappresentazione in virgola mobile, per questioni di

precisione. L’unico caso in cui si preferisce la fissa è quando p = N: si ha un registro

in cui tutti i bit rappresentano la parte frazionaria.