Bonjour,

Pour un de mes projets, j'ai une structure avec diverses listes d'objects. Cette structure "gère" ces objets. Pour des raisons de calcul, j'ai besoin d'accéder à tous ces objects de la même manière donc les objects héritent d'une classe interface et ils ont stockés dans une "map" qui contient un pointeur vers chacun des objects.

Mon approche marche mais n'est pas très "C++ moderne". J'aimerais remplacer les pointeurs par des "smart pointers" pour une meilleure gestion de la mémoire. Par contre, je ne les connais pas très bien et je me demande ce qu'il faut que j'utilise, j'hésite entre :
- des shared_pointers mais la "map" est pour moi juste un moyen d'accéder aux objects et n'est pas censée les "posséder" (au sens ownership)
- des unique_pointers pour le stockage des objects et des weak_pointers dans la "map" d'accès.

Pourriez-vous m'aider s'il vous plaît ? Merci d'avance !

Pour être plus concret, voisi un "pseudo 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class objectInterface {
  public:
  objectInterface() {}
  virtual ~objectInterface() {}
  std::string getId() const {return m_id};
 
  private:
  std::string m_id;
}
 
class object1 : public objectInterface {
  public:
  object1() : objectInterface() {}
  void loadCharacteristics(/*XML file*/) {/*load characteristics*/}
}
 
class object2 : public objectInterface {
  public:
  object2() : objectInterface() {}
  void loadCharacteristics(/*XML file*/) {/*load characteristics*/}
}
 
class container {
  public:
  container() {}
  void loadObjects() {
     while(/*read an XML file*/) {
       if(/*object1*/) {
         object1 newObject;
         newObject.loadCharacteristics(/*XML file*/);
         m_myObjects1.emplace_back(newObject);
         m_objects.emplace(newObject.getId(), &newObject);
       }
       else if(/*object2*/) {
         /* Idem object 1 */
       }
     }
  }
  void clearObjects() {
    m_myObjects1.clear();
    m_myObjects2.clear();
    for(auto & [id, obj]:m_objects) {
      if(obj!=nullptr)
        delete obj;
    }
  }
 
  private:
  std::vector<object1> m_myObjects1;  // shared ou unique ptr ?
  std::vector<object2> m_myObjects2;  // shared ou unique ptr ?
  std::unordered_map<std::string, objectInterface *> m_objects;  // accès par shared_ptr ou weak_ptr ?
}