Voici la classe patron liste à laquelle  a été ajouté une gestion des erreurs :

#include <iostream.h>
#include <stdlib.h>
#include <string.h>
#include <except.h>

// definition du type booleen

#define VRAI 1
#define FAUX 0
typedef char booleen;

// declaration et definition de la classe erreur de gestion des erreurs

class erreur
{
  public :
  // declaration des differents types d'erreur gérés
  static const int NON_DOCUMENTE;
  static const int MEMOIRE;
  static const int SYNTAXE;
  static const int MAX_CODE;
  // constructeurs
  erreur();
  erreur(int);
  erreur(int,char*);
  erreur(erreur&);

  // operateur de sortie sur flot
  friend ostream& operator << (ostream&,erreur);

  // destructeur
  ~erreur();

  private :
  // code de l'erreur
  int code;

  // commentaire supplementaire
  char* commentaire;
};

// initialistation des constantes de la classe erreur
const int erreur::NON_DOCUMENTE = 1;
const int erreur::MEMOIRE=2;
const int erreur::SYNTAXE=3;
const int erreur::MAX_CODE=4;

// constructeurs
erreur::erreur()
{
  commentaire = NULL;
  code = NON_DOCUMENTE;
}

erreur::erreur(int code_erreur)
{
  commentaire = NULL;
  if (code_erreur < MAX_CODE)
  {
	 code = code_erreur;
  }
  else
  {
	 code = NON_DOCUMENTE;
  }
}

erreur::erreur(int code_erreur, char* information)
{
  if ((commentaire = new char[strlen(information)+1]) == NULL)
  {
	 cout << "Espace mémoire insuffisant pour la création d'une erreur documentée." <<  endl;
	 exit(1);
  }
  strcpy(commentaire,information);
  if (code_erreur < MAX_CODE)
  {
	 code = code_erreur;
  }
  else
  {
	 code = NON_DOCUMENTE;
  }
}

erreur::erreur(erreur& err)
{
  if ((commentaire = new char[strlen(err.commentaire)+1]) == NULL)
  {
	 cout << "Espace mémoire insuffisant pour la création d'une erreur documentée." <<  endl;
	 exit(1);
  }
  strcpy(commentaire ,err.commentaire);
  code = err.code;
}

// sortie sur flot
ostream& operator << (ostream& flot, erreur err)
{
  switch(err.code)
  {
	 case err.NON_DOCUMENTE :
		flot << "Erreur " << err.commentaire << endl;
		break;
	 case err.MEMOIRE :
		flot << "Erreur de memoire " << err.commentaire << endl;
		break;
	 case err.SYNTAXE :
		flot << "Erreur de syntaxe " << err.commentaire << endl;
		break;
  }
  return flot;
}

// destructeur
erreur::~erreur()
{
  if(commentaire) delete[] commentaire;
}

// fonction appelée en cas de terminaison forcée
void terminaison()
{
  cout << "Une erreur non corrigeable est survenue. Le programme ne peut continuer. " << endl;
  exit(1);
}

// declaration et definition de la classe liste de gestion des listes

template <class T> class liste
{
  public :
  // constructeurs
  liste();
  liste(liste<T>&);

  // fonction permettant l'ajout d'un élément à la liste
  booleen ajouter (T);

  // operateur de sortie sur flot
  friend ostream& operator << (ostream&,liste<T>);

  // operateur d'entree sur flot
  friend istream& operator >> (istream&,liste<T>&);

  // operateur d'assignation
  liste<T> operator = (liste<T>);

  // fonction qui purge une liste
  void purge();

  // destructeur
  ~liste();

  private :
  // la liste est ici implémentée sous forme d'une liste chaînée
  // définition d'un maillon de la liste
  struct maillon
  {
	 T valeur;
	 maillon* suivant;
  };

  // pointeur de début de liste
  maillon* debut_liste;
};

template <class T> liste<T>::liste()
{
  debut_liste = NULL;
}

template <class T> liste<T>::liste(liste<T>& source)
{
  maillon *index,*nouveau;

  debut_liste = NULL;

  for (index=source.debut_liste; index!=NULL; index=index->suivant)
  {
	 if ((nouveau = new maillon) == NULL)
	 {
		throw erreur(erreur::MEMOIRE,"espace memoire insuffisant");
	 }
	 nouveau->valeur = index->valeur;
	 nouveau->suivant = debut_liste;
	 debut_liste = nouveau;
  }
}

template <class T> booleen liste<T>::ajouter(T element)
{
  maillon *nouveau;
  if ((nouveau = new maillon) == NULL)
  {
	 return FAUX;
  }
  nouveau->valeur = element;
  nouveau->suivant = debut_liste;
  debut_liste = nouveau;
  return VRAI;
}

template <class T> ostream& operator << (ostream& flot,liste<T> list)
{
  liste<T>::maillon *index;

  flot << "( " ;
  for (index=list.debut_liste; index!=NULL; index=index->suivant)
  {
	 flot << index->valeur << " ";
  }
  flot << ")";
  return flot;
}

template <class T> istream& operator >> (istream& flot,liste<T>& list)
{
  char delimiteur;
  T element;

  list.purge();

  flot >> delimiteur;
  if (delimiteur != '(')
  {
	 throw erreur(erreur::SYNTAXE,"liste mal formée ( elt1 elt2 ... )");
  }

  while (flot >> element)
  {
	 if (!list.ajouter(element))
	 {
		throw erreur(erreur::NON_DOCUMENTE,"lecture de la liste impossible");
	 }
  }

  // le flot est devenu  bad donc non lisible à cause de la tentative de lecture d'un caractère   
  // dans un entier. La fonction  clear le rend de nouveau operationnel.
  flot.clear();
  flot >> delimiteur;
  if (delimiteur != ')')
  {
	 throw erreur(erreur::SYNTAXE,"liste mal formée ( elt1 elt2 ... )");
  }

  return flot;
}


template <class T> void liste<T>::purge()
{
  maillon *index,*suivant_index;

  index = debut_liste;
  while(index!=NULL)
  {
	 suivant_index = index->suivant;
	 delete index;
	 index = suivant_index;
  }
  debut_liste = NULL;
}

template <class T> liste<T>::~liste()
{
  purge();
}

template <class T> liste<T> liste<T>::operator = (liste<T> source)
{
  // si la liste source est la même que la liste cible, on ne fait rien
  if (this == &source)
  {
	 return *this;
  }

  // destruction des maillons de l'ancienne liste
  maillon *index, *suivant_index;
  index = debut_liste;
  while(index!=NULL)
  {
	 suivant_index=index->suivant;
	 delete index;
	 index = suivant_index;
  }

  // copie de la liste source
  maillon *nouveau;
  debut_liste = NULL;
  for(index=source.debut_liste; index != NULL; index=index->suivant)
  {
	 if ((nouveau=new maillon) == NULL)
	 {
		throw erreur(erreur::MEMOIRE,"espace memoire insuffisant");
	 }

	 nouveau->valeur = index->valeur;
	 nouveau->suivant = debut_liste;
	 debut_liste = nouveau;
  }

  return *this;
}