Besoin d'aide pour utilisation de tableaux d'objets
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:
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:
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:
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:
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:
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 :
Citation:
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 :D ?
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!)
