Discussion :

[Yoruichi7]

Je dois faire un programme qui classe des individus d'un échantillon dans des classes. Et à chaque individu classé, la classe où il a été classé doit "apprendre".
J'ai donc une classe Sample qui contient un vector de Category, et qui doit pouvoir modifier les Category à chaque fois, voir en créer de nouvelles.
Chaque Category contient une liste de descripteurs (CatDescriptor est une classe abstraite), qui peuvent être de différents types (qualitatifs, quantitatifs, intervalles: CatQualitative, CatQuantitative, CatInterval)

Aussi, mon individu (Sample) possède une liste de descripteurs qui peuvent être de différents types (Qualitative, Quantitative, Interval).

S'il me faut créer une classe parce que mon individu ne correspond à aucune classe existante, je dois créer une Category avec les descripteurs (CatDescriptor) correspondant aux descripteurs de mon individu (Descriptor).
Je parcours donc la liste de mes descripteurs, et en fonction du type de descriptor que j'ai, je crée le catDescriptor correspondant.

J'ai donc essayé d'adapter la méthode des clones à mon problème, et j'ai fait ça:

dans Category.cpp:

Code :

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

1
2
3
4
5
void Category::addDescriptor(const Descriptor& i_desc){
    CatDescriptor* new_desc=i_desc.clone();
    new_desc->initialization(i_desc);
    m_descList.insert(new_desc);
}

dans Descriptor.h:

Code :

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

1
2
3
4
5
6
virtual CatDescriptor* clone() const =0;
 
dans Quantitative.cpp (par exemple):
virtual CatQuantitative* Quantitative::clone () const {
    return new CatQuantitative(this.getName());
}

Mais j'ai l'erreur suivante:

Code :

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

error: no matching function for call to 'std::list<CatDescriptor*>::insert(CatDescriptor*&);

et j'ai beau chercher, je n'arrive pas à m'en dépêtrer

[JolyLoic]

std::list::insert prend 2 arguments : La position et la valeur à insérer... Utilise push_back

Sinon, je n'aime pas dans ton code :
- Une fonction nommée initialization. C'est le job du constructeur
- La manipulation de pointeurs nus
- Le fait d'utiliser std::list (std::vector est probablement plus approprié, mais peut-être es tu dans un des rares cas où ce n'est pas le cas...)

[Yoruichi7]

En fait j'ai fait une fonction initialization parce que je cherchais à trouver mon erreur, donc je voulais séparer chacune de mes fonctions au maximum pour mieux la cerner (même si ça n'a finalement pas été efficace! )

Pour la list tu as raison, ça n'a pas trop d'intérêt ici, je vais utiliser vector à la place...

Par contre, la manipulation de pointeurs nus je ne comprends pas... J'ai commencé avec le C, et j'avoue que j'ai du mal à bien me servir de ceux en C++ et comprendre quand ils sont superflus ou non...

Merci en tous cas, ç'a résolu mon problème je crois!

[koala01]

Salut,

Par contre, la manipulation de pointeurs nus je ne comprends pas... J'ai commencé avec le C, et j'avoue que j'ai du mal à bien me servir de ceux en C++ et comprendre quand ils sont superflus ou non...

De manière générale, si tu es issu du monde du C, tu as eu plus que largement l'occasion d'être confronté soit aux tentatives de double libération de la mémoire, soit aux fuites mémoire occasionnées par le fait que tu "perdait" un pointeur avant d'avoir veillé à libérer correctement la mémoire vers laquelle il pointait.

Ces deux problèmes peuvent arriver strictement n'importe quand car il suffit d'oublier un free ou de le placer au mauvais endroit pour que tout foire

Les pointeurs intelligents (std::unique_ptr, std::shared_ptr et std::weak_ptr) présentent des solutions adaptées aux différentes situations qui permettent d'éviter tous les problèmes liés à la (non) libération de la mémoire au moment opportun.

La réponse "idéale" à la question de savoir quand utiliser les pointeurs intelligents est donc "chaque fois que tu as recours à l'allocation dynamique de la mémoire".

Quant à savoir si tu dois utiliser un unique_ptr, un shared_ptr ou un weak_ptr, cela dépendra très fortement de la situation à laquelle tu es confronté

Et, de manière générale, il faut aussi te dire que l'utilisation de pointeurs devrait être réservée à deux situations bien particulières:

1. Lorsque tu veux pouvoir maintenir une collection d'objets "passant pour être du type de base" alors que ce sont en réalité des objets de types dérivés
2. Lorsque tu veux pouvoir représenter l'absence d'un élément et que tu ne veux pas recourir à l'idiome de l'objet nul

En dehors de ces situations particulières, tu n'as, à peu de choses près, jamais besoin de recourir aux pointeurs : les réferences font parfaitement le travail avec la garantie de non nullité en plus (garantie que les pointeurs n'apportent absolument pas)