Salve ragazzi,

quando compilo mi da questo tipo di errore...ma non riesco a capire come risolverlo, dato che i metodi sono tutti dichiarati e li mostra nei suggerimenti.

classe Huffman

codice:
#include "Huffman.h"#include "Nodo.h"
#include "Coda_priorita.h"
#include <iostream> //libreria per l'i/o
#include <vector>   //libreria per gestire i vettori
#include <fstream>  //libreria per gestire i files
#include <cmath>    //libreria che permette di usare funzioni matematiche (nel mio caso la pow())
#include <cstdlib>  //libreria che permette di usare le funzioni system
#include <string>	//libreria che permette di usare e gestire le stringhe
#include <bitset>	//libreria che permette l'uso di array di bit


using namespace std;


vector<char>Huffman::lettura_file(string nome)
{
  ifstream fileread;
  fileread.open(nome);
  if(fileread.is_open())
    cout<<"Il file e' stato aperto correttamente!"<<endl;
    else{
        cout<<"Il file non esiste!!"<<endl;
        system("pause");
        exit(1);
    }
 vector<char> buffer;
 char carattere;
 while(fileread.get(carattere))
    buffer.push_back(carattere);
 fileread.close();
 return buffer;
}


void Huffman::costruisci_albero(){
    for(int j=0;j<256;j++)
        occorrenze.push_back(0);
    for(int i=0;i<input.size();i++)
        occorrenze[static_cast<int> (input[i])]++;
    vector <Nodo*> nodi;
    for(int i=0;i<occorrenze.size();i++)
        if(occorrenze[i]>0)
            nodi.push_back(new Nodo(occorrenze[i],i));


    Coda_priorita *coda = new Coda_priorita(nodi);


    while((coda->get_size())>1){
        Nodo *nodo=new Nodo;
        Nodo *sinistro,*destro;
        sinistro=coda->estrai_min();
        destro=coda->estrai_min();
        nodo->set_frequenza(sinistro->get_frequenza()+destro->get_frequenza());
        nodo->set_sinistro(sinistro);
        nodo->set_destro(destro);
        coda->inserisci(nodo);
    }
    radice=coda->estrai_min();
}
codice:
#ifndef HUFFMAN_H#define HUFFMAN_H
#include "Nodo.h"
#include "Coda_priorita.h"
#include <iostream> //libreria per l'i/o
#include <vector>   //libreria per gestire i vettori
#include <fstream>  //libreria per gestire i files
#include <cmath>    //libreria che permette di usare funzioni matematiche (nel mio caso la pow())
#include <cstdlib>  //libreria che permette di usare le funzioni system
#include <string>	//libreria che permette di usare e gestire le stringhe
#include <bitset>	//libreria che permette l'uso di array di bit


using namespace std;


class Huffman
{
    public:
        Huffman();
        void codifica(string p);
        void decompressione();
        ~Huffman();


    private:
        void compressione(string p);
        vector<char>lettura_file(string nome);
        void costruisci_albero();
        void costruisci_albero_decompressione();
        void tasso_compressione();
        void coding(Nodo*,char carattere,bool &);
        vector <int> v;
        vector <int> occorrenze;
        vector <char> input;
        Nodo* radice;
};


#endif // HUFFMAN_H
classe Nodo

codice:
#ifndef NODO_H#define NODO_H
#include <iostream> //libreria per l'i/o
#include <vector>   //libreria per gestire i vettori
#include <fstream>  //libreria per gestire i files
#include <cmath>    //libreria che permette di usare funzioni matematiche (nel mio caso la pow())
#include <cstdlib>  //libreria che permette di usare le funzioni system
#include <string>	//libreria che permette di usare e gestire le stringhe
#include <bitset>	//libreria che permette l'uso di array di bit


using namespace std;


class Nodo
{


        Nodo* sinistro; // puntatore nodo sinistro
        Nodo* destro;  // puntatore nodo destro
        int frequenza;
        string valore;
public:
        Nodo() {};  // costruttore di default
        Nodo (int freq, string val); //costruttore che prende in input frequenza e valore
        Nodo* get_sinistro();
        Nodo* get_destro();
        string get_valore();
        int get_frequenza();
        void set_frequenza(int freq1);
        void set_valore(string val1);
        void set_destro(Nodo*destro);
        void set_sinistro(Nodo*sinistro);
        ~Nodo() {delete sinistro;delete destro;};   //distruttore


};


