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

**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 ?

**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

**koala01** · 06/04/2012, 12h13

Salut,

Envoyé par gbdivers

Tu devrais regarder la doc pour bien comprendre la différence entre list et vector. vector est un tableau séquentiel, 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.

Justement, non, vector est un tableau d'élément contigus, permettant un acces "en temps constant" (dit aussi "aléatoire") aux éléments...

Cela implique que tu peux parfaitement accéder à l'élément tab[n] sans que cela ne te prenne plus de temps que d'accéder à l'élément tab[n+1], et ce, quelle que soit la valeur de n (à moins, bien sur, que tu ne décide d'itérer sur chaque élément entre 0 et n)

La liste, par contre, est un conteneur à accès séquentiel: on ne peut accéder au Nième élément qu'à partir de l'élément N-1, ce qui fait que, plus N augmentra, plus nous mettons du temps à y accéder (vu qu'il faudra passer par tous les élément entre 0 et N )

Vocabulaire, quand tu nous tiens

**gbdivers** · 06/04/2012, 12h45

je fatigue... si je ne fais plus la différence entre contigu et séquentiel, je vais aller me coucher je crois (hier, j'ai même bloqué sur heap et stack et je ne savais plus qui correspondait à la traduction de pile et de tas

)

**koala01** · 06/04/2012, 12h58

Envoyé par gbdivers

je fatigue... si je ne fais plus la différence entre contigu et séquentiel, je vais aller me coucher je crois (hier, j'ai même bloqué sur heap et stack et je ne savais plus qui correspondait à la traduction de pile et de tas

)

Il me semblait bien que, venant de toi, ce genre d'erreur ne pouvait être du qu'à de l'inattention

Mais je ne pouvais pas ne pas intervenir pour autant

**Tagazouh** · 06/04/2012, 21h07

Salut!

Envoyé par koala01

Salut,Justement, non, vector est un tableau d'élément contigus, permettant un acces "en temps constant" (dit aussi "aléatoire") aux éléments...

Cela implique que tu peux parfaitement accéder à l'élément tab[n] sans que cela ne te prenne plus de temps que d'accéder à l'élément tab[n+1], et ce, quelle que soit la valeur de n (à moins, bien sur, que tu ne décide d'itérer sur chaque élément entre 0 et n)

La liste, par contre, est un conteneur à accès séquentiel: on ne peut accéder au Nième élément qu'à partir de l'élément N-1, ce qui fait que, plus N augmentra, plus nous mettons du temps à y accéder (vu qu'il faudra passer par tous les élément entre 0 et N )

Alors dit comme ça, j'ai un peut de mal à voir l’intérêt d'une list! Donc d'après vous, quel est le mieux pour moi?
Je vais devoir lister différentes choses:
>>la liste d'invités pour chaque inscrits (maxi 3 pour un diplômé);
>>la liste de tout les invités;
>>la liste de tout les inscrits;
>>mettre en place des tables (il y en a pour 10 personnes, et un autre type pour 30 personnes) où des invités et des inscrits réservent des places (enfin, en gros ce sera un tableau dynamique de 8 cases).

Du coup si la vitesse d’accès diminue si il y a plus de données pourquoi ne pas prendre un vector? Les vérifications (doublons...) sont plus faciles dans les listes?

Merci d'avance,
A bientôt

**gbdivers** · 06/04/2012, 22h54

Les listes sont plus efficaces pour les insertions/deletions. De plus, tu n'as pas besoin d'avoir un accès avec [] donc pas besoin de vector.
Mais une map (si tu veux mettre une clé de trie) ou un set (pour éviter les doublons) peut convenir aussi.
Un petit coup d'oeil sur le graphique de la FAQ suivante pourra t'aider : http://cpp.developpez.com/faq/cpp/?p...hoix_conteneur

**koala01** · 07/04/2012, 08h29

Envoyé par Tagazouh

Salut!

Alors dit comme ça, j'ai un peut de mal à voir l’intérêt d'une list! Donc d'après vous, quel est le mieux pour moi?
Je vais devoir lister différentes choses:
>>la liste d'invités pour chaque inscrits (maxi 3 pour un diplômé);
>>la liste de tout les invités;
>>la liste de tout les inscrits;
>>mettre en place des tables (il y en a pour 10 personnes, et un autre type pour 30 personnes) où des invités et des inscrits réservent des places (enfin, en gros ce sera un tableau dynamique de 8 cases).

Du coup si la vitesse d’accès diminue si il y a plus de données pourquoi ne pas prendre un vector? Les vérifications (doublons...) sont plus faciles dans les listes?

Merci d'avance,
A bientôt

Poses toi la question de savoir comment tu comptes utiliser les invités de tes inscrits, et tu auras très certainement ta réponse

As tu le moindre intérêt à vouloir prendre l'invité qui vient en deuxième (ou en troisième) position pour tous tes inscrits, sans t'intéresser au premier (ou au deux premiers)

As tu même le moindre intérêt à savoir si "Andre Dupont" est le premier ou le troisième invité de "Jaques Henry"

A priori, je répondrais "non" à ces deux questions : tu dois sans doute savoir combien d'invités a Jaques Henry (en a-t-il

si oui, combine

), tu dois, éventuellement, pouvoir parcourir tous les invités de "Jaques Henry", mais tu n'as aucun besoin de savoir que "Jaques Henry" n'a pensé à "Andre Dupont" qu'après avoir épluché tout son carnet d'adresse, et presque ne désespoir de cause (sinon il n'aurait pas eu ses trois invités

)

