Discussion :

[Edouard Kaiser]

Bonjour à tous,
Migrant doucement du C vers le C++, je découvre les vecteurs et autres joies de la programmation orienté objet.
Mais j'ai un petit problème, j'ai l'impréssion que des vecteurs, contenant d'autres vecteurs bah ça passes pas chez moi :/
Je vous explique :
J'ai une classe CClasses qui contient un vecteur de la classe CClasse (peu importe ce qu'il y a dans ces classes aprés...)
Cette classe CClasse contient elle même un vecteur de ma classe CEleve.
Au final à partir d'une instance de CClasses, je souhaite ajouter une instance de CEleve dans une des CClasse du vecteur de CClasses
Vous me suivez ?
ça donne donc avec mes assesseurs : (on va prendre l'indice 0 du premier vecteur)

Code :

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

1
2
 
Classes.GetListe_Classe()[0].GetListe_Eleve.push_back(New_Eleve);

Hors rien à faire... ma liste d'eleve reste vide !
Donc je pense que j'ai du rater qqchose :
Merci d'avance pour votre aide !

[jmv]

salut,
avec un peu plus de code on pourra peut-être t'aider, donne au moins les déclarations des classes.

[Edouard Kaiser]

Ok let's go !

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
 
/*------------------ Classe CPersonne ----------------*/
class CPersonne
{
private:
	/* -- Attributs privés -- */
	string Nom;           // Nom
	string Prenom;        // Prénom
	string Adresse;       // Adresse
	string CP;            // Code Postal
	string Ville;         // Ville
	string Email;         // Email
	string Telephone;     // Numéro de téléphone
public:
	/* -- Accesseurs & fonctions -- */
	void SetNom(string);
	void SetPrenom(string);
	void SetAdresse(string);
	void SetCP(string);
	void SetVille(string);
	void SetEmail(string);
	void SetTelephone(string);
 
	string GetNom(void);
	string GetPrenom(void);
	string GetAdresse(void);
	string GetCP(void);
	string GetVille(void);
	string GetEmail(void);
	string GetTelephone(void);
};
 
 
/*------------------ Classe CClasse  --------------------*/
class CClasse
{
private:
	/* -- Attributs privés -- */
	string Nom;                     // Nom
	vector <CPersonne> Liste_Eleve;
public:
	/* -- Accesseurs & fonctions -- */
	void SetNom(string);
	void SetListe_Eleve(vector <CPersonne>);
 
	string GetNom(void);
	vector <CPersonne> GetListe_Eleve(void);
};
 
 
/*------------------ Classe CClasses  --------------------*/
class CClasses
{
private:
	/* -- Attributs privés -- */
	vector <CClasse> Liste_Classe; // Liste des classes
public:
	/* -- Accesseurs & fonctions -- */
	void AfficherListe_Classe(void);
	void AjouterClasse(void);
	void EnleverClasse(void);
 
	void SetListe_Classe(vector <CClasse>);
 
	vector <CClasse> GetListe_Classe(void);
};

En fait c'est pas un vecteur de CEleve dans CClasse mais CPersonne, enfin ça ne change rien...

Maintenant voila le code des assesseurs de CClasse et CClasses :

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
 
/*------------------ Classe CClasse  --------------------*/
 
/*         Méthodes Set          */
void CClasse::SetNom(string New_Nom)
{
	(this->Nom) = New_Nom;
}
 
void CClasse::SetListe_Eleve(vector <CPersonne> New_Liste)
{
	(this->Liste_Eleve) = New_Liste;
}
 
/*         Méthodes Get          */
string CClasse::GetNom(void)
{
	return (this->Nom);
}
 
vector <CPersonne> CClasse::GetListe_Eleve(void)
{
	return (this->Liste_Eleve);
}
 
 
/*------------------ Classe CClasses  --------------------*/
 
/*         Méthodes Set          */
void CClasses::SetListe_Classe(vector <CClasse> New_Liste)
{
	(this->Liste_Classe) = New_Liste;
}
 
/*         Méthodes Get          */
vector <CClasse> CClasses::GetListe_Classe(void)
{
	return (this->Liste_Classe);
}

Du classique quoi...

Imaginons :

Code :

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

1
2
3
4
5
6
7
 
CClasses MesClasses;
CClasse  MaClasse;
CPersonne Eleve;
 
MesClasses.GetListe_Classe().push_back(MaClasse); // Passe trés bien
MesClasses.GetListe_Classe()[0].GetListe_Eleve().push_back(Eleve); // Passe pas du tout :(

[jmv]

tes fonctions GetListe_Classe() et GetListe_Eleve() devraient retourner des références sur les vecteurs, sinon c'est une copie qui est retournée et que tu modifie.

[Edouard Kaiser]

Arg shit, bah voila je comprends mieux. Merci beaucoup, beaucoup.
Quel est la syntaxe au passage pour une référence vers un vecteur ?
Merci

Edit : Mmm c'est bon résolu, merci.

[Edouard Kaiser]

En fait non c'est pas résolu

Maintenant mes assesseurs ressemblent à ça par exemple :

Code :

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

1
2
3
4
5
 
void CEleve::SetListe_Note(vector <CNote>* New_Liste)
{
	(&Liste_Note) = New_Liste;
}

Or ça ne compile pas, donc je n'emploi pas la bonne méthode pour attribuer mes vecteurs.
Comment faut il s'y prendre proprement ?
Merci

[jmv]

En fait je pensais à cette modif :

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
 
/*------------------ Classe CClasse  --------------------*/
class CClasse
{
private:
	/* -- Attributs privés -- */
	string Nom;                     // Nom
	vector <CPersonne> Liste_Eleve;
public:
	/* -- Accesseurs & fonctions -- */
	void SetNom(string);
	void SetListe_Eleve(vector <CPersonne>);
 
	string GetNom(void);
	vector <CPersonne>&  GetListe_Eleve(void); //<== MODIF ICI
};
 
 
/*------------------ Classe CClasses  --------------------*/
class CClasses
{
private:
	/* -- Attributs privés -- */
	vector <CClasse> Liste_Classe; // Liste des classes
public:
	/* -- Accesseurs & fonctions -- */
	void AfficherListe_Classe(void);
	void AjouterClasse(void);
	void EnleverClasse(void);
 
	void SetListe_Classe(vector <CClasse>);
 
	vector <CClasse>& GetListe_Classe(void); //<== MODIF ICI
};

Le reste ne change pas

[Edouard Kaiser]

Ok compris, je pensais jouer sur les pointeurs, mais en faisant de cette façon ça reste bien plus transparent et pratique, merci.
Edit : Je me demandais pour quels types de variables il fallait utiliser ce moyen ? Pour tous lorsqu'on souhaite les modifier ?

[jmv]

tu peux utiliser des références sur n'importe quel type, structure, classe(comme avec les pointeurs).

[Edouard Kaiser]

Ok merci, mais prenons le cas des attributs de ma classe qui sont des "string"
Lors de mes assesseurs je fais de simples :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void CPersonne::SetAdresse(string New_Adresse)
{
	(this->Adresse) = New_Adresse;
}
 
string CPersonne::GetAdresse(void)
{
	return (this->Adresse);
}

Et la il semble que cela fonctionne trés bien sans passé par l'opérateur pour passer en référence. C'est pour cela que je me demandais quand il fallait utiliser cet opérateur.

[jmv]

http://c.developpez.com/faq/cpp/?page=references

[Edouard Kaiser]

Merci
C'est vrai qu'on pense jamais assez à la FAQ.

[Luc Hermitte]

Hum... plutôt:

Code :

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

1
2
3
4
5
6
7
8
9
void CPerson::setAddress(string const& new_adress_)
{
   address_ = new_address;
}
 
string const& CPerson::getAddress() const
{
   return address_;
}

Les changements:
- uniformité de langue
- capitalisation plus classique. Les majuscules en début sont plutôt réservées aux types
- const-correct -- les copies sont ici évitées. Et c'est la correction la plus importante.


Autre point: renvoyer une référence non constante sur un tableau que l'on contient, et aussi permettre de modifier un tableau que l'on contient (via un set) sont typiquement des erreurs de design.
Proposer d'exporter le tableau même constant est difficilement justifiable.
Il est plus normal de proposer des fonctions dédiées à certaines manipulations comme la recherche de personne(s) suivant tel ou tel critère, voire des combinaisons de critères, comme par exemple:

Code :

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

1
2
3
4
5
6
7
std::vector<boost::shared_ptr<Personne> > const
    lesdupont = annuaire.cherche( 
        Habite("Paris") && SAppelle("Dupon[td]"));
 
std::cout << "les Dupont et Dupond de paris sont :\n";
std::for_each(lesdupont.begin(), lesdupont.end(),
    std::cout << *boost::lambda::_1 << "\n");

(code non testé et requierant de définir diverses choses, mais parfaitement réalisable en C++)
En attendant, on commence par définir des fonctions dédiées à la recherche d'une personne à la fois suivant un critère bien particulier.

[Edouard Kaiser]

Je suis encore trop débutant en C++ et plus généralement conception orientée objet pour arriver vraiment à saisir ce que tu veux me dire
Ton code reste assez flou dans ma tete, je ne vois pas trop le probleme en fait de par la conception actuelle de mes classes.

[Luc Hermitte]

Regarde le design bancal suivant:

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
struct Annuaire
{
    typedef std::vector<Personne> Gens;
 
    int nombreGens() const { return nombreGens_; }
    Gens & gens() { return gens_;}
 
    void ajoute(Personne const& personne) {
        gens_.push_back(personne);
        ++nombreGens_;
    }
private:
    int  nombreGens_;
    Gens gens_;
}
....
{
    Annuaire monAnnuaire;
    monAnnuaire.ajoute(Personne("toto"));
    // assertion valide
    assert( monAnnuaire.nombreGens() == monAnnuaire.gens().size());
 
    monAnnuaire.gens().push_back(Personne("titi"));
    // assertion qui va provoquer un coredump
    assert( monAnnuaire.nombreGens() == monAnnuaire.gens().size());

En exposant une donnée interne à ton objet tu permets de le mettre dans un état incohérent.

C'est une faute de design. En général ce qui doit primer avant tout c'est l'abstraction que réprésente ton objet : comment tu veux le manipuler et non les données qu'il contient. Il y a un tendance (mode) qui consiste à réfléchir aux rôles que va tenir ton objet.
Que peut-on faire avec un annuaire ?
- ajouter des gens
- effacer des gens
- chercher des gens
- le sauver
- le restaurer
- ...

Dans l'exemple ci-dessus il va sans dire que l'on aurait pu retourner gens_.size() depuis nombreGens(). Cela n'empêche pas que l'on sera intéressés par observer les modifications (ajout/suppression/renommage) sur les gens de l'annuaire. On fait ça en général en notifiant des observateurs (comme une liste devant être mise à jour automatiquement), qui ont une vue (partielle ou non) sur l'annuaire, lorsque des opérations de modification sont exécutées. En retournant le vecteur interne sous forme modifiable, on peut perdre des notifications.

[Edouard Kaiser]

Ok je comprends un peu mieux, merci

[sg-40]

J'ai survolé (en A380 ton code)
Privilégies le codage de méthodes pour les modifications d'un attribut privé de ta classe.

Code :

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

CClasse::AjoutEleve(CPersonne monEleve){/* faire le push_back*/}

La qualité de ton code est inversement proportionnel au nombre d'accesseur que tu mets en place. Mais bon des fois on n'a pas trop le choix.