Besoin d'aide pour utilisation de tableaux d'objets [Débutant(e)]

**Tagazouh** · 02/04/2012, 23h54

Bonjour,

Je viens vous demander de l’aide, car j’essaie de faire un « programme », mais je n’arrive pas à le compiler…
Je pense que ça se voit, mais je suis un grand débutant en programmation, donc s’il vous plait, soyez indulgents.

Voilà comment il se présente : Je cherche à organiser une fête de fon d’étude, et je dois gérer les inscriptions.
J’ai une classe (virtuelle pure) PersonneInscrite, qui définit le nom, prénom, téléphone… d’une personne qui souhaite s’inscrite ;
Une classe Diplôme qui est une fille de la classe PersonneInscrite (j’ai 2 autres classes filles de PersonneInscrite, mais pour le moment je ne m’en occupe pas) ;
Et une classe Invite qui a une relation avec la classe PersonneInscrite telle que : une PersonneInscrite peur avoir jusqu’à 3 Invités, mais un Invité ne dépend que d’une PersonneInscite (je ne sais pas comment s’appelle ce type de classe, elle est comme un « outil » pour PersonneInscrite… ?).

Voilà mon problème : Un diplôme peut avoir jusqu’à 3 Invite, je cherche donc à stocker ces invités dans un tableau à 3 cases, pour pouvoir les retrouver plus tard.

Voila ma classe Invite

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class Invite
{
    public:
        Invite();
        Invite(std::string nom, std::string prenom);
        virtual ~Invite();
 
        void setNom(std::string nom);
        void setPrenom(std::string prenom);
    private:
        std::string nom;
        std::string prenom;
};

Fichier.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include "Invite.h"
 
using namespace std;
 
/*************************** CONSTRUCTEURS ***************************/
 
Invite::Invite()
{
    //ctor
    cout << "Constructeur default : Invité crée" << endl;
}
 
Invite::Invite(string _nom,
               string _prenom)
{
    nom = _nom;
    prenom = _prenom;
 
    cout << "Constructeur surchargé : Invité crée" << endl;
}
 
Invite::~Invite()
{
    //dtor
    cout << "Destructeur Invité" << endl;
}
 
/*************************** METHODES ***************************/
 
void Invite::setNom(std::string inom)
{
    nom=inom;
    cout << "Nom invité modif" << endl;
}
 
void Invite::setPrenom(std::string iprenom)
{
    prenom=iprenom;
    cout << "Prenom invité modif" << endl;
}

Et voici mon main :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
#include <string>
#include "include/PersonneInscrite.h"
#include "include/Diplome.h"
#include "include/Invite.h"
 
using namespace std;
 
 
int main()
{
    Diplome b("sauvage", "gaston", "1234567890", "gsauvage@gogl.com", "2009", "26", "03", "2012");
 
    b.invitation("Green", "Rachel");
    return 0;
 
}

Et donc, voilà donc ma classe Diplôme :
Fichier.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class Diplome : public PersonneInscrite
{
    public:
        Diplome();
        Diplome(std::string nom, std::string prenom, std::string telephone, std::string email, std::string promotion, std::string jour, std::string mois, std::string annee);
        virtual ~Diplome();
        void invitation(std::string inom, std::string iprenom);
 
    private:
        int promotion;
        Invite inviteDiplome[3];
};

Fichier.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include "Diplome.h"
using namespace std;
 
/*************************** CONSTRUCTEURS ***************************/
 
Diplome::Diplome() : PersonneInscrite()
{
    type = "Diplômé(e)";
    tarif = tarif_diplome;
    cout << "Constructeur default : Diplomé crée" << endl;
}
 
Diplome::Diplome(string nom,  string prenom, string telephone,  string email,  string _promotion, string jour, string mois, string annee):  PersonneInscrite(nom, prenom, telephone, email, tarif, jour, mois, annee)
{
    promotion = _promotion;
    type = "Diplômé(e)";
    tarif = tarif_diplome;
    cout << "Constructeur surchargé : Diplomé crée" << endl;
}
Diplome::~Diplome()
{
    cout << "Destructeur Diplomé" << endl;
}
 
 
/*************************** METHODES ***************************/
 
void Diplome::invitation(string inom, string iprenom)
{
    Invite tmp = Invite(inom, iprenom);
    inviteDiplome[1]=tmp;
    cout << inviteDiplome[1] << endl;
}