De toutes manières, en dehors des vérifications de nombre (combien "Jaques Henry" a-t-il d'invités

), toutes les vérifications suivantes se feront sur "l'ensemble de ses invités", par exemple, lorsqu'il s'agira de vérifier si "Andre Dupont" a déjà été invité par quelqu'un

Dans ce sens, la liste est un choix tout à fait cohérent

**Tagazouh** · 13/04/2012, 15h54

Salut!
Désolé pour le délai de réponse, mais merci beaucoup (encore), tout cela va bien m'aider, et je pense même utiliser une map pour la suite de mon «programme»!

Pour mes list d'invités, j'ai réussi à tout gérer dans ma class Diplome sans problèmes*; mais ensuite j'ai voulu essayer de faire ce don vous parliez en créant une class qui s'occupe de gérer la liste de tous les invités.
Du coup*:
dans PersonneInscrite, j'ai une liste d'invités (qui est de 3 maxi pour les Diplome) – (j'ai fait remonter ces méthodes dans PersonneInscrite, car ses classes filles en héritent toute)
dans Gala, j'ai une liste de tout les invités

Par contre je n'ai pas utilisé unique_ptr car la déclaration ne fonctionnait pas ...

list< unique_ptr< Invite > > invites;

Du coup je me suis aventuré du coté des pointeurs... J'ai abouti à quelque chose qui marche, mais je ne sais pas trop pourquoi ^^'
Enfin il y a une chose qui ne marche plus du coup: la vérification des doublons dans la liste personnelle d'un PersonneInscrite ne fonctionne plus. Du coup il y a des décalages entre la liste de tout les invités et la liste d’invité d'une PersonneInscrite...

voilà une partie de mon code:

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
 
class PersonneInscrite
{
    public:
        PersonneInscrite();
        PersonneInscrite(std::string nom, std::string prenom, std::string telephone, std::string email, std::string jour, std::string mois, std::string annee);
        virtual ~PersonneInscrite();
 
        void afficheInvites();
        virtual void afficheInfos();
        Invite* desinvitation();
        Invite * invitation();
        virtual void inscription();
        std::string getType();
        std::string getPromotion();
        int getNbInvite();
 
        friend std::ostream& operator << (std::ostream& flux, const PersonneInscrite& B);
        void print(std::ostream& flux) const;
 
 
    protected:
        static int baseNumeroInscription;
        int numeroInscription;
        std::string nom;
        std::string prenom;
        std::string telephone;
        std::string email;
        std::string type;
        std::string promotion;
        int nbInviteInscrit;
        std::list<Invite *> invites;
};

Et voilà les 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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
Invite * PersonneInscrite::invitation()
{
    string answer="";
    cout << "Veillez entrer le nom de la personne que vous voulez inviter : ";
    cin >> answer;
    string inom=answer;
    cout << "Veillez entrer le prénom de la personne que vous voulez inviter : ";
    cin >> answer;
    string iprenom=answer;
 
    Invite *tmp = new Invite(inom, iprenom);
 
    if(invites.size()!=0)
    {
        list<Invite*>::iterator it = find(invites.begin(), invites.end(), tmp);
        //recherche si l'invité est deja enregistré
        if (it == invites.end())
        {
            // non trouvé
            if(invites.size()<nbInviteInscrit)
            {
                invites.push_back(tmp);
                cout << "Invitation réussie !" << endl;
                return tmp;
            }
 
            else
            {
                 cout << "Vous avez déjà " << nbInviteInscrit << " invité(s), vous ne pouvez pas en ajouter !" << endl;
                 return NULL;
            }
        }
        else
        {
            //trouvé
            cout << "Vous avez deja invité " << tmp << " !" << endl;
            return NULL;
        }
    }
    else
    {   //invitation
        if(invites.size()<nbInviteInscrit)
        {
            invites.push_back(tmp);
            cout << "Invitation réussie !" << endl;
            return tmp;
        }
        else
        {
            cout << "Vous avez déjà " << nbInviteInscrit << " invité(s), vous ne pouvez pas en ajouter !" << endl;
            return NULL;
        }
    }
}
 
//pour dé-sinviter un invité
Invite* PersonneInscrite::desinvitation()
{
    string answer_str="";
    int answer=0;
    istringstream var;//variable pour tester que l'itilisateur entre bien une valeur type int
    if(invites.size()==0)
        cout << "\nVous n'avez invité personne." << endl;
    else
    {
        this->afficheInvites();
        cout << "\nEntrez le numero de la personne à supprimer : ";
        cin >> answer_str;
        var.str(answer_str);//transformation de string à int
        var >> answer;
 
        while((answer<=0) || (answer>invites.size()))
        {
            cout << "\nMauvaise saisie, veillez recommencer, svp : ";
            cin >> answer_str;
            var.clear();
            var.str(answer_str);//transformation de string à int
            var >> answer;
 
        }
 
        list<Invite*>::iterator it = invites.begin();
        advance(it, answer-1);
 
        Invite * tmp = *it;
        invites.erase(it);
 
        return tmp;
 
    }
}
 
 
//affiche les nom des invités
void PersonneInscrite::afficheInvites()
{
    int i=0;
 
    if(invites.size()==0)
        cout << "\nVous n'avez invité personne." << endl;
    else
    {
        cout << "\nVous avez " << invites.size() << " invité(s) :" << endl;
        for(list<Invite*>::iterator it = invites.begin(); it!=invites.end(); it++)
        {
            i++;
            cout << i << " - " << *(*it) << " ;" << endl;
        }
    }
}

Et la classe Gala:

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
 
class Gala
{
    public:
        Gala();
        virtual ~Gala();
 
        void invitation(PersonneInscrite &p);
        void desinvitation(PersonneInscrite &p);
        void afficheInvites(PersonneInscrite *p = NULL);
        int getNbInvite(PersonneInscrite *p = NULL);
 
        void ajouterInscrits(PersonneInscrite *p);
        void afficherInscrits();
 
    protected:
    private:
        std::list<PersonneInscrite*> listeInscrits;
        std::list<Invite> listeInvites;
};

Et les 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
68
69
 
//permet d'ajouter des invités
void Gala::invitation(PersonneInscrite &p)
{
    Invite *tmp = NULL;
    if ((tmp = p.invitation()) != NULL)
    {
        list<Invite>::iterator it = find(listeInvites.begin(), listeInvites.end(), *tmp);
        //recherche si l'invité est deja enregistré
        if (it == listeInvites.end())
        {
                listeInvites.push_back(*tmp);
                cout << "Ajout à la liste des Invites !" << endl;
        }
        else
        {
            //trouvé
            cout << *tmp << " a deja été invité !" << endl;
        }
    }
}
 
 
//pour dé-sinviter un invité
void Gala::desinvitation(PersonneInscrite &p)
{
    Invite * tmp = p.desinvitation ();
    listeInvites.remove (*tmp);
}
 
 
//affiche les nom des invités
void Gala::afficheInvites(PersonneInscrite *p)
{
    if (p != NULL)
        p->afficheInvites ();
    else
    {
        if(listeInvites.size()==0)
            cout << "\nIl n'y a aucun invité." << endl;
        else
        {
            int i=0;
            cout << "\nIl y a en tout " << listeInvites.size() << " invité(s) :" << endl;
            for(list<Invite>::iterator it = listeInvites.begin(); it!=listeInvites.end(); it++)
            {
                i++;
                cout << i << " - " << *it << " ;" << endl;
            }
        }
    }
}
 
 
//compte le nombre d'invités par PersonneInscrite
int Gala::getNbInvite(PersonneInscrite *p)
{
    int nombreInvite=0;
 
    if (p != NULL)
        p->getNbInvite();
    else
    {
    if (listeInvites.empty())
        return 0;
    else
        return nombreInvite=listeInvites.size();
    }
}

Donc c'est la partie qui vérifie si il la personne n'est pas déjà invitée (dans la méthode invitation de la classe PersonneInscrite). Est ce que vous sauriez me dire ce qui ne va pas?

Je ne sais pas si je me suis bien expliqué :$ donc si vous ne me comprenez pas, n'hésitez pas à me le dire !
Un grand merci d'avance
A bientôt

**koala01** · 15/04/2012, 11h26

C'est pas mal, mais...

La responsabilité de l'invitation (et de la "désinvitation", meme si le terme semble bizard

) ne devrait pas échoire à PersonneInscrite:

