Sujet Précédent Sujet Suivant

Execution ne se lance pas

maha1987 Messages postés 101 Date d'inscription samedi 4 juin 2011 Statut Membre Dernière intervention 29 avril 2013 - 1 févr. 2013 à 12:35
maha1987 Messages postés 101 Date d'inscription samedi 4 juin 2011 Statut Membre Dernière intervention 29 avril 2013 - 1 févr. 2013 à 14:21
j'ai developpee un programme c++ en utlisant le dev cpp ,apres sa compilation quand je lance lexecution la fenetre disparue dans qlq secondes et parfois le pc se redemarre

2 réponses

Réponse 1 / 2
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
1 févr. 2013 à 12:42
Bonjour

Sans plus d'information, impossible de t'aider...
- Poste ton code
- Essaie un IDE plus récent (Visual Studio Express, Code::Block, QtCreator). DevCPP est à éviter (plus maintenu, vieux compilateur).

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
Réponse 2 / 2
maha1987 Messages postés 101 Date d'inscription samedi 4 juin 2011 Statut Membre Dernière intervention 29 avril 2013
1 févr. 2013 à 14:21
merci pour ta réponse, voila le code : 
#include <stdlib.h>
#include 
#include<string>
#include<fstream>
#include<ctype.h>
#include "StringTokenizer.h"
using namespace std;
/*******************************************************************************
**************************classe element-liste*********************************
*******************************************************************************/
class element_liste
{

         string data; 
         element_liste *next;   
 public:
        element_liste(string contenu,element_liste *suiv)          
        {
            data=contenu;
            next=suiv;                 
        }
        element_liste(string contenu)
        {
            data=contenu;
            next=NULL; 
        }
       
   friend class liste;
   friend  class abr;
  
};
/********************************************************************************
**************************classe element_abr************************************
********************************************************************************/
class element_abr
{
private:
        string val;
        element_abr * fg;
        element_abr * fd;
       
public:
       element_abr()
       {
            val="";
            fg=NULL; 
            fd=NULL;      
       }
       element_abr(string contenu)
       {
            val=contenu;
            fg=NULL; 
            fd=NULL;                
       }
       
