Sujet Précédent Sujet Suivant

Creer objet avec classe heritée

cs_jonas03 Messages postés 52 Date d'inscription samedi 20 octobre 2007 Statut Membre Dernière intervention 7 mars 2010 - 20 mai 2009 à 15:26
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 - 11 juin 2009 à 00:16

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;
};

A voir également:

Creer objet avec classe heritée
Un composant activex ne peut pas créer un objet ✓ - Forum Visual Basic 6
Un composant ActiveX ne peut créer un objet GetObject - Forum Visual Basic
Objet requis vba ✓ - Forum Visual Basic 6
La référence d'objet n'est pas définie à une instance d'un objet ✓ - Forum C# / .NET
Recuperation objet wow - Forum Java

35 réponses

Réponse 21 / 35

cs_jonas03 Messages postés 52 Date d'inscription samedi 20 octobre 2007 Statut Membre Dernière intervention 7 mars 2010
9 juin 2009 à 10:10

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)'

Réponse 22 / 35

cs_jonas03 Messages postés 52 Date d'inscription samedi 20 octobre 2007 Statut Membre Dernière intervention 7 mars 2010
9 juin 2009 à 16:44

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

Réponse 23 / 35

cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
9 juin 2009 à 20:13

Copie colle moi ton code, que je puisse t'aider. Je regarderais cela dans la semaine.

Réponse 24 / 35

cs_jonas03 Messages postés 52 Date d'inscription samedi 20 octobre 2007 Statut Membre Dernière intervention 7 mars 2010
9 juin 2009 à 20:28

#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.

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question

Réponse 25 / 35

cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
9 juin 2009 à 20:37

Je vais essayer mais je ne te promets rien.

Réponse 26 / 35

cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
10 juin 2009 à 23:03

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;
}

Réponse 27 / 35

cs_jonas03 Messages postés 52 Date d'inscription samedi 20 octobre 2007 Statut Membre Dernière intervention 7 mars 2010
10 juin 2009 à 23:21

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.

Réponse 28 / 35

cs_jonas03 Messages postés 52 Date d'inscription samedi 20 octobre 2007 Statut Membre Dernière intervention 7 mars 2010
10 juin 2009 à 23:24

J'ai rien dit, j'avais mal vu.
MERCI ENCORE POUR TOUS

Réponse 29 / 35

cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
10 juin 2009 à 23:25

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.

Réponse 30 / 35

cs_jonas03 Messages postés 52 Date d'inscription samedi 20 octobre 2007 Statut Membre Dernière intervention 7 mars 2010
10 juin 2009 à 23:37

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, ....

Réponse 31 / 35

cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
10 juin 2009 à 23:43

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.

Réponse 32 / 35

cs_jonas03 Messages postés 52 Date d'inscription samedi 20 octobre 2007 Statut Membre Dernière intervention 7 mars 2010
10 juin 2009 à 23:48

OK. Et le problème au niveau de supprimer() tu sais de quoi il vient.

Réponse 33 / 35

cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
10 juin 2009 à 23:51

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.

Réponse 34 / 35

cs_jonas03 Messages postés 52 Date d'inscription samedi 20 octobre 2007 Statut Membre Dernière intervention 7 mars 2010
10 juin 2009 à 23:58

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 !

Réponse 35 / 35

cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
11 juin 2009 à 00:16

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.

Discussions similaires

la référence d'objet n'est pas définie à une instance d'un objet

la reference d'objet n'est pas définie a une instance d'un objet

Erreur "La référence d'objet n'est pas définie à une instance d'un objet."

La référence d'objet n'est pas définie à une instance d'un objet.

[erreur] La référence d'objet n'est pas définie à une instance d'un objet.

Votre réponse

Discussions similaires