Bonjour!
 
J'essaie de faire un programme qui me classe des individus d'un échantillon dans des classes. Un individu est de type Sample, et une classe de type Category.
Chaque category (je préfère dire ça, ducoup, ça évite les confusions avec les classes objet) a un vector de descripteurs (type CatDescriptor), et chaque individu a  un vector de category.
Mais à chaque individu classé, la category dans lequel il a été classé doit "apprendre", c'est à dire que les descripteurs (CatDescriptor) sont modifiés.
Ducoup, pour pouvoir modifier mes category à partir de mon objet Sample, il me semble que je n'ai pas d'autre solution que d'avoir un vector de pointeurs de category? Et que chaque category ait un vector de pointeurs de CatDescriptor?
 
Ce que j'implémente ducoup comme ça:
dans Sample.h:
std::vector<Category*> CatList;
 
dans Category.h:
std::vector<CatDescriptor*> DescList;
 
Le problème c'est qu'il me semble qu'en C++, il vaut mieux utiliser des références que des pointeurs. Typiquement, je voulais faire une fonction (dans Category.cpp):
 
CatDescriptor& Category::getCatWantedDesc(const std::string& i_name){
        for(auto it_desc=m_descList.begin();it_desc!=m_descList.end(); ++it_desc){
            if((*it_desc)->getName() == i_name)
               return *it_desc;
        }
 
        std::cerr << "Error: descriptor "+i_name+" doesn't exist in Class "+m_name;
}
 
Mais forcément, le type de retour ne correspond pas au type de retour annoncé dans la signature de la fonction.
 
Est ce qu'utiliser des pointeurs est réellement la seule solution ou est ce qu'il y en a une autre?  
Si c'est la seule solution, je n'ai pas d'autre choix que d'écrire, comme signature de ma fonction:
CatDescriptor* Category::getCatWantedDesc(const std::string& i_name) ?

Salut,
 
tu as essayé de faire un double déreférencement ? *it_desc est un pointeur, donc pour obtenir une référence, tu dois déréférencer it_desc une fois de plus :
 

 
Pour le type de retour tu as deux choix:
 
- Soit cette fonction de rechercher n'échoue jamais, c'est à dire que dans le contexte de ton programme, i_name est FORCEMENT un nom de catégorie. Dans ce cas tu peux garder un retour par référence. Pour la propreté du programme et éviter une erreur à la compilation, il faudrait cependant lever une exception après la boucle :
 

 
- Soit la fonction peut parfois échouer à trouver une correspondance, et dans ce cas elle doit pouvoir retourner un résultat null. Dans ce cas, tu dois effectivement utiliser une signature avec un pointeur en résultat :
 

 
Enfin, selon la version de ton compilateur, tu n'as plus besoin d'utiliser begin .. end...
 
En C++11, ta fonction peut s'écrire :
 

+ n'est pas un opérateur de concaténation. Sur ta ligne avec std::cerr, tu devrais vraisemblablement avoir des << à la place des + sans quoi tu vas te retrouver à faire des opérations arithmétiques sur des pointeurs.
 
en C++11, on évite autant que possible d'avoir des pointeurs nus. On a plus généralement des std::unique_ptr ou std::shared_ptr. Non seulement ca permet d'expliciter la durée de vie de tes objets, mais en plus, c'est plus sûr en cas d'exception. Ca a aussi notamment l'avantage de mieux traduire la relation entre tes classes, évidemment ...
 
... Et dans ton cas, je n'ai pas vriament réussi à saisir le rapport que tu as entre tes classes