     friend class abr;  
     friend class liste;
};
/*******************************************************************************
**************************classe abr*******************************************
*******************************************************************************/
class abr
{
private:
        element_abr * racine;
        string file;
public:
       abr(string file_name);
       ~abr();
       void inserer (element_abr **racine,string mot);
       void supprimer(element_abr **racine,string mot);
       int rechercher(element_abr *racine,string mot);
       void convertir_maj(element_abr *racine); 
       void detruire(element_abr *racine) ;
       void view(element_abr *racine) ;  
       void insert_fichier(element_abr*racine,ofstream &f);  
       string getfile();
       element_abr * getracine();
       string fichier_resultant(string file1,string file2);
       element_abr* insert_liste(element_liste **first,int n);
       friend abr operator +(abr,abr);
};
//-------------------------------constructeur------------------------------------
abr::abr(string file_name)
{    string s;           
    file=file_name;
    ifstream f(file.c_str());
    if(!f.is_open()) 
      {
       cout<<"impossible d'ouvrir le fichier en lecture !!!"<<endl;
       racine=new element_abr();             
      }  
    else
      {
        while(getline(f,s)) 
        inserer(&racine,s); 
      }   
    f.close();      
}
//------------------------------insertion----------------------------------------
void abr::inserer (element_abr **racine,string mot)
{
 if(!rechercher(*racine,mot))    
 {
     if(*racine)
     {
        if(((*racine)->val).compare(mot)<=0)   inserer(&((*racine)->fg),mot)  ;
        else    inserer(&((*racine)->fd),mot);
     }
     else
     {
         *racine=new element_abr(mot);
     }
 }   
}
//-------------------------------recherche---------------------------------------
int abr::rechercher(element_abr *racine,string mot)
{
        if(racine)
        {
                  if(racine->val.compare(mot)==0) return(1);
                  if((racine->val).compare(mot)<0) return(rechercher(racine->fg,mot));
                  return(rechercher(racine->fd,mot));
        }
        return(0);
}
//-------------------------------supprission-------------------------------------
void abr::supprimer(element_abr **racine,string mot) 
{
  element_abr *p,**t;
  if(*racine)
  {
         if((*racine)->val.compare(mot)!=0)
           {
                    if(((*racine)->val).compare(mot)<0)   supprimer(&((*racine)->fg),mot);
                    else  supprimer(&((*racine)->fd),mot);                      
           }
         else
           {
                 if(!((*racine)->fd))
                 {
                        p=*racine;
                        *racine=(*racine)->fg;
                        delete(p);
                 }
                 else
                 {
                        if(!((*racine)->fg))
                        {
                                 p=*racine;
                                 *racine=(*racine)->fd;
                                 delete(p);         
                        }
                        else
                        {
                            t=&((*racine)->fg);
                            while((*t)->fd)
                            t=&((*t)->fd);
                            p=*t;
                            (*racine)->val=(*t)->val;
                            *t=(*t)->fg;
                            delete(p);
                        }
                 }
          }
  }   
     
}
//-------------------------------convertion--------------------------------------
void abr::convertir_maj(element_abr *racine)
{
      if(racine)
      {
          convertir_maj(racine->fg);
          convertir_maj(racine->fd);  
          for(int i =0;racine->val.size();i++)
           racine->val[i]=toupper(racine->val[i]);     
      }
     
}
//--------------------------------detruire---------------------------------------
void abr::detruire(element_abr *racine)
{
     if(racine != NULL)
     {
               detruire(racine->fg);
               detruire(racine->fd);
               delete(racine);
     }
}
//-----------------------------destructeur---------------------------------------
abr::~abr()
{
 ofstream f(file.c_str());
 if(!f) 
   cout<<"impossible d'ouvrir le fichier en ecriture!!!"<<endl;                  
 else
   {
    insert_fichier(racine,f) ;
    detruire(racine);
    racine=NULL; 
   }                    
}
//----------------------------insertion fichier----------------------------------
void abr::insert_fichier(element_abr*racine,ofstream &f)
{  
      if(racine)
        {
           insert_fichier(racine->fg,f);
           f << racine->val << "\n" ;
           insert_fichier(racine->fd,f);
         }
   
}
//---------------------------insertion liste abr---------------------------------
element_abr* abr::insert_liste(element_liste **first,int n) 
{
             
 if (n<=0) return(new element_abr());
  element_abr *gauche=insert_liste(&(*first),n/2);
  element_abr *a=new element_abr((*first)->data);
  a->fg=gauche;
  *first=(*first)->next;
  a->fd=insert_liste(&(*first),n-n/2-1);
  return(a);
}
//-----------------------------affichage arbre-----------------------------------
void abr::view(element_abr *racine)
{
     if(racine != NULL)
     {
               view(racine->fg);
               cout<<(racine->val)<<endl;
               view(racine->fd);
     }
     else
        cout<<"larbre est vide"<<endl;
}
//---------------------------------get_file--------------------------------------
string abr::getfile()
{
       return(file);
}
//--------------------------------get_racine-------------------------------------
element_abr* abr::getracine()
{
      return(racine);
}
//--------------------------------nom fichier resultant--------------------------
string abr::fichier_resultant(string file1,string file2)
{
       string s3;
       StringTokenizer s1(file1,".");
       StringTokenizer s2(file2,".");
       while(s1.hasMoreTokens())
       {
         s3=s1.nextToken()+ s2.nextToken();
         s3=s3+s1.nextToken();                     
       }
       return(s3);
}

