compressore Class Reference

La classe che si occupa della compressione. More...

#include <compressore.h>

List of all members.

Public Member Functions

compressore (const char file[], const char fileo[])

il costruttore.

Protected Member Functions

void contaoccorrenze ()

assegna a v l'array con le sole frequenze.

int arrayfreq ()

assegna a pf un array con i caratteri e le relative frequenze.

node * huffman (heap h, int last)

costruisce l'albero delle codifiche.

void linearizza (node *tree, char *codice, int j=0)

costruisce l'array delle codifiche.

void comprimi (const char file[], IOs &out)

comprime il file.

void cancella (node *&tree)

cancella l'albero.

int traduci (char c)

questa funzione traduce un carattere nel suo corrispondente valore intero.

int elevato (int a, int b)

funzione che eleva l'intero a a potenza b.

Protected Attributes

int num

intero che conterrà il numero di diversi caratteri nel file.

fstream stream

stream per la lettura da file.

int * v

puntatore all'array con le sole frequenze dei 256 caratteri.

frequenza ** pf

puntatore all'array che diverrà heap.

node * root

puntatore al nodo che sarà la radice dell'albero delle codifiche.

char ** c

puntatore all'array contenente le codifiche risultanti.

Detailed Description

La classe che si occupa della compressione.

ho deciso di far svolgere tutti i passi al costruttore ed è lui stesso che richiama i metodi e provvede a eseguirli; i file codificati con questa classe potranno essere decodificati tramite la classe decompressore

See also:: decompressore

Definition at line 18 of file compressore.h.

Constructor & Destructor Documentation

compressore::compressore ( const char file[],

const char fileo[]

)

il costruttore.
questo costruttore sarà colui che svolgerà tutte le operazioni della compressione fino alla generazione del file compresso; il distruttore non è ptrsente perché il costruttore steso provvede a distruggere gli oggetti in memoria che risultano inutili; il parametro fileo viene passato al costruttore della classe IOs ed è lei stessa che provvede a scrivere l'intestazione; Complessità: O(n * log n) + O(m), ma siccome m è sempre >= a n allora si può fare la seguente approssimazione -> O(m).
See also:
IOs

Parameters:

file | il file da cui leggo.

fileo | il file dove scrivo.

Definition at line 63 of file compressore.cpp.
References arrayfreq(), c, contaoccorrenze(), node::freq, huffman(), heap::lastn(), num, pf, root, stream, traduci(), heap::v, and v.

Member Function Documentation

int compressore::arrayfreq ( ) [protected]

assegna a pf un array con i caratteri e le relative frequenze.
le sole frequenze > di 0 vengono memorizzate in pf ritorna il numero di caratteri diversi incontrati che verrà assegnato a num, per memorizzare solamente le frequenze diverse da 0 è necessario almeno uno scorrimento completo di v, ma per evitarne un secondo utilizzo un oggetto di tipo listadoppia; Complessità: O(n).
Returns:
il numero di caratteri diversi

See also:
num, pf, listadoppia, v

Definition at line 189 of file compressore.cpp.
References c, listadoppia::estrai(), listadoppia::inserisci(), listadoppia::numero(), pf, and v.
Referenced by compressore().

void compressore::cancella ( node *& tree ) [protected]

cancella l'albero.
per cancellare l'albero dalla memoria dinamica è necessaria una funzione ricorsiva, quindi introduco cancella(), essa viene invocata dal costruttore appena l'albero risulta inutile, in modo da non tenere in memoria informazioni inutili; Complessità: O(n).
Parameters:

tree |essendo ricorsiva, questa è la variabile di ricorsione.

See also:
root, huffman()

Definition at line 160 of file compressore.cpp.

void compressore::comprimi ( const char file[],

IOs & out

) [protected]

comprime il file.
essa legge da stream in modo binario in modo da leggere correttamente qualsiasi carattere, e per ogni carattere scrive la codifica corrispondente contenuta nell'array c, notare che l'accesso alla cella corrispondente dell' array c è diretto e quindi O(1), essa necessita di riaprire lo stream dato che dopo la funzione contaoccorrenze(), esso è già arrivato al termine del file; la classe IOs si occupa di scrivere le codifiche byte per byte, al termine viene invocato il metodo di IOs IOs::svuota(), per svuotare il buffer stampando l'ultimo carattere della codifica; Complessità: O(m).
Parameters:

file | il file da cui leggere.

out | riferimento a oggetto di tipo IOs che scrive byte per byte le codifiche.

See also:
stream, c, contaoccorrenze(), IOs, IOs::svuota()

Definition at line 259 of file compressore.cpp.
References c, IOs::inserisci(), stream, IOs::svuota(), and traduci().

void compressore::contaoccorrenze ( ) [protected]

assegna a v l'array con le sole frequenze.
si avvale della lettura in modo non formattato, si noti che al termine della funzione vi sono anche valori nulli; Complessità: O(m).
See also:
v

Definition at line 170 of file compressore.cpp.
References stream, and v.
Referenced by compressore().

int compressore::elevato ( int a,

int b

) [protected]

funzione che eleva l'intero a a potenza b.
ho definito questa funzione perché opera solo sugli interi, è necessaria per la traduci(char c), non uso la pow predefinita per evitare che la conversione in double e da double causi problemi; Complessità: O(1).
Parameters:

