Récupérer l'instance d'une classe à partir de la valeur de l'attribut unique de cette dernière

**it45200** · 22/03/2015, 22h19

Bonjour,

Peut-on trouver à quelle instance d'une classe appartient un attribut dont nous disposons de la valeur et qui est unique (une sorte d'Id)?
Je m'explique: j'ai 2 classes Obj et tabObj

B]Obj[/B] est utilisée dans un attribut de tabObj sous forme de tableau dynamique de pointeur constant à Obj.
Mon souci est que je n'arrive pas à trouver comment implémenter une méthode

Code :

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

bool enConflit(int id,vector <int> tabId);

comme suit:

Cette méthode devra retourner true si le Obj identifié par le premier paramètre est en conflit avec un Obj de tabId identifié par le 2ème paramètre: ) ; et false s’il n’y aucun conflit ;
Cette méthode retournera false si le Obj identifié par le premier paramètre ne fait pas partie tabObj (aucun des Obj de tabObj n’a cet identificateur) ; les Obj de la sélection qui ne font pas partie de tabObj seront ignorés.

La classe Obj a sa propre méthode enConflit et qui retourne true si l'instance OBJ en cours et celle qui est passée en paramètre ont le même nom et le même lieu.

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
#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
 
class Obj
{
private:
  int id_;
  string nom_;
  string lieu_;
 
public:
  Obj(int id, const string & nom, const string & lieu)
  : id_(id), nom_(nom), lieu_(lieu)
  {
  }
   int getId() const
   {
	   return id_;
   }
   const string & getNom() const
   {
	   return nom_;
   }
 
   const string & getLieu() const
   {
	   return lieu_;
   }
 
   bool enConflit (Obj o)
   {
       if (this->getLieu() == o.getLieu() && this->getNom() == o.getNom() )
       {
           return true;
       }
       else
       {
 
         return false;
       }
 
   }
 
};
 
class TabObj
{
  private:
  vector < const Obj* > objets;
 
  public:
  void add_objet (Obj const & o)
  {
    objets.push_back(&o);
  }
 
  const vector < const Obj* > & TabObjets () const
 
  {
 
	  return objets;
  }
 
 
  bool enConflit(int id,vector <int> tabId)
 
  {
      bool enConflit;
 
      return enConflit;
  }
 
};
 
 
int main()
{
   Obj o1(1,"Film","Paris");
   Obj o2(2,"Journal", "Moscou");
   Obj o3(3,"Film","Paris");
   TabObj tObj;
   tObj.add_objet(o1);
   tObj.add_objet(o2);
 
   for (const Obj * obj : tObj.TabObjets())
   {
       cout << obj->getId() << ": " << obj->getNom() << " -" << obj->getLieu() <<endl;
   }
 
   return 0;
}

Merci pour votre aide.

Cordialement,
IT

**ternel** · 23/03/2015, 10h00

