Discussion :

[Logan5]

Bonjour,

Je suis un peu perdu avec un programme dans lequel j'utilise des vecteurs de pointeurs. Je tente inlassablement de jouer avec les pointeurs depuis des heures, mais je ne trouve pas de solution.

Le programme me sert d'entrainement pour vérifier que j'ai bien retenu mes leçons de c++, il s'agit d'une liste d'ami.
Dans un vecteur j'enregistre des gens : titi, toto etc..
Dans un autre vecteur, j'enregistre les amis de ces gens. (On est ami avec soit même).

J'ai commenté le programme dans le main pour vous expliquer son déroulement. La ligne bloquante est celle où je tente d'accéder au propriété de mon objet Personne.

Merci d'avance pour votre aide et vos indications.


Classe Personne

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <string>
 
class Personne {
    public:
    Personne() {}
    Personne(std::string n) : name(n), firstname("") {}
    ~Personne() {}
    std::string name;
    std::string firstname;
};

Classe de liste des amis

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
#include <iostream>
#include <string>
#include <vector>
#include "personne.h"
 
class FriendList {
    public:
    FriendList() {}
    FriendList(std::string n) : name(n) {}
    ~FriendList() {}
    std::string getName();
    void setName(std::string n);
    void FriendList::addPerson(Personne* &p);
    std::vector<Personne**> FriendList::listInvited();
 
    private:
    std::string name;
    std::vector<Personne**> vInvited;
};
 
// Fichier CPP ci-dessous
 
#include "FriendList.h"
 
std::string FriendList::getName(){
    return(name);
}
 
void FriendList::setName(std::string n){
    name = n;
}
 
void FriendList::addPerson(Personne* &p){
    vInvited.push_back(&p);
}
 
std::vector<Personne**> FriendList::listInvited(){
    return(vInvited);
}

Le 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
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 <iostream>
#include "personne.h"
#include "FriendList.h"
#include <vector>
 
using namespace std;
 
vector<Personne*> vectorPerson;
vector<FriendList*> vectorFriendList;
 
int main()
{
    Personne p1("toto");
    vectorPerson.push_back(&p1); // une personne toto est ajoutee
 
    FriendList f1("listeDeToto");
    vectorFriendList.push_back(&f1); // la liste de toto est créée
 
    vectorFriendList[0]->addPerson(vectorPerson[0]); // toto est ami avec lui meme
 
    Personne p2("titi");
    vectorPerson.push_back(&p2); // une personne titi est ajoutee
 
    vectorPerson[0]->name = "tutu"; // on renomme titi en tutu
 
    vectorFriendList[0]->addPerson(vectorPerson[1]); // j'ajoute titi a la liste de toto (devenu tutu)
 
 
// le listing des personnes (tutu et titi)
    for(int i=0; i<vectorPerson.size(); i++){
        cout << vectorPerson[i]->name << endl;
    }
 
// le listing des listes dami
    for(int i=0; i<vectorFriendList.size(); i++){
        cout << endl << vectorFriendList[i]->getName() << ":" << endl;
 
        // la liste dami de la personne        
        vector<Personne**> vFriendsDeTutu  = vectorFriendList[i]->listInvited();
        cout << endl << vFriendsDeTutu.size() << " personne dont :" << endl;
        for(int j=0; j<vFriendsDeTutu.size(); j++){
        // plantage ici
        //            cout << *vFriendsDeTutu[j]->name << ":" << endl;
        }
    }
 
    return 0;
}

[r0d]

Bonjour,

avant toute autre considération, une question: pourquoi utilises-tu un vecteur de pointeurs de pointeurs? Pourquoi ne pas utiliser un simple vector<Personne> (sans pointeurs)?

[Chatanga]

Code :

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

1
2
3
4
for(int j=0; j<vFriendsDeTutu.size(); j++){
    // plantage ici
    cout << *vFriendsDeTutu[j]->name << ":" << endl;
}

Pour que ça plante (et ça plantera), il faut déjà mettre des parenthèses autour de "*vFriendsDeTutu[j]" :

Code :

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

1
2
3
4
for(int j=0; j<vFriendsDeTutu.size(); j++){
    // plantage ici
    cout << (*vFriendsDeTutu[j])->name << ":" << endl;
}