Donc voilà, j’ai voulu faire un test pour voir si cette méthode marchait en n'invitant qu'une personne et en affichant le résultat avec un cout << ; mais le compilateur me donne l’erreur suivante :

error: no match for 'operator<<' in 'std::cout << ((Diplome*)this)->Diplome::inviteDiplome[1]'

Donc si je comprends bien, je dois surcharger l’opérateur de flux, mais où le faire (dans quelle classe)?
De plus, quand je souhaite tester si une case du tableau inviteDiplome est vide (avec inviteDiplome[i]==NULL), j'ai aussi un problème avec les opérateurs, mais lequel faut-il surcharger, l’opérateur [] ou == ?

Et dernière question, est-ce la bonne méthode

?

Je vous remercie par avance pour l’aide que vous pourrez m’apporter.
A bientôt!

(j'ai un peut de mal à m'expliquer... donc si vous avez des questions, n'hésitez pas!)

**gbdivers** · 03/04/2012, 00h32

Bonsoir

Réponse courte, il est tard.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

virtual ~Invite();

Une raison pour virtual ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Diplome(std::string nom, std::string prenom, std::string telephone, std::string email, std::string promotion, std::string jour, std::string mois, std::string annee);

ça fait beaucoup d'arguments...
Pourquoi les dates en string et pas en chiffre ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Invite inviteDiplome[3];

Toujours 3 invités, ni plus, ni moins ?

Donc si je comprends bien, je dois surcharger l’opérateur de flux, mais où le faire (dans quelle classe)?

FAQ : http://cpp.developpez.com/faq/cpp/?p..._polymorphique

De plus, quand je souhaite tester si une case du tableau inviteDiplome est vide (avec inviteDiplome[i]==NULL)

Attention, inviteDiplome[i] ne sera jamais null, puisque inviteDiplome[i] n'est pas un pointeur. Par contre, inviteDiplome peut être un pointeur.
Prend peut être l'habitude d'utiliser nullptr (et d'utiliser du coup le C++11, qui n'est pas une extension du C++ mais le standard C++ actuel)
Si tu as répondu aux questions précédentes, celle ci ne se posera plus

j'ai aussi un problème avec les opérateurs, mais lequel faut-il surcharger, l’opérateur [] ou == ?

Je vois pas le rapport avec la surcharge d'opérateur ici
La surcharge d'opérateur n'est pas destiné à modifier le role d'un opérateur mais prendre en charge de nouveaux types

Et dernière question, est-ce la bonne méthode ?

Pour le surcharge de << oui, pour la surcharge de [] et == je crois pas

**Tagazouh** · 03/04/2012, 16h03

Bonjour,
Tout d'abord merci à tous, j'arrive à afficher les cases de mon tableau!! J'ai préféré utiliser la surcharge des opérateurs car je ne l'avais jamais faite, mais je retient la solution par fonction ^^.

Envoyé par gbdivers

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

virtual ~Invite();

Une raison pour virtual ?

Effectivement ça ne va pas servir à grand chose, mais c'est codeblocks qui l'ajoute automatiquement.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Diplome(std::string nom, std::string prenom, std::string telephone, std::string email, std::string promotion, std::string jour, std::string mois, std::string annee);

ça fait beaucoup d'arguments...
Pourquoi les dates en string et pas en chiffre ?

Déjà, à la base j'aurais voulu récupérer la date automatiquement depuis l'ordinateur, mais j'ai pas réussi à le faire...
Ici ce sont des string, car avec les int il y a un problème: si par exemple l'utilisateur entre la date 08/09/12, le programme plante car quand il voit un 8 ou 9 suivant un 0, il le prend pour un changement de base (octale...)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Invite inviteDiplome[3];

Toujours 3 invités, ni plus, ni moins ?

Et bien normalement un Diplome peut avoir maximum 3 Invite, donc il doit pouvoir en avoir aussi bien 0 que 2!

Du coup avec la surcharge d'opérateur <<, je peux vérifier que mon invité a bien été enregistré;
mais maintenant j'aimerai rajouter un «test» pour savoir si la personne a déjà des invités ou pas, pour rajouter de nouveaux invités sans effacer les précédents (car un Diplome peut ajouter des invites n'importe quand).
Si j'ai bien compris, je vais devoir utiliser les pointeurs …

? Ça non plus je ne sais pas trop le faire
Voila ce que je pensais faire:
Diplome.h:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Private:
Invite* inviteDiplome[3]