C'est probablement parce qu'il faut que tu cherches quel est le OBJ qui a pour identifiant (unique, j'espère) un élément de la liste.
En l'occurence, ton problème vient directement de ce que tu stocke un vector<OBJ*>, alors que tu devrais stocker une map<OBJ::identifiant_type, OBJ>.Au passage, un vecteur de pointeur n'est utile que si tu comptes utiliser des fonctions virtuelles.

Je te suggère vivement d'inclure typedef int identifiant_type; dans une zone publique de OBJ. Cela augmentera la robustesse de ton code.

**it45200** · 23/03/2015, 12h32

Envoyé par leternel

C'est probablement parce qu'il faut que tu cherches quel est le OBJ qui a pour identifiant (unique, j'espère) un élément de la liste.
En l'occurence, ton problème vient directement de ce que tu stocke un vector<OBJ*>, alors que tu devrais stocker une map<OBJ::identifiant_type, OBJ>.Au passage, un vecteur de pointeur n'est utile que si tu comptes utiliser des fonctions virtuelles.

Je te suggère vivement d'inclure typedef int identifiant_type; dans une zone publique de OBJ. Cela augmentera la robustesse de ton code.

Bonjour,

Le fait d'avoir utilisé un vector<OBJ*> à la place de map<OBJ::identifiant_type, OBJ> est dû à une contrainte imposée.
Pour le typedef c'est déjà le cas mais je ne l'ai pas mis dans l'exemple par fainéantise

!

Le souci c'est que je n'arrive pas à exprimer ceci :

Code :

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

1
2
3
4
5
6
7
bool enConflit(string id,vector <int> tabId) 
{

s'il existe un Obj o dont l'attribut  id_ = id (o.getId() == id) => on parcourt tabId,  en récupérant le Obj de chaque occurrence et en vérifiant si pour chaque int id:tabId il n'y a un conflit avec o dans ce cas on retourne true;
sinon  on retourne false; 
/ suite de l'implémentation ...
}

Dans l'attente de vous lire.

Cordialement,
IT

**stendhal666** · 23/03/2015, 12h44

Attends, je découpe:

1.

Cette méthode devra retourner true si le Obj identifié par le premier paramètre est en conflit avec un Obj de tabId identifié par le 2ème paramètre: ) ; et false s’il n’y aucun conflit ;

jusque-là pas de problème

Code :

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

return std::find_if( begin(tabId) , end(tabId) , [&](const std::string& anId) {anId.compare(id) == 0; }) != end(tabId);

2.

Cette méthode retournera false si le Obj identifié par le premier paramètre ne fait pas partie tabObj (aucun des Obj de tabObj n’a cet identificateur) ;

là, en revanche, je ne comprends plus bien pcq l'attribut id d'un Obj est un entier...
Il faudrait connaître la relation entre la chaîne de caractères utilisée dans la fonction et l'identifiant des objets individuels.

3.

les Obj de la sélection qui ne font pas partie de tabObj seront ignorés.

... quelle sélection?

**it45200** · 23/03/2015, 13h02

Bonjour,

ci-dessous en rouge mes retours ; n'hésitez à me solliciter si jamais je n'ai pas été assez clair.

Envoyé par stendhal666

Attends, je découpe:

1.

jusque-là pas de problème

Code :

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

return std::find_if( begin(tabId) , end(tabId) , [&](const std::string& anId) {anId.compare(id) == 0; }) != end(tabId);

=> désolé, mea-culpa id est de type int et tabId est un tableau de int et non pas string
2.

là, en revanche, je ne comprends plus bien pcq l'attribut id d'un Obj est un entier...
=> Aucun élément de objets n'a cet id

Il faudrait connaître la relation entre la chaîne de caractères utilisée dans la fonction et l'identifiant des objets individuels.
=> désolé, mea-culpa id est de type int et tabId est un tableau de int et non pas string

3.

... quelle sélection?
=> la sélection c'est le 2ème paramètre de la méthode bool enConflit(string id,vector <int> tabId);, en l'occurrence tabId

Merci pour votre retour.

cordialement,
IT

**stendhal666** · 23/03/2015, 13h58

En fait, si comme tu le dis les ids dans la sélection qui ne correspondent pas à un Obj dans tabObj.objets ne comptent pas, alors il suffit de tester l'appartenance à tabObj.objets:

Code :

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

return std::find_if( begin(objets), end(objets), [&](const Obj* o) { return o->getId() == id; }) != end(objets);

Si en revanche il s'agit de tester si le Obj en premier paramètre appartient à l'intersection de tabId et objets (dans TabObj), alors:

Code :

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

1
2
3
4
5
6
bool enConflit (int id, std::vector<int> tabId) { // j'enlève la référence pcq tabId est modifié dans la fonction
  auto endOfIntersection= std::remove_if( begin(tabId), end(tabId), [&](int anId) { // range les éléments également présents dans objets au début et renvoie le dernier élément + 1
                                               return std::find_if( begin(objets), end(objets), [&](const Obj* o) { return o->getId() == anId; } ) == end(objets); 
                                           });
  return std::find( begin(tabId), endOfIntersection, anId ) != endOfIntersection;
}

**it45200** · 23/03/2015, 14h54

Tout d'abord merci pour tous tes retours et ta patience.

Ensuite mon vrai souci c'est déjà de récupérer l'instance à la quelle appartient l'id passé en 1er paramètre de la fonction ; une fois cette instance de Obj récupérée si cette dernière est en conflit avec un Obj de tabId (utilisation de la méthode enConflit de la classe Obj qui retourne true si l'instance OBJ en cours et celle qui est passée en paramètre ont le même nom et le même lieu) elle devra retourner true et false sinon.
Cette méthode retournera false si le Obj identifié par le premier paramètre de la méthode enConflit de la classe tabObj ne fait pas partie tabObj (aucun des Obj de tabObj n’a cet identificateur) ; les Obj de la sélection qui ne font pas partie de tabObj seront ignorés.

Cordialement,
Ite

**ternel** · 23/03/2015, 15h01

alors fait une map à partir du vecteur, et basta.
Tu auras juste besoin d'une fonction externe pour extraire l'identifiant du OBJ.

