Creer objet avec classe heritée

Signaler
Messages postés
52
Date d'inscription
samedi 20 octobre 2007
Statut
Membre
Dernière intervention
7 mars 2010
-
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
-
Bonjour à tous,
Voici mon problème : j'ai une classe personne et 2 classe dérivées
interne et externe mais je veut créer dans mon main une personne mais
je ne sais pas encore de quel type elle appartient :

Dans le main :
 switch(Option)
     {
     case 1 :   pEle = new personne;     //Impossible de créer (normal il y a une méthode abstraite ...)
                pEle->Saisir();                //Dans cette méthode je choisi le type de personne
                Entreprise.Ajouter(pEle);
     break;

Differentes classes :
 class personne
    {
    protected:
    char Nom[10+1];
    char Prenom[10+1];
    char Matricule[10+1];
            int prix;
        int Fax;
    public:
    personne(char*No="", char*Pre="", char *Mat="");

    void Affiche();
    void Saisir();

    virtual int GetSalaire() const = 0;

     personne*pSuivant; // pointeur vers l'objet suivant

     class Externe : public personne
{
    public:
        Externe(int p) {Fax = p;}

        int GetSalaire() const
          {
            int sal = 2500;
            return sal;
        }

    protected:
        int Fax;
};

class Interne : public personne
{
    public:
        Interne(int p) {prix = p;}

            int GetSalaire() const
          {
            int sal = 1200;
            return sal;
        }

    protected:
        int prix;
};

35 réponses

Messages postés
52
Date d'inscription
samedi 20 octobre 2007
Statut
Membre
Dernière intervention
7 mars 2010

J'ai essayé de faire ceci :




std::istream& operator>> (std::istream& in, Interne* va)

{

  std::getline(in, sizeof(va->_prix), ';');


  return in;

}


std::ostream& operator<< (std::ostream& out, Interne* va)

{

  va->print(out);


  return out;

}

Mais j'ai cette erreur :


error: no matching function for call to
`getline(std::basic_istream<char, std::char_traits<char>
>&, unsigned int, char)'
Messages postés
52
Date d'inscription
samedi 20 octobre 2007
Statut
Membre
Dernière intervention
7 mars 2010

En fait, j'arrive a créer le fichier et le lire juste après quand l'appli est ouverte mais dès que je la ferme et que je la ré-exécute, le fichier n'est plus lu, comme si celui ci n'existait pas.
Aidez moi. Merci
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
Copie colle moi ton code, que je puisse t'aider. Je regarderais cela dans la semaine.
Messages postés
52
Date d'inscription
samedi 20 octobre 2007
Statut
Membre
Dernière intervention
7 mars 2010

#include
#include <fstream>
#include <string>
#include <sstream>

class Personne
{
  friend std::ostream& operator<<(std::ostream& out, Personne* v);   // objet de type ostream pour ecrire dans un fichier
  friend std::istream& operator>>(std::istream& in, Personne* v);    // objet de type istream pour lire un fichier

public:
  Personne(const std::string& nom, const std::string& prenom, const std::string& telephone);

  virtual void affiche() const;
  virtual int getSalaire() const = 0;
  virtual Personne* getSuivant() const;
  virtual const std::string& Personne::getNom() const;
  virtual void setSuivant(Personne* suivant);
  virtual void print(std::ostream& o) const;
  virtual const std::string Personne::getInformations() const = 0;

protected:
  std::string _nom;
  std::string _prenom;
  std::string _telephone;
  Personne* _pSuivant;
};

class Entreprise
{
public :
  Entreprise();
  virtual ~Entreprise();

  void ajouter(Personne *pEle);
  void afficheTout();
  void enregistrer();
  void recuperer();
  void supprimer(Personne *pEle);

private :
  Personne* _pPremier;
  Personne* _pCourant;
};

class Externe : public Personne
{
public:
  Externe(const std::string& nom, const std::string& prenom, const std::string& telephone, int fax);
  virtual void affiche() const;
  virtual int getSalaire() const;
  virtual const std::string getInformations() const;
  virtual void print(std::ostream& o) const;

protected:
  int _fax;
};

class Interne : public Personne
{
public:
  Interne(const std::string& nom, const std::string& prenom, const std::string& telephone, int matricule);
  virtual void affiche() const;
  virtual int getSalaire() const;
  virtual const std::string getInformations() const;
  virtual void print(std::ostream& o) const;

protected:
  int _matricule;
};

Personne::Personne(const std::string& nom, const std::string& prenom, const std::string& telephone)
  : _nom(nom), _prenom(prenom), _telephone(telephone), _pSuivant(0)
{
}

Externe::Externe(const std::string& nom, const std::string& prenom, const std::string& telephone, int fax)
  : Personne(nom, prenom, telephone), _fax(fax)
{
}

Interne::Interne(const std::string& nom, const std::string& prenom, const std::string& telephone, int matricule)
  : Personne(nom, prenom, telephone), _matricule(matricule)
{
}

void Personne::affiche() const
{
  // affiche le contenu avec alignement a gauche
  std::cout.setf(std::ios::left, std::ios::adjustfield);
  std::cout << " Nom : ";
  // width permet de definir le nombre de caractere maxi
  std::cout.width(10);
  std::cout << _nom;
  std::cout << " Prenom : ";
  std::cout.width(10);
  std::cout << _prenom;
  std::cout << " Telephone : ";
  std::cout.width(10);
  std::cout << _telephone;
}

void Externe::affiche() const
{
  Personne::affiche();
  std::cout << " Fax : ";
  std::cout << _fax << std::endl;
}

void Interne::affiche() const
{
  Personne::affiche();
  std::cout << " Matricule : ";
  std::cout << _matricule << std::endl;
}

const std::string Personne::getInformations() const
{
   std::stringstream ss;
   ss << _nom << " : " << _prenom << " : " << _telephone;
   return ss.str();
}

const std::string Externe::getInformations() const
{
   std::stringstream ss;
   ss << Personne::getInformations() << " : " << _fax << " ; " << std::endl;
   return ss.str();
}

const std::string Interne::getInformations() const
{
   std::stringstream ss;
   ss << Personne::getInformations() << " : " << _matricule << " ; " << std::endl;
   return ss.str();
}

int Externe::getSalaire() const
{
  return 2500;
}

int Interne::getSalaire() const
{
  return 1200;
}

Personne* Personne::getSuivant() const
{
  return _pSuivant;
}

const std::string& Personne::getNom() const
{
  return _nom;
}

void Personne::setSuivant(Personne* suivant)
{
  _pSuivant = suivant;
}

void Personne::print(std::ostream& out) const
{
  out << _nom << ':';
  out << _prenom << ':';
  out << _telephone << ':';
}

void Externe::print(std::ostream& out) const
{
  out << _fax <<  std::endl;
}

void Interne::print(std::ostream& out) const
{
  out << _matricule << std::endl;
}

Entreprise::Entreprise() : _pPremier(0), _pCourant(0)
{
  recuperer();
}

void Entreprise::supprimer(Personne* pEle)
{
    *_pPremier = *pEle;
    _pCourant = 0;
    std::string name;

    std::ofstream Fichier("Entreprise.txt");

    if (Fichier.eof())
        std::cout << "La liste est vide!\n";
    else
    {
        while (_pPremier->getNom() == name && _pPremier->getSuivant() != NULL)
        {
            _pCourant = _pPremier;
            _pPremier = _pPremier->getSuivant();
        }

        if (_pPremier->getNom() != name)
        {
            if (_pCourant == 0)
            {
                _pPremier = (*pEle).getSuivant();
                delete(pEle);
                pEle = _pPremier;
            }
            else
            {
                _pCourant->setSuivant(_pPremier->getSuivant());
                delete(_pPremier);
            }

            std::cout << "Fiche " << name << " effac,e avec succŠs!\n";
        }
        else
            std::cout << "\nErreur: Personne" << name << " non trouv,e!\n";
    }
}

void Entreprise::enregistrer()
{
  //destrcution du fichier Entreprise.txt
  remove("Entreprise.txt");
  // ouverture en ecriture grace a la creation de l'objet ofstream
  std::ofstream fichier("Entreprise.txt");
  // test d'ouverture du fichier
  if (!fichier)
    return;

  Personne* pTemp = 0;// pointeur vers l'objet Personne
  pTemp = _pPremier;

  while (pTemp)     // boucle qui permet de parcourir la liste chainee afin de sauvegarder chaque objet de cette liste
  {
    fichier << (pTemp->getInformations());
    pTemp = pTemp->getSuivant();
  }
}

void Entreprise::recuperer()
{
  //création de l'objet ifstream pour lire le fichier
  std::ifstream fichier("Entreprise.txt");

  if (!fichier)
    return;
}

void Entreprise::ajouter(Personne *pEle)
{
  if (_pPremier == 0)
  {
    //initialisation des pointeurs grace a l'objet
    _pPremier = pEle;
    _pCourant = pEle;
  }
  else
  {
    _pCourant->setSuivant(pEle);
    _pCourant = _pCourant->getSuivant();
  }
}

void Entreprise::afficheTout()
{
  Personne *pTemp;
  pTemp = _pPremier;

  while (pTemp)
  {
    pTemp->affiche();
    pTemp = pTemp->getSuivant();
  }
}

std::ostream& operator<< (std::ostream& out, Personne* v)
{
  v->print(out);

  return out;
}

std::istream& operator>> (std::istream& in, Personne* v)
{
  // Recuperation des donnees du Fichier
  // (voir fonction recuperer()) jusqu'au caractere ':'
  std::getline(in, v->_nom, ':');
  std::getline(in, v->_prenom, ':');
  std::getline(in, v->_telephone, ':');

  return in;
}

Entreprise::~Entreprise()
{
  // appel de la fonction Enregistrer avant appel du destructeur
  enregistrer();
  delete _pPremier;
}

Personne* saisirPersonne()
{
  bool continuer = true;
  int choix;
  Personne *pEle = 0;
  std::string nom;
  std::string prenom;
  std::string telephone;
  int matricule = 0;
  int fax = 0;

  while (continuer)
  {
    std::cout << " Nom : ";
    std::getline(std::cin, nom);
    std::cout << std::endl << " Prenom : ";
    std::getline(std::cin, prenom);
    std::cout << std::endl << " Telephone : ";
    std::getline(std::cin, telephone);
    std::cout << "Vous etes interne a l'entreprise, taper 1" << std::endl
          << "Vous etes externe a l'entreprise, taper 2" << std::endl
          << "Votre choix : ";
    std::cin >> choix;

    switch (choix)
    {
      case 1:
    std::cout << std::endl << "Matricule : ";
    std::cin >> matricule;
    pEle = new Interne(nom, prenom, telephone, matricule);
    continuer = false;
    break;
      case 2:
    std::cout << std::endl << "Fax : ";
    std::cin >> fax;
    pEle = new Externe(nom, prenom, telephone, fax);
    continuer = false;
    break;
      default:
    std::cerr << "Erreur choix invalide, recommencez" << std::endl;
    }
  }

  return pEle;
}

Personne* supprimerPersonne()
{
    std::string name;
    std::cout << " Nom de l'Personne a supprimer : ";
    std::getline(std::cin, name);
}

void menu()
{
  Entreprise cours;
  int option = 0;
  bool continuer = true;

  while (continuer)
  {
    std::cout << "\nChoisissez une option de menu \n";
    std::cout << "1-Creation d'une Fiche \n"
                 "2-Afficher Liste \n"
                 "3-Supprimer une Fiche \n"
                 "0-Quitter \n\n"
                 "Votre choix : ";
    std::cin >> option;
    std::cin.ignore();

    switch (option)
    {
      case 1 :
    cours.ajouter(saisirPersonne());
    break;
      case 2 :
    cours.afficheTout();
    break;
      case 3 :
    cours.supprimer(supprimerPersonne());
    break;
      case 0 :
    continuer = false;
    break;
      default :
    std::cerr << std::endl << "Choix invalide\a" << std::endl;
    }
  }
}

int main()
{
  menu();

  return 0;
}

Ça serait super si tu y jetait un coup d'œil avant demain soir, parce que je doit finir cette partie et la montrer jeudi matin.
Merci d'avance.
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
Je vais essayer mais je ne te promets rien.
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
Je t'ai partiellement corrigé ce qu'il fallait. Notamment la partie de délimitation qui te posait problème. Je te laisse le soin de finir les procédures enregistrer() et recuperer(), qui sont bien avancé.

#include
#include <fstream>
#include <string>
#include <sstream>
#include <vector>

std::vector<std::string>
&split(const std::string &s, char delim, std::vector<std::string> &elems)
{
  std::stringstream ss(s);
  std::string item;
  while(std::getline(ss, item, delim))
    elems.push_back(item);

  return elems;
}

std::vector<std::string>
split(const std::string &s, char delim)
{
  std::vector<std::string> elems;
  return split(s, delim, elems);
}

class Personne
{
  friend std::ostream& operator<<(std::ostream& out, Personne* v);   // objet de type ostream pour ecrire dans un fichier
  friend std::istream& operator>>(std::istream& in, Personne* v);    // objet de type istream pour lire un fichier

public:
  Personne(const std::string& nom, const std::string& prenom, const std::string& telephone);

  virtual void affiche() const;
  virtual int getSalaire() const = 0;
  virtual Personne* getSuivant() const;
  virtual const std::string& getNom() const;
  virtual void setSuivant(Personne* suivant);
  virtual void print(std::ostream& o) const;
  virtual const std::string getInformations() const = 0;

protected:
  std::string _nom;
  std::string _prenom;
  std::string _telephone;
  Personne* _pSuivant;
};

class Entreprise
{
public :
  Entreprise();
  virtual ~Entreprise();

  void ajouter(Personne *pEle);
  void afficheTout();
  void enregistrer();
  void recuperer();
  void supprimer(Personne *pEle);

private :
  Personne* _pPremier;
  Personne* _pCourant;
};

class Externe : public Personne
{
public:
  Externe(const std::string& nom, const std::string& prenom, const std::string& telephone, int fax);
  virtual void affiche() const;
  virtual int getSalaire() const;
  virtual const std::string getInformations() const;
  virtual void print(std::ostream& o) const;

protected:
  int _fax;
};

class Interne : public Personne
{
public:
  Interne(const std::string& nom, const std::string& prenom, const std::string& telephone, int matricule);
  virtual void affiche() const;
  virtual int getSalaire() const;
  virtual const std::string getInformations() const;
  virtual void print(std::ostream& o) const;

protected:
  int _matricule;
};

Personne::Personne(const std::string& nom, const std::string& prenom, const std::string& telephone)
  : _nom(nom), _prenom(prenom), _telephone(telephone), _pSuivant(0)
{
}

Externe::Externe(const std::string& nom, const std::string& prenom, const std::string& telephone, int fax)
  : Personne(nom, prenom, telephone), _fax(fax)
{
}

Interne::Interne(const std::string& nom, const std::string& prenom, const std::string& telephone, int matricule)
  : Personne(nom, prenom, telephone), _matricule(matricule)
{
}

void Personne::affiche() const
{
  // affiche le contenu avec alignement a gauche
  std::cout.setf(std::ios::left, std::ios::adjustfield);
  std::cout << " Nom : ";
  // width permet de definir le nombre de caractere maxi
  std::cout.width(10);
  std::cout << _nom;
  std::cout << " Prenom : ";
  std::cout.width(10);
  std::cout << _prenom;
  std::cout << " Telephone : ";
  std::cout.width(10);
  std::cout << _telephone;
}

void Externe::affiche() const
{
  Personne::affiche();
  std::cout << " Fax : ";
  std::cout << _fax << std::endl;
}

void Interne::affiche() const
{
  Personne::affiche();
  std::cout << " Matricule : ";
  std::cout << _matricule << std::endl;
}

const std::string Personne::getInformations() const
{
  std::stringstream ss;
  ss << _nom << " : " << _prenom << " : " << _telephone;
  return ss.str();
}

const std::string Externe::getInformations() const
{
  std::stringstream ss;
  ss << "Externe : " << Personne::getInformations()
     << " : " << _fax << " ; " << std::endl;
  return ss.str();
}

const std::string Interne::getInformations() const
{
  std::stringstream ss;
  ss << "Interne : " << Personne::getInformations()
     << " : " << _matricule << " ; " << std::endl;
  return ss.str();
}

int Externe::getSalaire() const
{
  return 2500;
}

int Interne::getSalaire() const
{
  return 1200;
}

Personne* Personne::getSuivant() const
{
  return _pSuivant;
}

const std::string& Personne::getNom() const
{
  return _nom;
}

void Personne::setSuivant(Personne* suivant)
{
  _pSuivant = suivant;
}

void Personne::print(std::ostream& out) const
{
  out << _nom << ':';
  out << _prenom << ':';
  out << _telephone << ':';
}

void Externe::print(std::ostream& out) const
{
  out << _fax <<  std::endl;
}

void Interne::print(std::ostream& out) const
{
  out << _matricule << std::endl;
}

Entreprise::Entreprise() : _pPremier(0), _pCourant(0)
{
}

void Entreprise::supprimer(Personne* pEle)
{
  *_pPremier = *pEle;
  _pCourant = 0;
  std::string name;

  std::ofstream Fichier("Entreprise.txt");

  if (Fichier.eof())
    std::cout << "La liste est vide!\n";
  else
  {
    while (_pPremier->getNom() == name && _pPremier->getSuivant() != NULL)
    {
      _pCourant = _pPremier;
      _pPremier = _pPremier->getSuivant();
    }

    if (_pPremier->getNom() != name)
    {
      if (_pCourant == 0)
      {
    _pPremier = (*pEle).getSuivant();
    delete(pEle);
    pEle = _pPremier;
      }
      else
      {
    _pCourant->setSuivant(_pPremier->getSuivant());
    delete(_pPremier);
      }

      std::cout << "Fiche " << name << " effac,e avec succ�1B;%GŠ�1B;%@s!\n";
    }
    else
      std::cout << "\nErreur: Personne" << name << " non trouv,e!\n";
  }
}

void Entreprise::enregistrer()
{
  remove("Entreprise.txt");
  std::ofstream fichier("Entreprise.txt");
  if (!fichier)
    return;

  Personne* pTemp = 0;
  pTemp = _pPremier;

  while (pTemp)
  {
    fichier << (pTemp->getInformations());
    pTemp = pTemp->getSuivant();
  }
  fichier.close();
}

void Entreprise::recuperer()
{
  std::ifstream fichier("Entreprise.txt");

  if (!fichier)
    return;

  std::string line;
  while (std::getline(fichier, line))
  {
    const std::vector<std::string>& tmp = split(line, ':');
    typedef std::vector<std::string>::const_iterator iter;
    for (iter it = tmp.begin(); it != tmp.end(); ++it)
    {
      std::cout << *it << " | ";
    }
    std::cout << std::endl;
  }
}

void Entreprise::ajouter(Personne *pEle)
{
  if (_pPremier == 0)
  {
    //initialisation des pointeurs grace a l'objet
    _pPremier = pEle;
    _pCourant = pEle;
  }
  else
  {
    _pCourant->setSuivant(pEle);
    _pCourant = _pCourant->getSuivant();
  }
}

void Entreprise::afficheTout()
{
  Personne *pTemp;
  pTemp = _pPremier;

  while (pTemp)
  {
    pTemp->affiche();
    pTemp = pTemp->getSuivant();
  }
}

std::ostream& operator<< (std::ostream& out, Personne* v)
{
  v->print(out);

  return out;
}

std::istream& operator>> (std::istream& in, Personne* v)
{
  // Recuperation des donnees du Fichier
  // (voir fonction recuperer()) jusqu'au caractere ':'
  std::getline(in, v->_nom, ':');
  std::getline(in, v->_prenom, ':');
  std::getline(in, v->_telephone, ':');

  return in;
}

Entreprise::~Entreprise()
{
  // appel de la fonction Enregistrer avant appel du destructeur
  enregistrer();
  delete _pPremier;
}

Personne* saisirPersonne()
{
  bool continuer = true;
  int choix;
  Personne *pEle = 0;
  std::string nom;
  std::string prenom;
  std::string telephone;
  int matricule = 0;
  int fax = 0;

  while (continuer)
  {
    std::cout << " Nom : ";
    std::getline(std::cin, nom);
    std::cout << std::endl << " Prenom : ";
    std::getline(std::cin, prenom);
    std::cout << std::endl << " Telephone : ";
    std::getline(std::cin, telephone);
    std::cout << "Vous etes interne a l'entreprise, taper 1" << std::endl
          << "Vous etes externe a l'entreprise, taper 2" << std::endl
          << "Votre choix : ";
    std::cin >> choix;

    switch (choix)
    {
      case 1:
    std::cout << std::endl << "Matricule : ";
    std::cin >> matricule;
    pEle = new Interne(nom, prenom, telephone, matricule);
    continuer = false;
    break;
      case 2:
    std::cout << std::endl << "Fax : ";
    std::cin >> fax;
    pEle = new Externe(nom, prenom, telephone, fax);
    continuer = false;
    break;
      default:
    std::cerr << "Erreur choix invalide, recommencez" << std::endl;
    }
  }

  return pEle;
}

Personne* supprimerPersonne()
{
  std::string name;
  std::cout << " Nom de l'Personne a supprimer : ";
  std::getline(std::cin, name);
}

void menu()
{
  Entreprise cours;
  int option = 0;
  bool continuer = true;

  while (continuer)
  {
    std::cout << "\nChoisissez une option de menu \n";
    std::cout << "1-Creation d'une Fiche \n"
      "2-Afficher Liste \n"
      "3-Supprimer une Fiche \n"
      "4-Enregistrer dans un fichier \n"
      "5-Charger depuis un fichier \n"
      "0-Quitter \n\n"
      "Votre choix : ";
    std::cin >> option;
    std::cin.ignore();

    switch (option)
    {
      case 1:
    cours.ajouter(saisirPersonne());
    break;
      case 2:
    cours.afficheTout();
    break;
      case 3:
    cours.supprimer(supprimerPersonne());
    break;
      case 4:
    cours.enregistrer();
    break;
      case 5:
    cours.recuperer();
    break;
      case 0:
    continuer = false;
    break;
      default :
    std::cerr << std::endl << "Choix invalide\a" << std::endl;
    }
  }
}

int main()
{
  menu();

  return 0;
}
Messages postés
52
Date d'inscription
samedi 20 octobre 2007
Statut
Membre
Dernière intervention
7 mars 2010

Merci de m'avoir répondu ce soir. Mais je n'arrive toujours pas a ouvrir le fichier créer avec "afficher la liste" alors que c'est ce que je veut.
Les méthodes récupérer et enregistrer était pour moi les méthodes pour trouver une personne afin de la supprimer et celle pour enregistrer une personne(Fiche) dans le fichier.
Messages postés
52
Date d'inscription
samedi 20 octobre 2007
Statut
Membre
Dernière intervention
7 mars 2010

J'ai rien dit, j'avais mal vu.
MERCI ENCORE POUR TOUS
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
N'appelle pas l'enregistrement de la liste dans la constructeur, et sa sauvegarde dans le destructeur. Fais le explicitement avec des options prévues à cet effet. C'est ce que j'ai rajouté dans le menu.
Retire le enregistrer dans le destructeur.
Ensuite, tu as tout ce qu'il te faut pour réaliser une sauvegarde et une chargement.
Messages postés
52
Date d'inscription
samedi 20 octobre 2007
Statut
Membre
Dernière intervention
7 mars 2010

Mais pourquoi "afficher la liste" ne m'affiche rien une fois le fichier saisie, car il a la méthode affiche qui affiche bien le nom, prénom, ....
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
Comme je te l'ai dit, je n'ai pas terminé la fonction, à toi de le faire.

recuperer() ne fait que lire le fichier, spliter les phrases, et les affiche.
Il te reste à retirer la phrase temporaire de debug, et à créer les Personnes au fur et à mesure.
Messages postés
52
Date d'inscription
samedi 20 octobre 2007
Statut
Membre
Dernière intervention
7 mars 2010

OK. Et le problème au niveau de supprimer() tu sais de quoi il vient.
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
Dans la fonction supprimer(), tu ne touches pas au fichier. C'est à l'utilisateur de choisir de le sauvegarder. Tu ne supprimes un utilisateur qu'au niveau de la mémoire.
Messages postés
52
Date d'inscription
samedi 20 octobre 2007
Statut
Membre
Dernière intervention
7 mars 2010

Je suis d'accord, mais si on supprimer un utilisateur au niveau de la mémoire, il devrait pour le faire alors que la il me mets une erreur mémoire.Je comprends pas !
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
La fonction supprimerPersonne()  ne retourne rien. Donc pEle est nulle. D'où ton erreur.
J'aurais écrit ceci, mais je ne l'ai pas du tout testé, donc je ne te garantie rien.
La fonction supprimerPersonne devrait retourner un std::string du nom de la personne à chercher.
Puis tu devrais ajouter une fonction qui à partir d'un std::string, retourne une "Personne*", si elle existe.

void Entreprise::supprimer(Personne* pEle)
{
  // Erreur normalement impossible
  if (pEle == 0)
    return;

  // La liste est vide
  if (_pPremier == 0)
    return;

  // Si c'est le premier
  if (_pPremier->getNom() == pEle->getNom())
  {
    Personne* tmp = _pPremier;
    delete tmp;
    _pPremier = _pPremier->getSuivant();
    return;
  }

  // Recherche de l'élément à supprimer
  while (_pPremier->getSuivant() != 0 &&
     _pPremier->getSuivant()->getNom() != pEle->getNom())
    _pPremier = _pPremier->getSuivant();

  // Rien trouvé à supprimer
  if (_pPremier->getSuivant() == 0)
    return;

  Personne* tmp = _pPremier->getSuivant();
  _pPremier = _pPremier->getSuivant()->getSuivant();
  delete tmp;
}

Je vais me coucher, donc bonne chance pour la suite.