Diplome.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include "Diplome.h"
using namespace std;
 
/*************************** CONSTRUCTEURS ***************************/
 
Diplome::Diplome() : PersonneInscrite()
{
    type = "Diplômé(e)";
    tarif = tarif_diplome;
    cout << "Constructeur default : Diplomé crée" << endl;
	*inviteDiplome[3]=NULL;//ajout
}
 
Diplome::Diplome(string nom,  string prenom, string telephone,  string email,  string _promotion, string jour, string mois, string annee):  PersonneInscrite(nom, prenom, telephone, email, tarif, jour, mois, annee)
{
    promotion = _promotion;
    type = "Diplômé(e)";
    tarif = tarif_diplome;
    cout << "Constructeur surchargé : Diplomé crée" << endl;
	*inviteDiplome[3]=NULL;//ajout
}
Diplome::~Diplome()
{
    cout << "Destructeur Diplomé" << endl;
}
*
*
/*************************** METHODES ***************************/
*
void Diplome::invitation(string inom, string iprenom)
{
    Invite tmp = Invite(inom, iprenom);
 
    for (int i=0; i<3; i++)
    {
        if(inviteDiplome[i]!=NULL)
	{
        cout << "il y a deja " << i+1 << " invité(s)" << endl;
        cout << inviteDiplome[i] << endl;
	}
        else
        {
            inviteDiplome[i]=&tmp;
            cout << "Nouvel invité : " << endl;
            cout << inviteDiplome[i] << endl;
        }
    }
}

Mais là, ça ne marche plus … Je pense que c'est à cause de l'initialisation, mais je n'ai pas trouvé, pourtant j'essaie de faire comme on me l'a expliqué en cours...

int a = 2;
char b;
int *p1;
char *p2;
p1 = &a;
p2 = &b;

Encore merci d'avance,
A bientôt

**gbdivers** · 03/04/2012, 17h05

Bonjour

