Comment on fait??
Paske moi ça fait couiller mes progs qd le destructeur est appelé. Je faisait 1 delete de la tete et de la queue et un appel du constructeur par défaut des maillons avant.
Merci d'avance...

Il suffit normalement de faire un delete juste de ta tete en tout cas si ce ne sont pas de arbres !!!

OK mais ça va pas detruire le contenu de tout mes maillons.

si c est une simple liste normalement si !

Oups g omis de dire ke C t une liste générique doublement chainée...

 
Ca depend de ta liste pardi !
Quelle classe utilises-tu?
 
Legreg

 
Ouai d'accord mais ca nous en dit pas plus..
T'as pas le code de ta classe?
 
Legreg

 
 
// liste.h: interface for the Cliste class.
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_LISTE_H__CA951F6C_7224_4C51_AE1C_C46225634B5A__INCLUDED_)
#define AFX_LISTE_H__CA951F6C_7224_4C51_AE1C_C46225634B5A__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
template <class T>
class Cliste  
{
 Cmaillon<T> *queue, *tete, *cour;
 char nomfich[40];
 int loading, nbt;
 
public:
 Cliste(void);
 ~Cliste(void);
 void set_tete(Cmaillon<T>*);
 void set_queue(Cmaillon<T>*);
 void set_loading(int);
 void set_nbt(int);
 void set_nomf (char*);
 char* get_nomf(char*);
 Cmaillon<T>* get_tete(void);
 Cmaillon<T>* get_queue(void);
 int get_nbt(void);
 void ajout_tete(const T &);
 void ajout_queue(const T &);
 void ajout_queue( Cliste<T>&, Cliste<T> );
 void ajout_avant(const T &, Cmaillon<T> *);
 void supp_tete(void);
 void supp_queue(void);
 void supp_pos(Cmaillon<T> *);
 void afficheliste_ville_trans(Carc [], int, CListBox&);
 Cmaillon<T> * recherche(const T &);
 Cliste<T> recherche_theme(char*);
// void ajout_trie(const T &);
 void ajout_trie(T);
 void ajout_trie_circuit(T, Cliste<T> );
 void chargement (void);
 void chargement_circuit ( Cliste<T> );
 void sauvegarde (void);  //ecrase le fichier qd on a fait une suppression ds la liste
 
 void Draw(CDC *cdc);
 void Draw(CDC *cdc, Cliste<T> lv);
 
 /*class Cerreur
 {int code;
 public:
  //int code;
  Cerreur(int);
  int get_code(void);
  };*/
};
 
/*template <class T>
Cliste<T>::Cerreur::Cerreur(int c)
{code=c;
}
 
template <class T>
int Cliste<T>::Cerreur::get_code(void)
{return code;
}*/
 
template <class T>
Cliste<T>::Cliste(void)
{
 tete = queue = NULL;
 strcpy(nomfich, "ville.txt" );
 loading=nbt=0;
}
 
template <class T>
Cliste<T>::~Cliste(void)
{
/* cour = tete;
 while(cour != NULL)
 {
  cour = cour->get_suiv();
  cour->get_prec() = NULL;
 }*/
 
 //tete = queue = NULL;
 
 //delete tete;
 //delete queue;
}
 
template <class T>
void Cliste<T>::set_tete(Cmaillon<T> *m)
{ tete=m;}
 
template <class T>
void Cliste<T>::set_queue(Cmaillon<T> *m)
{ queue=m;}
 
template <class T>
void Cliste<T>::set_loading(int i)
{ loading=i;}
 
template <class T>
Cmaillon<T>* Cliste<T>::get_tete(void)
{ return tete;}
 
template <class T>
Cmaillon<T>* Cliste<T>::get_queue(void)
{ return queue;}
 
template <class T>
int Cliste<T>::get_nbt(void)
{ return nbt;}
 
template <class T>
void Cliste<T>::set_nbt(int n)
{ nbt=n;}
 