/*******************************************************************************
**************************classe liste*****************************************
*******************************************************************************/
class liste
{
 private:
        element_liste *first;      
 public :
        liste();
        ~liste();
        void insert(string valeur);
        void create(element_abr* racine);
        string lire_data(element_abr* racine);  
        void fusion(element_liste **first,element_liste *a,element_liste *b);     
        element_liste* getfirst();
        int nb_element(element_liste*first);
        friend abr operator +(abr,abr);
      
};
//---------------------------------destructeur-----------------------------------
liste::~liste()
{
     element_liste *save;
    for( element_liste *p=first;p;)
     {
              save=p;
              p=p->next;
              delete(save);
     }          
}
//--------------------------------constructeur-----------------------------------
liste::liste()
{
    first=NULL;
}
//-----------------------------insertion-liste-----------------------------------
void liste::insert(string valeur)
{
     first= new element_liste(valeur,first);
}
//------------------------------creation-liste-----------------------------------
void liste::create(element_abr* racine)
{
     string s;
     while((s = lire_data(racine))!="")
       insert(s);
}
//----------------------------------lire_data------------------------------------
string liste::lire_data(element_abr* racine)
{
   string s;
   if(racine)
   {
        s=lire_data(racine->fd);
        s=racine->val;
        s=lire_data(racine->fg);
        return(s);
   }
   return("");
  
}
//-----------------------------fusionner deux listes-----------------------------
void liste::fusion(element_liste **first,element_liste *a,element_liste *b)
{
      if (a == NULL) 
           *first=b;
      else if (b==NULL) 
           *first=a;
 
  if (a->data <= b->data) 
  {
    *first = a;
     fusion(&((*first)->next),a->next, b);
  }
  else
  {
     *first = b;
     fusion(&((*first)->next),a, b->next);
  }
}
//----------------------------------get-first------------------------------------
element_liste* liste::getfirst()
{
      return(first);        
}
//-------------------------------nombre d'elements-----------------------------
int liste::nb_element(element_liste*first)
{
    if(first)
    return(1+nb_element(first->next));
    return(0);
}


