Errore eccezioni

Devo svolgere questa traccia : Si realizzi un elenco di ProdottiFreschi, mediante una classe Lista, ricorrendo ad una implementazione linkata (a puntatori). La classe ElencoFreschi fornisce le seguenti funzionalità:
- inserimento: in testa, deve avvenire assicurando l'univocità del codice nella lista, nel caso si tenti di inserire un codice già esistente la funzione lancia una eccezione di tipo Duplicato

ho fatto tutto, ma l'argomento eccezioni non mi è ancora chiaro (e ho l'esame tra 2 giorni )

la mi a gestione prevede solamente una stampa a video.
ma il programma termina dandomi quest'errore:
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
terminate called after throwing an instance of 'char const*'

vi posto il codice dei vari files:

mian

#include <iostream>
#include "elenco.h"

using namespace std;

int main() {
	elenco <string>  e;
	e.insert("latte",1);
	e.insert("insalata",2);
	e.insert("pane",3);
	e.insert("frutta",4);
	e.insert("lem",1);

	e.print();

	return 0;
}

prodottifreschi.h (sarebbe il nodo della lista)

#ifndef PRODOTTIFRESCHI_H_
#define PRODOTTIFRESCHI_H_

template <class t> class elenco;

template <class t>
class prodottiFreschi {
	friend class elenco <t>;
public:
	prodottiFreschi(const t& ,int );
private:
	t data;
	int id;
	prodottiFreschi<t> * next;
};


template <class t>
prodottiFreschi<t>::prodottiFreschi(const t& value,int i){
	data=value;
	id=i;
	next=0;
}

elenco.h

/*
 * elenco.h
 *
 *  Created on: 15/lug/2013
 *      Author: gen
 */

#ifndef ELENCO_H_
#define ELENCO_H_
#include <iostream>
#include "prodottiFreschi.h"
#include "eccezione.h"
using namespace std;

template <class t>
class elenco {
public:
	elenco():firstPtr(0),lastPtr(0){};
	~elenco();
	bool isEmpty(){return firstPtr==0;}
	bool check(int);
	void insert(const t& ,int);
	void print();
private:
	prodottiFreschi<t>* firstPtr;
	prodottiFreschi<t>* lastPtr;
};


template <class t>
elenco<t>::~elenco(){
	if (!isEmpty()){
		prodottiFreschi<t>* currentPtr=firstPtr;
		prodottiFreschi<t>* tempPtr;
		while(currentPtr!=0){
			tempPtr=currentPtr;
			currentPtr=currentPtr->next;
			delete tempPtr;
		}
	}
	else cout<<"\nLista vuota\n";
}


template <class t>
void elenco<t>::insert(const t & value,int id){
	try{
			prodottiFreschi<t>* newPtr=new prodottiFreschi<t>(value,id);
			if(isEmpty())
				firstPtr=lastPtr=newPtr;
			else{
				if(!check(id)){
					throw("\nEccezione eseguita\n");
					newPtr->next=firstPtr;
					firstPtr=newPtr;
				}

			}
		}catch(eccezione& e){
			cout<<e.getWhat();
	}
}


template <class t>
bool elenco<t>::check(int i){
	prodottiFreschi<t>* currentPtr=firstPtr;
	bool trovato=false;
	while(currentPtr!=0&&trovato==false){
		if(currentPtr->id==i) {
			trovato=true;
			cout<<"Non posso inserire "<<i<<endl;
			return false;
		}
		currentPtr=currentPtr->next;
	}
	return true;
}

template <class t>
void elenco<t>::print(){
	if(isEmpty()){
		cout<<"\nLa lista è vuota, no può essere stampata ... \n";
	}
	else{
		prodottiFreschi<t>* currentPtr=firstPtr;
		while(currentPtr!=0){
			cout<<currentPtr->id<<"  "<<currentPtr->data<<"\n";
			currentPtr=currentPtr->next;
		}
	}
}
#endif /* ELENCO_H_ */

ed infine la classe eccezione:

/*
 * eccezione.h
 *
 *  Created on: 15/lug/2013
 *      Author: gen
 */

#ifndef ECCEZIONE_H_
#define ECCEZIONE_H_
using namespace std;
class eccezione {
public:
	eccezione(string s):what(s){};
	string getWhat(){return what;};
private:
	string what;
};

#endif /* ECCEZIONE_H_ */

in elenco.h c'è la funzione di inserimento che richiama al suo interno al funzione check, la quale restituisce false se trova un doppione e quindi poi si dovrebbe lanciare l'eccezione