template <class T>
void Cliste<T>::set_nomf (char *n)
{ strcpy(nomfich, n);}
 
template <class T>
char* Cliste<T>::get_nomf(char*s)
{
 strcpy(s, nomf);
 return s;
}
 
template <class T>
void Cliste<T>::ajout_tete(const T& a)
{
 Cmaillon<T> *p;
 p = new Cmaillon<T>;
 p -> set_info(a);
 p -> set_suiv(tete);
 p -> set_prec(NULL);
 if (tete == NULL) queue = p;                    
  else tete->set_prec(p);
 tete = p;
}
 
template <class T>
void Cliste<T>::ajout_queue(const T& a)
{
 Cmaillon<T> *p;
 p = new Cmaillon<T>;
 p -> set_info(a);
  p -> set_suiv(NULL);
  p -> set_prec(queue);
  if (queue == NULL)
  tete = p;
 else queue->set_suiv(p);        
 queue = p;
}
 
template <class T>
void Cliste<T>::ajout_queue(Cliste<T> &l, Cliste<T> lv)
{
 Cmaillon<T> *pl;
 
 pl=l.get_queue();
 while (pl!=NULL)
 {
  ajout_queue( pl->get_info() );
  pl=pl->get_prec();  
 }
}
 
template <class T>
void Cliste<T>::ajout_avant(const T& a, Cmaillon<T> *m)
{
 Cmaillon<T> *p;
 p = new Cmaillon<T>;
 p -> set_info(a);
 p -> set_suiv(m);
 p -> set_prec(m -> get_prec());
 
 (m -> get_prec()) -> set_suiv(p);
  m -> set_prec(p);
}
 
template <class T>
void Cliste<T>::supp_tete(void)
{
 Cmaillon<T> *p;
 if(tete->get_suiv()==NULL) tete=queue=NULL;
 else
 {
  p = tete;
  tete->get_suiv() -> set_prec(NULL);
  tete=tete->get_suiv();
 }
}
 
template <class T>
void Cliste<T>::supp_queue(void)
{
 Cmaillon<T> *p;
 p = queue;
 queue->get_prec() -> set_suiv(NULL);
 queue=queue->get_prec();
}
 
template <class T>
void Cliste<T>::supp_pos(Cmaillon<T> *m)
{
 if(m!=NULL)
 {
  if (m==tete) supp_tete();
        else if (m==queue) supp_queue();
             else  
    {
      (m -> get_suiv()) -> set_prec(m -> get_prec());
         (m -> get_prec()) -> set_suiv(m -> get_suiv());
    }
  delete m;
  nbt--;
  if (!loading) sauvegarde();
 }
}
 
template <class T>
void Cliste<T>::afficheliste_ville_trans(Carc t[], int nba, CListBox& m_lb)
{
 Cmaillon<T> *p;
 char c[40], v1[40], v2[40], v11[40], v22[40];
 int i=0;
 CString s, s1, s2, s3, s4;
 
 cout<<endl;
 if (tete != NULL)
 {
  p = tete;
  while (p -> get_suiv() != NULL)
  {
   p -> get_info().get_nom(v1);
   p -> get_suiv() -> get_info().get_nom(v2);
   for( i=0; i<nba; i++ )
   if( strcmp( t[i].get_depart(v11), v1 )==0
             && strcmp( t[i].get_arrivee(v22), v2 )==0 )  
   {
    t[i].get_transport(c);
    //printf("%15s -> %-15s par %s ( %4i km ).\n",v1, v2, c, t[i].get_dist() );
    s1 = v1; s2 = v2; s3 = c;
    s4 = itoa(t[i].get_dist(), c, 10 );
    s = s1+" -> "+s2+" par "+s3+" ( "+s4+" km ).";
    m_lb.AddString(s);
    break;
   }
   p = p->get_suiv();            
  }
 }
 else m_lb.AddString("Liste vide." );
 s = "";
 m_lb.AddString(s);
 m_lb.AddString("Arrivée !" );
}
 