Tu peux utiliser un vecteur à coté, mais au moins, ta map sera facile à chercher.

**it45200** · 23/03/2015, 15h25

Bonjour,

Merci pour ce retour mais le vector<OBJ*>a été imposé, je ne peux donc pas utiliser de map<OBJ::identifiant_type, OBJ> à la place.

Cordialement,
It

**stendhal666** · 23/03/2015, 15h46

mmm...

Ensuite mon vrai souci c'est déjà de récupérer l'instance à la quelle appartient l'id passé en 1er paramètre de la fonction ; une fois cette instance de Obj récupérée si cette dernière est en conflit avec un Obj de tabId (utilisation de la méthode enConflit de la classe Obj qui retourne true si l'instance OBJ en cours et celle qui est passée en paramètre ont le même nom et le même lieu) elle devra retourner true et false sinon.

Donc, en pseudo-code:
instance = trouver_obj_dans_tab_obj_avec_cet(id);
pourChaque id dans tabId {
idInstance = trouver_obj_dans_tab_obj_avec_cet(id);
si instance.enConflit(idInstance) alors retourner true;
}
return false;

C'est bien ça?

Alors traduction c++:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
bool enConflit( int id, const std::vector<int> tabId ) {
  auto instance = std::find_if(objets.begin(); objets.end(); [&](const Obj* o) {return o->getId() == id;});
  // ce pourrait être une bonne idée de vérifier si instance existe, quand même, mais à toi de voir
  for (int thisId : tabId) {
     auto thisInstance = std::find_if(objets.begin(); objets.end(); [&](const Obj* o) {return o->getId() == thisId;});
     if (thisInstance == objets.end()) continue; // s'il n'est pas dans objets on l'ignore
     if (*instance)->enConflit(**thisInstance) return true; // double indirection: iterateur -> pointeur -> valeur
  }
  return false;
}

**it45200** · 23/03/2015, 16h18

Bonjour,

Merci, le pseudo-code est parfait par contre j'ai des erreurs à la compil et en plus je ne comprends pas trop les subtilités de ton code. Une petite explication (par rapport à find_if) s'impose quand tu auras le temps!

Encore merci.

Cordialement,
IT

**ternel** · 23/03/2015, 16h21

C'est parce que tu ne compiles pas en C++11, et donc que tu n'as pas accès aux lambdas (les [machin](bidule){truc})
Solution: compile en C++11 (-std=c++11 pour gcc, option dans les paramètres de compilation pour un IDE)
Solution du pauvre, défini des fonctions à la place.

Dans tout les cas, regarde ce que sont les lambdas en C++.

**stendhal666** · 23/03/2015, 16h21

je corrige volontiers mes erreurs, mais avec les messages d'erreur de la compil ce sera plus facile... il vaudra mieux que j'explique le code quand il sera correct :-)

**it45200** · 23/03/2015, 16h30

Envoyé par stendhal666

je corrige volontiers mes erreurs, mais avec les messages d'erreur de la compil ce sera plus facile... il vaudra mieux que j'explique le code quand il sera correct :-)

Bonjour,

Voilà:

------------- Build: Debug in testConst2 (compiler: GNU GCC Compiler)---------------

mingw32-g++.exe -Wall -fexceptions -g -std=c++11 -c D:\Cpp\Projets\testConst2\main.cpp -o obj\Debug\main.o
D:\Cpp\Projets\testConst2\main.cpp: In member function 'bool TabObj::enConflit(int, std::vector<int>)':
D:\Cpp\Projets\testConst2\main.cpp:70:54: error: expected ')' before ';' token
D:\Cpp\Projets\testConst2\main.cpp:70:54: error: unable to deduce 'auto' from '<expression error>'
D:\Cpp\Projets\testConst2\main.cpp:70:114: error: expected ';' before ')' token
D:\Cpp\Projets\testConst2\main.cpp:73:61: error: expected ')' before ';' token
D:\Cpp\Projets\testConst2\main.cpp:73:61: error: unable to deduce 'auto' from '<expression error>'
D:\Cpp\Projets\testConst2\main.cpp:73:125: error: expected ';' before ')' token
D:\Cpp\Projets\testConst2\main.cpp:75:28: error: expected primary-expression before '->' token
D:\Cpp\Projets\testConst2\main.cpp:75:56: error: expected ';' before 'return'
Process terminated with status 1 (0 minutes, 0 seconds)

Cordialement,
IT

**it45200** · 23/03/2015, 16h31

Envoyé par leternel