a | base.

b | esponente.

Definition at line 13 of file compressore.cpp.
Referenced by traduci().

node * compressore::huffman ( heap h,

int last

) [protected]

costruisce l'albero delle codifiche.
costruisce l'albero memorizzandone il puntatore di base in root utilizzando come argomento l'heap di puntatori, organizzato in modo crescente per frequenza a partire da pf; Complessità: O(n * log n).
Parameters:

h | oggetto di tipo heap.

last | ultimo indice dello heap.

Returns:
il puntatore alla radice, memorizzato in root

See also:
pf, heap, root

Definition at line 218 of file compressore.cpp.
References heap::estrai(), node::freq, heap::inserisci(), node::left, and node::right.
Referenced by compressore().

void compressore::linearizza ( node * tree,

char * codice,

int j = 0

) [protected]

costruisce l'array delle codifiche.
assegna l'array delle codifiche a c a partire dall'albero di huffman in modo da velocizzare la traduzione del file, che verrà effettuata dalla comprimi(); Complessità: O(n).
Parameters:

tree | la funzione è ricorsiva, all'inizio questo puntatore corrisponde alla radice.

codice | questo parametro è necessario per la ricorsione, ad ogni passo esso corrisponde al codice fino a quel momento.

j | tiene in memoria il livello, o se vogliamo la lunghezza del codice.

See also:
c, root

Definition at line 232 of file compressore.cpp.
References c, node::left, node::right, and traduci().

int compressore::traduci ( char c ) [protected]

questa funzione traduce un carattere nel suo corrispondente valore intero.
è necessario definire questa funzione perché se si utilizza la conversione esplicita possono essere tradotti in modo scorretto certi caratteri dell'ASCII esteso; Complessità: O(1).
Parameters:

c | carattere da tradurre.

Returns:
il valore intero corrispondente

See also:
elevato()

Definition at line 25 of file compressore.cpp.
References elevato().
Referenced by compressore(), comprimi(), and linearizza().

Member Data Documentation

char** compressore::c [protected]

puntatore all'array contenente le codifiche risultanti.
la funzione linearizza() provvede a inserire nell'array le codifiche dei caratteri, trovate grazie alla funzione huffman e contenute nel puntatore root.
See also:
root, huffman() and linearizza()

Definition at line 79 of file compressore.h.
Referenced by arrayfreq(), compressore(), comprimi(), and linearizza().

frequenza** compressore::pf [protected]

puntatore all'array che diverrà heap.
ogni elemento di questo array contiene un puntatore a un oggetto di tipo frequenza, esso verrà prima modificato dalla funzione arrayfreq e poi diverrà heap
See also:
arrayfreq

Definition at line 65 of file compressore.h.
Referenced by arrayfreq(), and compressore().

node* compressore::root [protected]

puntatore al nodo che sarà la radice dell'albero delle codifiche.
esso verrà costruito con la funzione Huffman.
See also:
huffman()

Definition at line 71 of file compressore.h.
Referenced by compressore().

fstream compressore::stream [protected]

stream per la lettura da file.
viene aperto in modalità lettura binaria per fare in modo di leggere correttamente i caratteri che vengono letti in altro modo nella lettura formattata.
Definition at line 50 of file compressore.h.
Referenced by compressore(), comprimi(), and contaoccorrenze().

int* compressore::v [protected]

puntatore all'array con le sole frequenze dei 256 caratteri.
servirà per la funzione che dovrà contare le occorrenze di ogni carattere presente nel testo, ossia contaoccorrenze().
See also:
contaoccorrenze()

Definition at line 57 of file compressore.h.
Referenced by arrayfreq(), compressore(), and contaoccorrenze().

The documentation for this class was generated from the following files:

Desktop/Daniele/Program Editing/Progetto di informatica 2/componenti/compressore.h
Desktop/Daniele/Program Editing/Progetto di informatica 2/componenti/compressore.cpp

Generated on Sat May 20 14:57:56 2006 for Huffzip by

1.4.6-NO


Public Member Functions
	compressore (const char file[], const char fileo[])
	il costruttore.
Protected Member Functions
void	contaoccorrenze ()
	assegna a v l'array con le sole frequenze.
int	arrayfreq ()
	assegna a pf un array con i caratteri e le relative frequenze.
node *	huffman (heap h, int last)
	costruisce l'albero delle codifiche.
void	linearizza (node tree, char codice, int j=0)
	costruisce l'array delle codifiche.
void	comprimi (const char file[], IOs &out)
	comprime il file.
void	cancella (node *&tree)
	cancella l'albero.
int	traduci (char c)
	questa funzione traduce un carattere nel suo corrispondente valore intero.
int	elevato (int a, int b)
	funzione che eleva l'intero a a potenza b.
Protected Attributes
int	num
	intero che conterrà il numero di diversi caratteri nel file.
fstream	stream
	stream per la lettura da file.
int *	v
	puntatore all'array con le sole frequenze dei 256 caratteri.
frequenza **	pf
	puntatore all'array che diverrà heap.
node *	root
	puntatore al nodo che sarà la radice dell'albero delle codifiche.
char **	c
	puntatore all'array contenente le codifiche risultanti.