PersonneInscrite devrait présenter des fonctions comme :

bool ajouteInvite ( Invite *) // renvoie "false" si l'invité n'est pas ajouté (parce que la personne inscrite a déjà trois invités, ou parce que l'invité en question apparait déjà dans la liste )
void retireInvite( std::string const & nom, std::string const & prenom);
std::list<Invite*>::const_iterator inviteDebut() const;
std::list<Invite*>::const_iterator inviteFin() const;
(éventuellement) bool inviteExiste(std::string const & nom, std::string const & prenom);

PersonneInscrite n'est pas responsable de la durée de vie des invités (bon, c'est une décision arbitraire, mais la responsabilité de PersonneInscrite est de regrouper les informations concernant... les personnes inscrites, dont celle de garder en mémoire les gens qu'elle a invités, mais la responsabilité de la gestion des invités se ferait plutot au niveau du gala

)

La classe gala est, par contre, un candidat idéal pour gérer les inscrits d'une part et leurs invités d'autre part...

Elle pourrait avoir des fonctions proches de

list<PersonneInscrite>::iterator ajouteInscription();
Llist<PersonneInscrite>::const_iterator inscritDebut() const;
list<PersonneInscrite>::const_iterator inscritFin() const;
List<PersonneInscrite>::iterator inscritDebut();
list<PersonneInscrite>::iterator inscritFin();
bool inscritExiste(std::string const & nom, std::string const prenom) const;;
list<PersonneInscrite>::const_iterator trouveInscrit(std::string const & nom, std::string const & prénom) const;
List<PersonneInscrite>::iterator trouveInscrit(std::string const & nom, std::string const & prénom);
bool ajouteInvitation(PersonneInscrite const &);
bool retireInvitation(std::string const & nom std::string const & prenom)
bool estInvite(std::string const & nom, std::string const & prenom) const;
List<Invite>::const_iterator inviteDebut() const;
List<Invite>::const_iterator inviteFin() const;

et disposerait essentiellement des membres privés proches de

std::list<Invite> invites_
std::list<PersonneInscrite> inscrits_;

Quand tu veux créer une invitation, tu vérifies dans la liste d'invités si l'invité potentiel n'a pas encore été invité, et, si ce n'est pas le cas, tu l'ajoute

au niveau de la list invites_
sous forme de pointeur dans la liste des invités de la personne inscrite qui l'invite

pour retirer un invité, tu fais le contraire:

tu commences par le rechercher dans la liste
tu retrouves grace à cela quelle est la personne inscrite qui l'avait invité
tu retires l'invité de la liste des invités de la personne inscrite
tu retires enfin l'invité de la liste (générale) des invités

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

C++

Discussions similaires

Partager

Partager