template <class T>
Cmaillon<T>* Cliste<T>::recherche(const T& a)
{
 Cmaillon<T> *p, *res;
 if (tete != NULL)
 {
  p = tete;
  while ( p -> get_info() != a && p != queue)
   p = p -> get_suiv();
  if (p -> get_info() == a) res = p;
  else res = NULL;
 }
 else res = NULL;
 return res;
}
 
template <class T>
Cliste<T> Cliste<T>::recherche_theme(char *s)
{
 Cliste<T> lt;
 Cmaillon<T> *p;
 int res;
 lt.loading=1;  //c'est pour ne pas ecrire dans le fichier!!!!
 if (tete != NULL)           //qd on execute l'ajout_trié
 {
  p = tete;
  while (p  != NULL)
  {
   res = ( p -> get_info() ) . recherche_theme(s);
   if(res) lt.ajout_trie( p->get_info() );
   p = p->get_suiv();
  }
 }
 lt.loading=0;
 return lt;
}
 
template <class T>
//void Cliste<T>::ajout_trie(const T & a)
void Cliste<T>::ajout_trie(T a)
{  
 Cmaillon<T> *cour;
 
 nbt++;
 if(tete==NULL) ajout_tete(a);
 else if( a<tete->get_info() ) ajout_tete(a);
     else  
   {
   cour=tete;
   while( cour !=NULL && a>cour->get_info() )
   cour=cour->get_suiv();                            
   if(cour==NULL)ajout_queue(a);
   else ajout_avant(a,cour);
   }
 if (!loading)
 {
  ofstream sortie_f;
  sortie_f.open(nomfich, ios::app);
  sortie_f << a;
  sortie_f.close();
 }
}
 
template <class T>
void Cliste<T>::ajout_trie_circuit(T a, Cliste<T> lvi) //throw (Cerreur)
{
 if( lvi.recherche(a)!=NULL )// <=> si la ville est dans la liste placée en paramètre
 {
  nbt++;
  if(tete==NULL) ajout_tete(a);
  else ajout_queue(a);
  if( !loading)
  {
   ofstream sortie_f;
   sortie_f.open(nomfich, ios::app);
   sortie_f << a << flush;
   sortie_f.close();      
  }
 }
 else cout<<"ajout impossible car ville inconnue."<<endl;
}
 
template <class T>
void Cliste<T>::chargement (void)
{  
 ifstream entree_f(nomfich);
 T info;
 if ( tete==NULL )
 {
     loading=1;
  nbt=0;
  do
  {
   entree_f>>info;
   if( entree_f.eof()==0 )  
       ajout_trie(info);
  }while ( entree_f.eof()==0 );        
  entree_f.close();
  loading=0;
 }
}
 
template <class T>
void Cliste<T>::chargement_circuit (Cliste<T> l)
{
 ifstream entree_f(nomfich);
 T info;
 if ( tete==NULL )
 {
     loading=1;
  nbt=0;
  do
  {
   entree_f>>info;
   if( entree_f.eof()==0 )  
   ajout_trie_circuit(info, l);
  }while ( entree_f.eof()==0 );        
  entree_f.close();
  loading=0;
 }
}
 
template <class T>
void Cliste<T>::sauvegarde (void)
{  
 ofstream sortie_f;
 Cmaillon<T> *pm;
 pm=tete;
 sortie_f.open(nomfich, ios::out);
 for(int i=0;i<nbt;i++)
 {
  sortie_f << pm-> get_info();
  pm= pm->get_suiv() ;
 }
 sortie_f.close();
}
 