Une fois cette correction faite, la raison du plantage résidera dans la double indirection de "std::vector<Personne**>" qui, par ailleurs, ne te sert à rien. C'est de pointer sur des instance de Personne qui t'intéresse ici, pas de pointer sur une variable temporaire (retournée par l'opérateur [] de vector) qui pointe à son tour sur une personne.

[Logan5]

Tout d'abord merci pour vos réponses. J'en suis venu à mettre des pointeurs, puis des pointeurs sur pointeur car je n'obtenais pas le resultat voulu. Et effectivement, j'ai complètement perdu mon objectif de vue.

@r0d J'ai suivi ton conseil, mais lorsque je change le nom de titi pour tutu, dans mon vecteur, la modification "ne suis pas". Par contre, ça compile bien !

@Chatanga Effectivement je veux pointer sur les instances des personnes afin de suivre les changements effectués sur les noms comme juste au dessus.

Tel quel, j'ai bien compris que cette ligne effectue une copie de mon objet Personne. Et du coup je suis tenté de remettre des pointeurs. Mais j'ai l'impression de tourner en rond

Code :

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

vectorFriendList[0].addPerson(vectorPerson[0]);

FriendList modifiée

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
#ifndef FriendList_H_INCLUDED
#define FriendList_H_INCLUDED
 
#include <iostream>
#include <string>
#include <vector>
#include "personne.h"
 
class FriendList {
    public:
    FriendList() {}
    FriendList(std::string n) : name(n) {}
    ~FriendList() {}
    std::string getName();
    void setName(std::string n);
    void FriendList::addPerson(Personne p);
    std::vector<Personne> FriendList::listInvited();
 
    private:
    std::string name;
    std::vector<Personne> vInvited;
};
 
#endif // FriendList_H_INCLUDED
 
// le CPP
 
#include "FriendList.h"
 
 
 
std::string FriendList::getName(){
    return(name);
}
 
void FriendList::setName(std::string n){
    name = n;
}
 
void FriendList::addPerson(Personne p){
    vInvited.push_back(p);
}
 
std::vector<Personne> FriendList::listInvited(){
    return(vInvited);
}

Main modifié

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
#include <iostream>
#include "personne.h"
#include "FriendList.h"
#include <vector>
 
using namespace std;
 
vector<Personne> vectorPerson;
vector<FriendList> vectorFriendList;
 
int main()
{
    Personne p1("toto");
    vectorPerson.push_back(p1);
    FriendList f1("listeDeToto");
    vectorFriendList.push_back(f1);
 
    vectorFriendList[0].addPerson(vectorPerson[0]);
 
 
    Personne p2("titi");
    vectorPerson.push_back(p2);
    vectorPerson[0].name = "tutu";
 
 
    vectorFriendList[0].addPerson(vectorPerson[1]);
 
    for(int i=0; i<vectorPerson.size(); i++){
        cout << vectorPerson[i].name << endl;
    }
 
    for(int i=0; i<vectorFriendList.size(); i++){
        cout << endl << vectorFriendList[i].getName() << ":" << endl;
        vector<Personne> vFriendsDeTutu  = vectorFriendList[i].listInvited();
        cout << endl << vFriendsDeTutu.size() << " personne dont :" << endl;
        for(int j=0; j<vFriendsDeTutu.size(); j++){
            cout << vFriendsDeTutu[j].name << endl;
        }
    }
 
    return 0;
}

[r0d]

Tel quel, j'ai bien compris que cette ligne effectue une copie de mon objet Personne. Et du coup je suis tenté de remettre des pointeurs. Mais j'ai l'impression de tourner en rond

C'est la raison pour laquelle je te demandais pourquoi tu utilisais des pointeurs. Posée de façon plus abrupte, la question est: "est-ce que tu sais ce que tu es en train de faire?". Est-ce que tu sais à quel résultat veux-tu arriver?
Il est absolument primordial que tu aies une idée la plus claire possible du résultat que tu souhaites obtenir avant de te lancer dans l'écriture du code, car sinon, tu va finir par tourner en rond...

Par exemple, dans ton cas, il faut que tu décides qui sera responsable des Personne. Cela signifie qu'il faut que tu décides quand et par qui les objets Personne vont-ils être construit, et quand et par qui vont-il être détruits.

Lorsqu'on programme en c++ il faut faire particulièrement attention à ce qui se passe en mémoire, et donc il faut toujours savoir, avant d'écrire le code, une idée du cycle de vie des objets.

Une fois que tu auras répondu à cette question, viens la question de la manière de stocker les objets. L'utilisation de pointeurs peut être légitime, ou pas, selon ce que tu souhaites faire. Mais garde à l'esprit que si tu peux, évite l'utilisation de pointeur.

Une chose à savoir aussi: la copie d'un objet simple est à peine plus gourmand qu'une copie de pointeurs. Dans un contexte où la rapidité d'exécution n'est pas primordiale, la différence peut être considérée comme négligeable.

[Dalini71]

Si tu ne veux pas modifier tes objets de type Personne par la suite, tu peux les passer par copie a ton vecteur de cette façon :

Code :

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

1
2
3
std::vector<Personne> v;
Personne p1 ("TOTO");
v.push_back (p1);

Sinon si tu veux pouvoir agir sur tes objets Personne depuis le vector, du genre

Code :

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

v.at (o).set_name ("TITI");

Alors la oui il vaut mieux passer par des pointeurs:

Code :

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

1
2
3
std::vector<Personne*> v;
Personne* p1 = new Personne ("TOTO");
v.push_back (p1);

Par contre l'utilité d'un vector de pointeurs de pointeurs sur Personne, j'avoue que j'ai pas pigé dans ton cas.

[r0d]

Tiens, il y a dans ton code un exemple parfait de ce que je suis en train d'essayer d'expliquer:

Code :

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

void FriendList::addPerson(Personne p);

addPerson est une fonction membre de la classe FriendList.

Essaie de répondre aux questions suivantes:
- Quel est le rôle de la classe FriendList? Est-ce:
1. Manipuler des Personne
2. Posséder un ensemble de Personne
3. Les deux

- Pourquoi est-ce qu'un simple vector<Personne> ne suffit-il pas? Pourquoi dois-tu ajouter une couche (ici avec la classe FriendList)?

- La question importante: Dans le code ci-dessus (la fonction addPerson), à quel moment le nouvel objet, de type Personne, doit-il être crée? Avant d'appeler cette fonction ou après?

[Logan5]

@r0d : Ce que tu m'écris - je le lis et je le comprends ... enfin je pense
J'aurais mieux fait d'ajouter un vector<Personne> dans ma classe Personne. Merci pour les remarques, car seul ... je me serai tourné vers des solutions encore plus complexe et incompilable.

@Dalini71 : Effectivement je voulais pouvoir agir sur les objets personnes.
J'ai suivi modifier mon code en conséquence et ça fonctionne enfin !

Code :

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

void FriendList::addPerson(Personne* p);

[r0d]

Ce que j'essayais de t'expliquer (j'aurais aimé que tu tentes de répondre à mes questions), c'est qu'avant de t'apprendre un langage (sa syntaxe, sa philosophie, ses paradigmes, ses pièges, ses points forts, ...), il faut commencer par penser son programme. C'est la raison pour laquelle on commence toujours par "programmer" sur du papier.

Mais bon, depuis Socrates rien n'a changé: les jeunes sont toujours aussi impatients

[Chatanga]

Ce n'est pas mon avis. Il faut mieux réflechir avant d'agir, mais c'est l'expérience qui fonde la réflexion. Autrement dit :
- agir ;
- réfléchir ;
- répêter les deux premières étapes ad infinitam.

C'est particulièrement vrai pour un langage. La manière dont on pense et organise ses idées est liée au langage qu'on parle. C'est aussi vrai avec le code. On n'aborde pas un problème de la même manière selon qu'on code en Java ou en Haskell. Un développeur expérimenté sait jongler entre différents (types de) langages en fonction des besoins. Le risque de s'abstraire du langage utilisé c'est de penser à tort qu'on s'en rend indépendant et ne pas voire qu'on continue à penser dans les limites restreinte de ce dernier. Un défaut qui ne touche heureusement que les vieux et qui épargne les débutants.

Pour revenir à nos moutons, voici une version du code récrite à ma sauce. Il ne s'agit pas de *la* version idéale (l'exemple étant de tout manière trop petit et dénué de contexte pour être significatif), mais simplement d'une version différente pouvant donner des idées à un débutant.

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
#include <string>
#include <set>
#include <boost/foreach.hpp>
 
 
/*
La POO est souvent enseignée à l'aide de contre-exemples. Les hiérarchies
d'employés de banque sont typiquement le genre de chose qui ne gagnent
pas grand chose à être transformées en objets car ce ne sont que de pures
données la plupart du temps. Rendre les attributs privés pour ensuite les
accompagner de getter / setter n'apporte rien dans le cas présent. Autant
en faire des structures transparentes.
*/
struct Person
{
    /*
    En l'absence de plus d'informations, c'est ici un string et non un simple
    "const char *" à la durée de vie indéfinie (ce peut être une constante
    tout comme une chaîne temporaire construite dynamiquement).
    */
    std::string name;
 
    int age;
};
 
/*
Le nommage des types (et encore plus des variables) ne doit pas
s'encombrer de détails d'implémentation sans intérêts. Le terme "liste
d'amis" est toutefois courant (p. ex. "ma liste d'amis sur FaceBook"
contrairement à "Tiens, bonjour, je te présente ma collection d'amis...").
D'ailleurs, en terme d'implémentation, c'est un set qui est utilisé.
*/
struct FriendList
{
    /*
    Même remarque qu'au dessus.
    */
    std::string name;
    /*
    Pluriel de "friend" et non un truc du genre "friendList". En l'occurence, 
    c'est un "set" afin de garantir à peu de frais (sans devoir écrire de
    add/removePerson) qu'on n'aura pas de doublons.
     
    Quant au type des éléments, il s'agit naturellement de pointeurs car une 
    liste d'amis référence des personnes qui vivent leur vie indépendamment
    des différentes listes d'amis qui peuvent pointer vers eux. Plus 
    fondamentalement, c'est l'identité des amis qu'on veut stocker et non leur 
    valeur (nom, sexe, couleurs des yeux, etc.). Si on avait voulu stocker
    l'historique des abonnements de personnes à cette liste, c'est par contre 
    un stockaga par valeur qui aurait prévalu, permettant de savoir, par
    exemple, que la première fois où une personne s'est abonnée, elle avait 
    75 ans et 95 ans la deuxième fois.
    */
    std::set< Person * > friends;
};
 
 
using namespace std;
 
 
int main( int, char ** )
{
    Person persons[] = {
        { "François", 13 },
        { "Mick", 11 },
        { "Annie", 10 },
        { "Claude", 11 },
        { "Dagobert" }
    };
 
    FriendList club = { "Le club des 5" };
    for (size_t i = 0; i < 5; ++i) {
        club.friends.insert( &persons[i] ); // c. à d. &( persons[i] )
    }
 
    cout << club.name << " contient " << club.friends.size() << " amis :" << endl;
    for (set< Person * >::const_iterator itr = club.friends.begin(), endItr = club.friends.end(); itr != endItr; ++itr) {
        cout << '\t' << (*itr)->name << endl;
    }
 
    /*
    Variante utilisant la bibliothèque Boost pour plus de lisibilité.
    */
    cout << club.name << " contient " << club.friends.size() << " amis :" << endl;
    BOOST_FOREACH (const Person * pFriend, club.friends) {
        cout << '\t' << pFriend->name << endl;
    }
 
    return EXIT_SUCCESS;
}

[r0d]

Bonjour,

Tu as peut-être raison Chatanga, je ne sais pas, c'est une question complexe.
Mais là par exemple, le code que tu proposes est extrêmement dangereux. Surtout pour un débutant. Si le programme se complexifie, et que celui qui programme n'a pas compris la problématique du "qui possède quoi", il risque fort de se retrouver avec le tableau persons désalloué à un moment donné (typiquement en sortant de sa portée), et du coup tout le reste de son programme va planter et il ne comprendra pas pourquoi.

Tu me diras qu'alors, il devra refaire une boucle sur "réfléchir", puis "agir". Peut-être. Il reste cependant le risque de la boucle infinie...

[Logan5]

Je vous remercie tous pour les messages et l'orientation pour la suite.

@Chatanga : merci bcp pour le code

@r0d : Pour tes questions:
- Quel est le rôle de la classe FriendList? 2. Posséder un ensemble de Personne. Les Personnes existent hors de FriendList.

- Pourquoi est-ce qu'un simple vector<Personne> ne suffit-il pas? Pourquoi dois-tu ajouter une couche (ici avec la classe FriendList)? Je voulais créer des listes de personne indépendante. Chaque utilisateur peut ainsi avoir plusieurs liste et une même liste peut avoir plusieurs utilisateurs.

- La question importante: Dans le code ci-dessus (la fonction addPerson), à quel moment le nouvel objet, de type Personne, doit-il être crée? Avant d'appeler cette fonction ou après? Il faut creer les objets Personne avant.