violazione di accesso

[Unrue]

Originariamente inviato da ilsensine

Continua ad essere errato. Qui da me feof ritorna true solo dopo la prima volta che fgetc ritorna -1. Il risultato è un accesso a PHuff[-1] se il file è vuoto. Utilizza la
while((v=fgetc(in))>=0){PHuff[v]->frequenza++;}
direttamente eliminando il resto inutile di codice (nb occhio che il confronto è ">=0" non ">0").

A me funziona pero', guarda:


while(!feof(in)){
v= fgetc(in);
if(PHuff[v]==NULL)
{PHuff[v]=new Huffman(v,1,NULL,NULL);}
else
{if(v>=0){PHuff[v]->frequenza++;}}
}
fclose(in);


Tu dici che dovrei scrivere cosi?

while((v=fgetc(in))>=0){PHuff[v]->frequenza++;}

e basta? Quindi il controllo sullla fine del file mi viene direttamente da v quando vale -1. Pero' devo metterci anche il codice che mi fa puntare il puntatore nella posizione v ad un'oggetto di tipo Huffman,quello non posso toglierlo. Incremento la frequenza solo se ho giò incontrato quel simbolo

[Unrue]

Originariamente inviato da ilsensine

Dalla documentazione in mio possesso, feof non fa altro che testare l'indicatore EOF dello stream. Evidentemente la fgetc imposta tale indicatore, ma solo quando si accorge che il file è finito (e contestualmente ritorna -1).
Ho letto adesso; non amo molto le funzioni sui FILE *.

Alla fine ho scritto cosi:

while(v= fgetc(in)>=0){
if(PHuff[v]==NULL)
{PHuff[v]=new Huffman(v,1,NULL,NULL);}
else
{PHuff[v]->frequenza++;}
}
fclose(in);
cout<<"3";
return PHuff;

e funziona lo stesso, non so se in quell'altro modo andasse veramente, magari mi creava l'albero ma era tutto sbagliato

[ilsensine]

Originariamente inviato da Unrue

A me funziona pero', guarda:

Prova con un file di lunghezza 0

Alla fine ho scritto cosi:

while(v= fgetc(in)>=0){
if(PHuff[v]==NULL)
{PHuff[v]=new Huffman(v,1,NULL,NULL);}
else
{PHuff[v]->frequenza++;}
}

Il controllo sulla nullità di PHuff[v] è superfluo in quanto tutti gli oggetti sono stati preallocati (quindi PHuff[v] è sicuramente !=NULL).

[Unrue]

Originariamente inviato da ilsensine

Prova con un file di lunghezza 0

Il controllo sulla nullità di PHuff[v] è superfluo in quanto tutti gli oggetti sono stati preallocati (quindi PHuff[v] è sicuramente !=NULL).

No aspetta, questa cosa non mi torna. Io ho un'array di puntatori tutti inizializzati a NULL e siamo d'accordo. Se ho trovato un simbolo v nuovo nel file che sto leggendo devo inizializzare tale puntatore nella posizione v facendolo puntare ad un oggetto di tipo Huffman (v,1,NULL,NULL). Tale controllo devo mettercelo, ma allora lo creo se la frequenza di quel nodo è 0. In pratica:

while(v=fgetc(in)>=0){
if(PHuff[v]->frequenza=0)
{PHuff[v]=new Huffman(v,1,NULL,NULL);}
else
{PHuff[v]->frequenza++;}
}
fclose(in);

va bene cosi'?il programma gira )

[ilsensine]

Originariamente inviato da Unrue

No aspetta, questa cosa non mi torna. Io ho un'array di puntatori tutti inizializzati a NULL e siamo d'accordo.

Non siamo d'accordo. Se hai usato il codice di inizializzazione che ho postato, gli oggetti sono tutti preallocati con frequenza 0, che mi sembra la soluzione più logica.
Se non vuoi questo comportamento devi cambiare la

 for(unsigned pos=0; pos<256; ++pos) {
  PHuff[pos] = new Huffman(pos, 0, NULL, NULL);
 }

in

 for(unsigned pos=0; pos<256; ++pos) {
  PHuff[pos] = NULL;
 }

[Unrue]

Originariamente inviato da ilsensine

Non siamo d'accordo. Se hai usato il codice di inizializzazione che ho postato, gli oggetti sono tutti preallocati con frequenza 0, che mi sembra la soluzione più logica.
Se non vuoi questo comportamento devi cambiare la

 for(unsigned pos=0; pos<256; ++pos) {
  PHuff[pos] = new Huffman(pos, 0, NULL, NULL);
 }

in

 for(unsigned pos=0; pos<256; ++pos) {
  PHuff[pos] = NULL;
 }

Hai ragione, ho sbagliato. i puntatori sono tutti preallocati, ma hanno frequenza 0. Man mano che leggo un simbolo v, faccio un controllo sulla frequenza del puntatore alla posizione v, se è un simbolo nuovo, la frequenza che leggo è 0 , quindi la incremento. Se è diversa da zero, vuol dire che quel simbolo l'ho già trovato nel file che sto leggendo, quindi la incremento di uno. Ok cosi'?

[Unrue]

Originariamente inviato da ilsensine

Non siamo d'accordo. Se hai usato il codice di inizializzazione che ho postato, gli oggetti sono tutti preallocati con frequenza 0, che mi sembra la soluzione più logica.
Se non vuoi questo comportamento devi cambiare la

 for(unsigned pos=0; pos<256; ++pos) {
  PHuff[pos] = new Huffman(pos, 0, NULL, NULL);
 }

in

 for(unsigned pos=0; pos<256; ++pos) {
  PHuff[pos] = NULL;
 }

Ciao,scusa se ti ridisturbo, il programma gira,ma accade una ocsa stranissima.Ho preso un fileprova.txt in cui ci ho scritto :
file di prova,vediamo se funziona


Ebbene, per vedere se funzionava il tutto ho messo delle stampe a video dopo la funzione fgetc e con grande sorpresa ho notato che mi da sempre 1! Cioè v, vale sempre 1, infatti il programma giustamente scrive 34 volte, (il numero delle battiture nel file di esempio), nella posizione 1 dell'array di puntatori. Come mai?

[Unrue]

Ho risolto rispolveranto la funzione feof ma facendo un controllo dopo sul vaolre restituito da v;

while(!feof(in)){
v=fgetc(in);
if(v>=0){
cout<<"\n"<<"questa è la v: "<<v;
PHuff[v]->frequenza++;
}
}

Adesso funziona !