In this code I generate three "dict" objects. When main returns the deconstructor ~dict() is called. But it's only one of the three objects that get runs through the deconstructor without failing. The second one generates a segmentation fault. Why doesn't this work for all three objects.
(Note: When i use the list member erase() instead of it's deconstructor the two first objects gets deallocated correctly, but the third seg faults).

# include <iostream>
# include <list>

# define NUMASC 128 /* # ASCII-values */

using namespace std;

template <class detype> class dictElem{
public:
detype data;
string key;

dictElem(string k, detype d){
key = k;
data = d;
}
};

template <class dtype> class dict{
public:
typedef dictElem<dtype> dictE;
typedef list <dictE> listOfDictElems;
typedef list <dictE> *arrayOfLists;
arrayOfLists a;

dict(){
a = new listOfDictElems[NUMASC];
}

void dictadd(string key, dtype data){
int idx = hash(key);
dtype *tmp;

if((tmp = dictIdx(key, idx)) != NULL){
*tmp = data;
return;
}
a[idx].push_back(*(new dictE (key , data)));
}

bool dictDel(string key){
int idx = hash(key);

typename listOfDictElems::iterator it;
for(it = a[idx].begin(); it != a[idx].end(); ++it)
if(it->key == key){
a[idx].erase(it);
return true;
}
return false;
}

dtype *dictIdx(string pipe, int idx = -1){
if(idx == -1)
idx = hash(pipe);

typename listOfDictElems::iterator it;// Ensure the compiler that listOf... is a typename
for(it = a[idx].begin(); it != a[idx].end(); ++it)
if(it->key == pipe)
return &(it->data);
return NULL;
}

void delDict(){

}

int hash(string base){
string::size_type len = base.length();
unsigned int i;
int val = 0;
for(i = 0; i < len; i++){
val += base[i];
}
return (val % NUMASC);
}

void printdict(){
int i, node;
cout << "[DICT START]\n";
for(i = 0; i < NUMASC; i++)
if(!a[i].empty()){
node = 0;
cout << "array[" << i << "]:\n";
typename listOfDictElems::const_iterator it;
for(it=a[i].begin(); it!=a[i].end(); ++it)
cout << "\tNode " << node++ << "\t[Key : " << it->key << "]\n\t\t[Data: " << it->data << "]\n";
}
cout << "[DICT END]\n";
}

dict<dtype> operator* (dict<dtype> b){
dict<dtype> ret;
int i;
typename listOfDictElems::iterator it;

for(i = 0; i < NUMASC; i++){
if(!b.a[i].empty())
for(it = b.a[i].begin(); it != b.a[i].end(); ++it)
ret.dictadd(it->key, it->data);
if(!a[i].empty())
for(it = a[i].begin(); it != a[i].end(); ++it)
ret.dictadd(it->key, it->data);
}
return ret;
}

dict<dtype> operator/ (dict<dtype> b){
dict<dtype> ret;
int i;
typename listOfDictElems::iterator it;

for(i = 0; i < NUMASC; i++)
if(!b.a[i].empty() && !a[i].empty())
for(it = a[i].begin(); it != a[i].end(); ++it)
if(b.dictIdx(it->key) != NULL)
ret.dictadd(it->key, it->data);
return ret;
}

dict<dtype> operator- (dict<dtype> b){
dict<dtype> ret;
int i;
typename listOfDictElems::iterator it;

for(i = 0; i < NUMASC; i++){
if(!b.a[i].empty() && !a[i].empty()){
for(it = a[i].begin(); it != a[i].end(); ++it)
if(b.dictIdx(it->key) != NULL)
continue;
else{
ret.dictadd(it->key, it->data);
}
}else{
for(it = a[i].begin(); it != a[i].end(); ++it)
ret.dictadd(it->key, it->data);
}
}
return ret;
}

~dict(){ //destructor
int i;
cout << "here\n";
for(i = 0; i < NUMASC; i++)
if(!a[i].empty())
a[i].~listOfDictElems();

delete [] a;
}

};

int main(){
typedef string type;
typedef dictElem<type> dictE;
typedef list <dictE> listOfDictElems;
typedef list <dictE> *arrayOfLists;
dict<type> d;
d.dictadd("key1", "string");
d.dictadd("kex2", "data");
d.dictadd("key2", "dd");
d.dictadd("key3", "test");
d.printdict();
// d.dictDel("key1");
d.printdict();
dict<type> e;
e.dictadd("kex2", "skalikkekomme");
e.dictadd("tt2", "data");
e.dictadd("tt3", "dd");
e.dictadd("tt4", "test");
e.printdict();
dict<type> p = d*e;
p.printdict();
p = d/e;
p.printdict();
p = d-e;
p.printdict();
// p.~dict();
}