//***********************************operateur +*********************************
abr operator +(abr p1,abr p2)
{
   element_liste *p; liste l1;liste l2;liste l3;
   abr p3(p3.fichier_resultant(p1.file,p2.file));
   l1.create(p1.racine);
   l2.create(p2.racine);
   p=l3.getfirst();
   l3.fusion(&p,l1.getfirst(),l2.getfirst());
   int n=l3.nb_element(l3.getfirst());
   p3.racine= p3.insert_liste(&p,n);
   return(p3);
}
//-----------------------------fin operateur + ----------------------------------
//-------------------------------affichage du fichier----------------------------
void affichage_fichier(string s)
{
ifstream fichier(s.c_str());
 
   if(fichier)
   {
      string ligne; 
      while(getline(fichier, ligne))
         cout << ligne << endl;
   }
   else
      cout << "ERREUR: Impossible d'ouvrir le fichier en lecture." << endl;
}
/*******************************************************************************
**************************main*******************************************
*******************************************************************************/
int main()
{
    string s;
    int a;
    cout << "Tapez le nom du fichier a traiter : "; 
     cin >> s;
    system(" color ec"); 
      do
      {
cout << "1:creer une abr avec le contenu du fichier\n2:ajouter un mot a l'abr\n3:supprimer un mot a l'abr\n4:rechercher un mot a l'abr\n";
cout << "5:convertir en majusculeles mots contenus dans l'abr\n6:voir le fichier trie\n7:additionner deux abr\n";
cout << "8:afficher le fichier resultant de l'addition\n0:Quitter le programme\n";
 cin >> a;
}
while(a<0||a>8);
switch(a)
{
         case 1:
              {
             abr d(s);
             d.view(d.getracine());
              break;
              }
         case 2:
              {
              string s1;
              cout << "Tapez le mot pour l'ajouter : "; 
              cin >> s1;
              abr d(s);
              element_abr *p=d.getracine();
              d.inserer(&p,s1);
              d.view(d.getracine());
              break;
              }
         case 3:
              {
              string s2;
             cout << "Tapez le mot pour le supprimer : "; 
              cin >> s2;
              abr d(s);
              element_abr *p=d.getracine();
              d.supprimer(&p,s2);
              d.view(d.getracine());
              break;
              }
             case 4:
                  {
                  string s3;
             cout << "Tapez le mot pour le rechercher : "; 
              cin >> s3;
              abr d(s);
            if(d.rechercher(d.getracine(),s3))
                cout << "l'abr contient ce mot";
            else cout << "ce mot n'exsite pas dans l'abr ";    
             break;
             }
         case 5:  
              {
                  abr d(s);
             d.convertir_maj(d.getracine());
              d.view(d.getracine());
              break;
              }
         case 6:
              {
             abr d(s);
            d.~abr();
            affichage_fichier(d.getfile());
              break;   
              }
         case 7:
              {
              string s4,s5;
            cout << "Tapez les noms du fichiers a additionner : "; 
            cin >> s4>>s5;
            abr a(s4);
            abr b(s5);
           abr c=a+b;
            c.view(c.getracine());
              break; 
              }
         case 8:
              {
             string s4,s5;
            cout << "Tapez les noms du fichiers a additionner : "; 
            cin >> s4>>s5;
            abr a(s4);
            abr b(s5);
           abr c=a+b;
           c.~abr();
             affichage_fichier(c.getfile()); 
              break;
              } 
         case 0:
              exit(0);  
              
              }
              
            
    do
    {
    cout << "Choisir 1:continuer ou 0:Quitter\n";
    cin >> a;
    if(a)
    {
         
         system("cls");
          do
      {
cout << "1:creer une abr avec le contenu du fichier\n2:ajouter un mot a l'abr\n3:supprimer un mot a l'abr\n4:rechercher un mot a l'abr\n5:convertir en majusculeles mots contenus dans l'abr\n6:voir le fichier trie\n7:additionner deux abr\n8:afficher le fichier resultant de l'addition\n0:Quitter le programme\n";
 cin >> a;
}
while(a<0||a>8);
switch(a)
{
             case 1:
              {
             abr d(s);
             d.view(d.getracine());
              break;
              }
         case 2:
              {
              string s1;
              cout << "Tapez le mot pour l'ajouter : "; 
              cin >> s1;
              abr d(s);
              element_abr *p=d.getracine();
              d.inserer(&p,s1);
              d.view(d.getracine());
              break;
              }
         case 3:
              {
              string s2;
             cout << "Tapez le mot pour le supprimer : "; 
              cin >> s2;
              abr d(s);
              element_abr *p=d.getracine();
              d.supprimer(&p,s2);
              d.view(d.getracine());
              break;
              }
             case 4:
                  {
                  string s3;
             cout << "Tapez le mot pour le rechercher : "; 
              cin >> s3;
              abr d(s);
            if(d.rechercher(d.getracine(),s3))
                cout << "l'abr contient ce mot";
            else cout << "ce mot n'exsite pas dans l'abr ";    
             break;
             }
         case 5:  
              {
              abr d(s);
             d.convertir_maj(d.getracine());
              d.view(d.getracine());
              break;
              }
         case 6:
              {
           abr d(s);
            d.~abr();
            affichage_fichier(d.getfile());
              break;   
              }
         case 7:
              {
              string s4,s5;
            cout << "Tapez les noms du fichiers a additionner : "; 
            cin >> s4>>s5;
            abr a(s4);
            abr b(s5);
           abr c=a+b;
            c.view(c.getracine());
              break; 
              }
         case 8:
              {
                     string s4,s5;
            cout << "Tapez les noms du fichiers a additionner : "; 
            cin >> s4>>s5;
            abr a(s4);
            abr b(s5);
           abr c=a+b;
             c.~abr();
             affichage_fichier(c.getfile()); 
              break;
              } 
              
              }
              }
         else
         if(!a)
         exit(0);
         }
         
    while(a);
    
    
    
  system("PAUSE");
         return (0);
    }
0

Discussions similaires

Erreur d’exécution 424 : objet requis
luciol8 -
Marion8316 -

7 réponses
erreur d'execution 9
cs_getrare -
getrare -

7 réponses
erreur d'execution '9'
cs_tracto -
tracto -

10 réponses
Erreur d'exécution '9' : l'indice n'appartient pas à la sélection
ptitemeuh -
ptitemeuh -

4 réponses
Erreur d'exécution 9
rednor -
rednor -

5 réponses
Rejoignez-nous