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%