C'est parce que tu ne compiles pas en C++11, et donc que tu n'as pas accès aux lambdas (les [machin](bidule){truc})
Solution: compile en C++11 (-std=c++11 pour gcc, option dans les paramètres de compilation pour un IDE)
Solution du pauvre, défini des fonctions à la place.

Dans tout les cas, regarde ce que sont les lambdas en C++.

Bonjour,

Je compile bien en C++11:

mingw32-g++.exe -Wall -fexceptions -g -std=c++11 -c D:\Cpp\Projets\testConst2\main.cpp -o obj\Debug\main.o

Cordialement,
IT

**stendhal666** · 23/03/2015, 16h31

Pardon, je n'avais pas vu que c'était sur find_if que tu demandais des précisions:
- il y a 3 arguments: les deux premiers sont des itérateurs ou tout ce qui a une interface identique (grosso modo: ++ pour avancer et * pour récupérer la valeur sur laquelle il est en train d'itérer), et le troisième est tout ce qui ressemble à une fonction (fonction "en dur", fonction lambda, foncteur, tout ce qui peut être appelé avec l'opérateur () )
les fonctions lambda c'est des fonctions définies localement, avec comme syntaxe:
[paramètres de capture du contexte] (arguments) { corps de la fonction }
les paramètres de capture permettent de savoir ce que tu veux capturer de l'environnement dans lequel la fonction est définie. [&] permet d'avoir accès par référence à tous les identifiants définis dans l'environnement.
- elle retourne soit un itérateur positionné sur le premier élément pour lequel la fonction renvoie true, soit le deuxième itérateur donné en argument si aucun élément n'est le bon.

**stendhal666** · 23/03/2015, 16h36

Oui, pardon, j'ai mis des points-virgule au lieu de virgules dans find_if

**it45200** · 23/03/2015, 17h03

Envoyé par stendhal666

Oui, pardon, j'ai mis des points-virgule au lieu de virgules dans find_if

Ce n'est pas grave, je ne l'ai pas vu non plus!!!!
Par contre il y a encore une erreur dans le branchement

Code :

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

if (*instance)->enConflit(**thisInstance) return true;

mingw32-g++.exe -Wall -fexceptions -g -std=c++11 -c D:\Cpp\Projets\testConst2\main.cpp -o obj\Debug\main.o
D:\Cpp\Projets\testConst2\main.cpp: In member function 'bool TabObj::enConflit(int, std::vector<int>)':
D:\Cpp\Projets\testConst2\main.cpp:75:28: error: expected primary-expression before '->' token
D:\Cpp\Projets\testConst2\main.cpp:75:56: error: expected ';' before 'return'

d'ailleurs j'ai un peu de mal à comprendre cette double indirection: iterateur -> pointeur -> valeur

et même en rajoutant des parenthèses à la condition :

Code :

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

if ((*instance)->enConflit(**thisInstance)) return true

;

-------------- Build: Debug in testConst2 (compiler: GNU GCC Compiler)---------------

mingw32-g++.exe -Wall -fexceptions -g -std=c++11 -c D:\Cpp\Projets\testConst2\main.cpp -o obj\Debug\main.o
D:\Cpp\Projets\testConst2\main.cpp: In member function 'bool TabObj::enConflit(int, std::vector<int>)':
D:\Cpp\Projets\testConst2\main.cpp:75:55: error: passing 'const Obj' as 'this' argument of 'bool Obj::enConflit(Obj)' discards qualifiers [-fpermissive]

**stendhal666** · 23/03/2015, 17h22

Oui, c'est à cause de la signature de ta fonction Obj::enConflit(Obj o)
Il faudrait que tu la remplaces par Obj::enConflit(const Obj& o) j'ai l'impression

// non, je dis une bêtise, il faut le remplacer par
Obj::enConflit(Obj o) const

**stendhal666** · 23/03/2015, 17h28

pour la double indirection, ce n'est en fait pas compliqué, c'est juste un peu moche!

un itérateur ressemble beaucoup à un pointeur. On utilise l'opérateur * pour savoir ce à quoi il renvoie.
par exemple:

Code :

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

1
2
3
std::vector<int> vec = { 1, 2, 3, 4 };
auto iterateur = vec.begin();
std::cout << *iterateur; // affiche 1

donc si un itérateur renvoie à un pointeur, il faut d'abord sortir le pointeur de l'itérateur, puis la valeur du pointeur, d'où la double indirection: **iterateurSurPointeur pour obtenir la valeur

Récupérer l'instance d'une classe à partir de la valeur de l'attribut unique de cette dernière

C++

Discussions similaires

Partager

Partager