Leggendo meglio errore mi ero accorto che semplicemente c'erano dei metodi che venivano solo dichiarati nella classe ma non venivano mai implementati, che codice carino
Ora ho un codice che funziona, ma su una funzione da me fatta vorrei essere sicuro che fa esattamente ciò che io voglio e non è solo un caso fortuito.
Detto in poche parole il costruttore della classe alloca dinamicamente un vettore di puntatori a tipo strutturato (mypair se vede il cocie non è altro che una struttura di due elementi chiave e valore, ovvero first e second) in questo modo:
codice:
hash_table<K,E>::hash_table(int the_divisor)
{
divisor = the_divisor;
dsize = 0;
table = new mypair<K, E>* [divisor];
for (int i=0; i<divisor; i++)
table[i] = NULL;
}
Ed inizializza tutti i puntatori a NULL
L'inserimento di un nuovo elemento invece, senza scendere di tutte le precondizioni non fa altro che far puntare un elemento del vettore ad un nuovo elemento the_pair.
codice:
template<class K, class E>
void hash_table<K,E>::insert(mypair<K, E>& the_pair)
{
// search the table for a matching element
int b = search(the_pair.first);
// chack if matching element found
if (table[b] == NULL){
// no matching element and table not full
table[b] = new mypair<K, E >(the_pair);
dsize++;
} else {
// check id duplicate or table full
if (table[b]->first == the_pair.first)
// duplicate, change table[b]->second
table[b]->second = the_pair.second;
else{
// table is full
// throw the exception hash_table_full();
}
}
}
Ora il mio arduo () compito è stato quello di sviluppare la funzione di erase, che è si fatta:
codice:
template<class K, class E>
void hash_table<K,E>::erase(const K& k)
{
if( find(k) != NULL)
{
// search the table for a matching element
int b = search(k);
delete find(k);
table[b] = NULL;
}
}
Il dubbio è questo, la funzione di cancellazione non fa altro che vedere se l'elemento che vuoi cancellare effettivamente esiste con la prima condizione, se esiste ne cerca la posizione nella tabella (si lo so non è molto ottimizzato questo codice), dealloca (con delete) la coppia mypair (che ti ritorna da find) e poi setta a NULL il puntatore nella tabella.
E' tutto giusto così?
Cioè se io mettessi solo a null il puntatore sulla tabella ma non mettessi quel delete rimarebbe allocato il mio spazio di memoria no?
La funzione find è questa:
codice:
template<class K, class E>
mypair<K, E>* hash_table<K,E>::find(const K& the_key)
{
// search the table
int b = search(the_key);
// see if a match was found at table[b]
if (table[b] == NULL || table[b]->first != the_key)
return NULL; // no match
return table[b]; // matching pair
}
Ovvero non dovrebbe far altro che ritornare, nel caso esiste il puntatore proprio all'indirizzo della coppia mypair.
Dite che è giusto? con i puntatori non si è mai sicuri al 100%