#endif // NODO_H
codice:
#include "Nodo.h"#include <iostream> //libreria per l'i/o
#include <vector>   //libreria per gestire i vettori
#include <fstream>  //libreria per gestire i files
#include <cmath>    //libreria che permette di usare funzioni matematiche (nel mio caso la pow())
#include <cstdlib>  //libreria che permette di usare le funzioni system
#include <string>	//libreria che permette di usare e gestire le stringhe
#include <bitset>	//libreria che permette l'uso di array di bit


using namespace std;


Nodo::Nodo(int freq, string val)
{
    this->frequenza=freq;
    this->valore=val;
    this->destro=NULL;
    this->sinistro=NULL;
}


Nodo* Nodo::get_sinistro(){
    return this->sinistro;
}


Nodo* Nodo::get_destro(){
    return this->destro;
}


int Nodo::get_frequenza(){
    return this->frequenza;
}


string Nodo::get_valore(){
    return this->valore;
}


void Nodo::set_sinistro(Nodo* sinistro){
    this->sinistro=sinistro;
}


void Nodo::set_destro(Nodo* destro){
    this->destro=destro;
}


void Nodo::set_frequenza(int freq1){
    this->frequenza=freq1;
}


void Nodo::set_valore(string val1){
    this->valore=val1;
}
classe Coda di Priorita'

codice:
#ifndef CODA_PRIORITA_H#define CODA_PRIORITA_H
#include "Nodo.h"
#include <iostream> //libreria per l'i/o
#include <vector>   //libreria per gestire i vettori
#include <fstream>  //libreria per gestire i files
#include <cmath>    //libreria che permette di usare funzioni matematiche (nel mio caso la pow())
#include <cstdlib>  //libreria che permette di usare le funzioni system
#include <string>	//libreria che permette di usare e gestire le stringhe
#include <bitset>	//libreria che permette l'uso di array di bit


using namespace std;


class Coda_priorita
{
    public:
        Coda_priorita();
        void inserisci (Nodo*);
        Nodo* estrai_min();
        Nodo* get_radice();
        int get_size();
        ~Coda_priorita();


    private:
        vector <Nodo*> n;
        void heapify(int);
        void costruisci_heap();
        int get_sinistro(int);
        int get_destro(int);
};




#endif // CODA_PRIORITA_H
codice:
#include "Coda_priorita.h"#include "Nodo.h"
#include <iostream> //libreria per l'i/o
#include <vector>   //libreria per gestire i vettori
#include <fstream>  //libreria per gestire i files
#include <cmath>    //libreria che permette di usare funzioni matematiche (nel mio caso la pow())
#include <cstdlib>  //libreria che permette di usare le funzioni system
#include <string>	//libreria che permette di usare e gestire le stringhe
#include <bitset>	//libreria che permette l'uso di array di bit


using namespace std;


int Coda_priorita::get_size(){
    return n.size();
}


int Coda_priorita::get_sinistro(int i){
    return 2*i+1;
}


int Coda_priorita::get_destro(int i){
    return 2*i+2;
}


Nodo* Coda_priorita::get_radice(){
    return n[0];
}


Nodo* Coda_priorita::estrai_min(){
    Nodo* temp;
    temp=this->n[0];
    this->n[0]=this->n[n.size()-1];
    this->n[n.size()-1]=temp;
    n.pop_back();
    heapify(0);
    return temp;
}


void Coda_priorita::heapify(int i){
    int min,des,sin;
    min=i;
    sin=get_sinistro(i);
    des=get_destro(i);
    if (sin<n.size() && n[sin]->get_frequenza()<n[min]->get_frequenza())
        min=sin;
    if (des<n.size() && n[des]->get_frequenza()<n[min]->get_frequenza())
        min=des;
    if(min!=i){
        Nodo* temp=new Nodo();
        temp=this->n[min];
        this->n[min]=this->n[i];
        this->n[i]=this->n[min];
    heapify(min);
    }
}


void Coda_priorita::costruisci_heap(){
    for (int i = ((this->n.size()) - 1); i >= 0; i--)
		heapify(i);
}


void Coda_priorita::inserisci(Nodo*x){
    this->n.push_back(x);
    costruisci_heap();
}