template <class T>
void Cliste<T>::Draw(CDC *cdc)
{
 CPoint pt(0,0);
 CSize centre(6, 6);
 CPen pen, Rpen, Gpen, Bpen;
 
 pen.CreatePen(PS_SOLID, 1, RGB(255,0,255) );
 
 Cmaillon<Cville> *m;
 m = tete;
 pt = m->get_info().get_pos();
 pt = pt + centre;
 cdc->MoveTo( pt );
 m = m->get_suiv();
 while ( m != NULL )
 {
  pt = m->get_info().get_pos();
  pt = pt + centre;
  cdc->LineTo( pt );
  m = m->get_suiv();
 }
 m = tete;
 pt = m->get_info().get_pos();
 pt = pt + centre;
 
 CPen *poldpen = cdc->SelectObject( & pen );
 
 cdc->LineTo( pt );
 
 cdc->SelectObject( poldpen );
}
 
template <class T>
void Cliste<T>::Draw(CDC *cdc, Cliste<T> lv)
{
 CPoint pt(0,0);
 CSize centre(6, 6);
 CPen pen, Rpen, Gpen, Bpen;
 char v[50], vd[50], va[50];
 Cgraph gr;
 
 gr.chargement( lv );
 pen.CreatePen(PS_SOLID, 1, RGB(255,0,255) );
 Rpen.CreatePen(PS_SOLID, 1, RGB(0,0,255) );
 Gpen.CreatePen(PS_SOLID, 1, RGB(0,255,0) );
 Bpen.CreatePen(PS_SOLID, 1, RGB(0,0,0) );
 
 Cmaillon<Cville> *m;
 m = tete;
 pt = m->get_info().get_pos();
 pt = pt + centre;
 cdc->MoveTo( pt );
 m = m->get_suiv();
 while ( m != NULL )
 {
  strcpy( vd, m->get_prec()->get_info().get_nom(v) );
  strcpy( va, m->get_info().get_nom(v) );
  strcpy( v, gr.get_rech_transport( va, vd ) );
  if( strcmp( v, "route" )==0 ) cdc->SelectObject( & Rpen );
  else if( strcmp( v, "avion" )==0 ) cdc->SelectObject( & Gpen );
  else if( strcmp( v, "train" )==0 ) cdc->SelectObject( & Bpen );
  else cdc->SelectObject( & Bpen );
 
  pt = m->get_info().get_pos();
  pt = pt + centre;
  cdc->LineTo( pt );
  m = m->get_suiv();
 }
 m = tete;
 pt = m->get_info().get_pos();
 pt = pt + centre;
 
 CPen *poldpen = cdc->SelectObject( & pen );
 
 cdc->LineTo( pt );
 
 cdc->SelectObject( poldpen );
}
 
#endif // !defined(AFX_LISTE_H__CA951F6C_7224_4C51_AE1C_C46225634B5A__INCLUDED_)

C'est quoi ce truc moisi ?
 
pourquoi t'utilises pas std:list<T> ?

 
Arrete de lui dire que sa liste est moisie, il va en faire un caca nerveux ! C'est quand même le puissant résultat de 3 ou 4 td et tp de c++ !

Elle est pas moisie ma liste et comme l'a dit JOTB, C le résultat de qq TP de licence d'info.
 
Mais alors ça n'inspire personne pour le destructeur???

 
Euh ca fait quoi ce bout de code??
 
LEGREG

 
On pourrait dire pas grand chose...

je pense que ça peut le faire
template <class T>  
Cliste<T>::~Cliste(void)  
{  
   Cmaillon<T> * p;
   if( tete != NULL )
   {
      p = tete->get_suiv();
      while( p != NULL )
      {
          delete tete;
          tete = p;
          p = p->get_suiv();
      }
      delete  tete;
   }
}  
 
marche si le pointeur vers le suivant est à nul s'il ne pointe sur rien, sinon utilise la STL, c'est mieux je pense.

[jfdsdjhfuetppo]--Message édité par ayachi le 19-05-2002 à 15:52:46--[/jfdsdjhfuetppo]