Bon, cob59 à vendu la mèche pour le vector, je voulais te laisser chercher un peu (c'est mieux pour apprendre).

Effectivement ça ne va pas servir à grand chose, mais c'est codeblocks qui l'ajoute automatiquement.

C'est pas une erreur. C'est inutile dans cette situation. Par contre, ça peut être une erreur de ne pas le mettre dans d'autres situations. Ça doit être pour ça que C::B le met par défaut.
En fait, le destructeur virtuel est obligatoire si tu as au moins 1 fonction virtuelle dans ta classe. Pour l'explication détaillée, voir la FAQ : Pourquoi et quand faut-il créer un destructeur virtuel ?

Déjà, à la base j'aurais voulu récupérer la date automatiquement depuis l'ordinateur, mais j'ai pas réussi à le faire...

Encore la FAQ : Comment gérer les dates et les heures en C++ ?
Je te conseille l'utilisation d'une bibliothèque pour cela (j'utilise boost ou Qt)

Ici ce sont des string, car avec les int il y a un problème: si par exemple l'utilisateur entre la date 08/09/12, le programme plante car quand il voit un 8 ou 9 suivant un 0, il le prend pour un changement de base (octale...)

Il y a un problème uniquement si les date sont écrites directement dans le code. Or, on s'attend pas vraiment que sur le programme final, les dates soient codées en dur dans le code, non ?
Le plus simple est d'avoir un classe dédié pour la gestion des dates (c'est un grand classique en C++, donc beaucoup de libs propose cette classe et elle est souvent nommée data_time) avec une fonction fromString(). Du coup tu écris la date avec une chaîne de caractères (donc plus de problème d'erreur de base) et la classe gère en interne avec des entiers (pour les calculs, c'est mieux)
Encore mieux, tu utilises une libs comme indiqué dans la FAQ. Ou encore mieux si tu débutes : tu écris ta propres classes date_time pour t'exercer puis tu l'oublies pour utiliser boost.date_time

Et bien normalement un Diplome peut avoir maximum 3 Invite, donc il doit pouvoir en avoir aussi bien 0 que 2!

Là tu imposes qu'il en ait 3. Donc les variables Invite seront allouées et prendront de la mémoire pour rien. De plus, tu dois gérer du coup quand une variable représente quelque chose ou non. Et ça peut rapidement poser des problèmes. Imagine si quelqu'un inscrit 3 personnes puis annule la première de la liste. Il faut faire quoi ? Laisser le "blanc" en début de tableau ? Déplacer les 2 derniers invités pour mettre le "blanc" à la fin ? etc.
Donc le plus simple est d'utiliser un conteneur de la STL, qui te fournira la fonction size(). Tu ajoutes simplement un test dans ta fonction addInvite() pour vérifier que tu n'as pas plus de 3 invités et c'est bon

Faut-il utiliser un vector ? Pas forcement. Tu peux préféré une list (plus optimisé pour les ajouts/suppression) ou une map (plus optimisé pour les recherches avec une clé) (*)

Voila ce que je pensais faire:

Mauvaises idées. Première erreur, tu utilises des pointeurs nus qui t'oblige à gérer la mémoire manuellement. Utilise des shared_ptr ou unique_ptr (du C++11 si tu as un compilateur correcte, sinon boost). Seconde erreur, tu continues d'utiliser un tableau de taille fixe
Du coup, tu récupères pleins d'erreurs. Et c'est du travail inutile de gérer ça manuellement alors que le C++ propose des outils pour simplifier la vie (et gagner en productivité, c'est ce qu'on demande dans un cadre pro)

Bref, un simple std::list<Invité> et c'est bon. Pour parcourir ta liste, tu passes par les itérateurs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for (std::list<Invite>::iterator it = l.begin(); it != l.end(); )
{
    // *it pour accéder
}

(*) Pour aller plus loin...
Pour le moment, commence avec le code précédant et fait en sorte que ça fonctionne. Par contre, tu vois que l'on est vite en face d'un problème : comment rechercher qu'un invité n'est pas déjà invité par quelqu'un d'autre ?

En fait, la solution est relativement simple : il suffit de créer une liste d'invités ! Cette liste se chargera d'éviter les doublons. Et cette responsabilité est suffisante pour créer un classe spécifique.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class InviteList {
   // fonctions à proposer :
      // ajouter un invité
      // vérifier qu'un invité est présent ou non
      // supprimer un invité
      // optionnel : afficher la liste des invités
};

Comme cette classe et elle seule aura la responsabilité de gérer (création et destruction) les objets de type Invite, on est face à un gestionnaire unique : tu peux utiliser unique_ptr (http://loic-joly.developpez.com/tuto...inters/#LIII-C)
Tu auras donc une liste d'invité dans InviteList avec un responsabilité unique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
class InviteList {
private:
    list< unique_ptr< Invite > > invites;
};

La classe Diplome pourra manipuler directement des pointeurs nus, puisque tu es sur que la mémoire est déjà géré dans InviteList, donc sans risque :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
class Diplome {
   // fonctions à proposer :
      // ajouter un invité si moins de 3 invités 
         //en 3 étapes : vérifier dans InviteList s'il existe, le créer si nécessaire
         // et l'ajouter à sa liste personnelle
      // supprimer un invité
private:
    list< Invite* > invites;
};

Pour récupérer un pointeur nu à partir d'un unique_ptr, tu utilises la fonction get()

**Tagazouh** · 04/04/2012, 12h05

Bonjour,

Je te remercie, car tu m'aide beaucoup avec tout ca! Je n'ai pas encore tout regardé, mais je pense que ca va m'éviter pas mal de problèmes (surtout pour la date!)

Effectivement, il y a les vecteurs! Je pensais que l'utilisation de tableaux «normaux» serait plus facile,... mais en fait non ^^
Alors voilà les nouvelles méthodes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
//permet d'ajouter des invités
void Diplome::invitation(string inom, string iprenom)
{
    Invite tmp = Invite(inom, iprenom);
 
    if(inviteDiplome.size()<nbInviteDiplome)
        {
            inviteDiplome.push_back(tmp);
            cout << "Invitation réussie !" << endl;
        }
    else
        cout << "Vous avez déjà 3 invités, vous ne pouvez pas en ajouter une de plus !" << endl;
}
 
//pour dé-sinviter un invité
void Diplome::desinvitation()
{
    int answer=0;
    if(inviteDiplome.size()==0)
        cout << "\nVous n'avez invité personne." << endl;
    else
    {
        afficheInvites();
        cout << "\nEntrez le numero de la personne à supprimer : ";
        cin >> answer;
 
        while(answer<=0 | answer>inviteDiplome.size())
        {
            cout << "\nMauvaise saisie, veillez recommencer, svp : ";
            cin >> answer;
        }
        list<Invite>::iterator it = inviteDiplome.begin();
        inviteDiplome.erase(it +answer);
    }
}
 
//affiche les nom des invités
void Diplome::afficheInvites()
{
    int i=0;
 
    if(inviteDiplome.size()==0)
        cout << "\nVous n'avez invité personne." << endl;
    else
    {
        cout << "\nVous avez un/des invité(s) :" << endl;
        for(list<Invite>::iterator it = inviteDiplome.begin(); it!=inviteDiplome.end(); it++)
        {
            i++;
            cout << i << " - " << *it << " ;" << endl;
        }
    }
}
 
//compte le nombre d'invités par Diplome
int Diplome::getNbInvite()
{
    int nombreInvite=0;
    if (inviteDiplome.empty())
        return 0;
    else
    {
        nombreInvite=inviteDiplome.size();
        return nombreInvite;
    }
}

Tout marche, sauf la méthode desinvitation, le compilateur me dit qu'il y a une erreur d' operator+ quand j'essaie de faire inviteDiplome.begin() +answer pour donner la position dans la liste de l'objet à supprimer. J'avais un problème similaire pour la méthode afficheInvites() pour obtenir la position des Invite, mais je l'ai contourné avec l'ajout de i comme compteur.
Je ne vois pas trop ce qui bloque, j'ai regardé sur internet et pourtant j'ai fais la même chose que ce que j'ai vu …

Et puis, effectivement ce sera très utile de faire une liste pour vérifier les doublons, compter le nombre d'invités..., là tu m’enlève une épine du pied (même si je vais devoir toucher aux pointeurs :$). Je n'ai pas encore trop regardé comment faire, mais je m'y mets.

Encore merci d'avance,
A bientôt

**gbdivers** · 04/04/2012, 12h26

Tu devrais regarder la doc pour bien comprendre la différence entre list et vector. vector est un tableau ~~séquentiel~~ contigu (EDIT : erreur de vocabulaire, merci koala01), on peut y accéder avec [] et begin() + n à un sens (les éléments se suivent en mémoire). Par contre, list est une liste chaînée donc les éléments ne se suivent pas.
Pour faire la même chose, il suffit d'utiliser la fonction advance :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

inviteDiplome.erase( advance(inviteDiplome.begin(), answer) );

En fait, je te conseille de toujours utiliser advance pour avancer de n éléments, que ce soit pour une list ou vector. En effet, advance est optimisé pour choisir la meilleure méthode : +n dans le cas d'un vector et faire n fois ++ dans la cas d'une liste. Cela permet de rendre ton code indépendant du conteneur que tu utlises (alors que si tu utilises begin() + n, comme tu l'as vu, ça peut planter si tu choisis de changer de conteneur)

Bon courage

**cob59** · 03/04/2012, 01h28

Donc si je comprends bien, je dois surcharger l’opérateur de flux, mais où le faire (dans quelle classe)?

Après la définition de classe de Invité.
Plus simplement, il suffirait d'ajouter une méthode std::string toString() const { return nom + " " + prenom; } à Invité et d'afficher l'objet avec std::cout << inviteDiplome[1].toString() << std::endl.

De plus, quand je souhaite tester si une case du tableau inviteDiplome est vide (avec inviteDiplome[i]==NULL)

C'est un problème à lier au fait que inviteDiplome est un tableau statique, et aura donc une cardinalité fixe. Tu devrais utiliser un tableau dynamique std::vector<Invite> à la place.

**Bousk** · 03/04/2012, 09h35

Envoyé par cob59

C'est un problème à lier au fait que inviteDiplome est un tableau statique, et aura donc une cardinalité fixe. Tu devrais utiliser un tableau dynamique std::vector<Invite> à la place.

Attention non, gbdivers l'a bien expliqué :
Invite inviteDiplomes[3] est un tableau de 3 Invite. Il s'agit de 3 objet qui ne peuvent pas être NULL.
Seul un pointeur peut être NULL, et dans ce cas la déclaration serait Invite* inviteDiplomes[3], et à condition de lui assigner la valeur NULL à chaque case, ce qui n'est pas le cas par défaut.

**cob59** · 03/04/2012, 10h02

J'ai dit que inviteDiplomes pouvait contenir des éléments NULL ?

Besoin d'aide pour utilisation de tableaux d'objets [Débutant(e)]

C++

Vue hybride

Discussions similaires

Partager

Partager