Envoyé par
Kaluza
Merci pour ta réponse.
Concernant le renvoie de la référence constante, ça consisterai à ça ? :
1
2
3
4
| inline const listElement& ListClass::getElement(int i) const
{
return _listvector[i];
} |
Oui, pour autant que _listvector contienne... des listElements et non des pointeurs sur listElement 
(puisque l'opérateur [] renvoie en principe une ref constante ?)
Pas tout à fait...
L'opérateur [] est généralement défini de deux manières:
Il renvoie une référence non constante lorsque tu l'appelle depuis un objet non constant et une référence constante quand tu l'appelle depuis un objet constant
Mais si tu invoque cet opérateur depuis une fonction constante, c'est effectivement la version constante de l'opérateur qui sera appelée, et tu obtiendra donc... une référence constante.
Je rajoute quelques précisions :
le std::vector<listElement> est un élément
private de la classe (puisque je veux que seule la classe puisse le modifier). En revanche j'aimerai bien que les éléments contenus dans le
std::vector<listElement> soient accessibles directement (en lecture seule) de n'importe quelle partie du programme sans passer par des copies (car les
listElement sont lourds en mémoire).
C'est la raison pour laquelle je te conseille de créer deux fonctions (begin et end)...
La première renvoie un itérateur constant sur le premier élément de _listvector et la seconde renvoie un itérateur constant sur... ce qui suit le dernier élément de _listvector:
1
2
3
4
5
6
7
8
| const_itertator ListClass::begin() const
{
return _listvector.begin();
}
const_iterator ListClass::end() const
{
return _listvector.end();
} |
avec, dans la définition de ta classe, un typedef publique proche de
typedef std::vector<listElement>::const_iterator const_iterator;
Tu pourra alors envisager de travailler sous une forme proche de
1
2
3
4
5
6
7
8
9
| int main()
{
ListClass truc;
/* on rempli truc */
for(ListClass::const_iterator it=truc.begin(); it!=truc.end();++it)
{
/* utilisation de it pour accéder à chaque élément */
}
} |
Tu pourrais d'ailleurs envisager la création de foncteurs proches de
1
2
3
4
5
6
7
| struct Foncteur
{
void operator()(listElement const & le)
{
/* ce qu'il faut faire */
}
} |
et l'utilisation de std::for_each (en C++1x) ou de boost::for_each(si tu ne dispose pas d'un compilateur supportant la nouvelle norme):
1
2
3
4
5
6
| int main()
{
ListClass truc;
/*remplir truc */
std::for_each(truc.begin(),truc.end(),Foncteur());
} |
Ah oui, dernière demande : j'ai actuellement des fonctions qui effectuent des recherches et renvoient les éléments correspondants du type :
1
2
3
4
5
6
7
8
| inline listElement ListClass::getElementName(const std::string &name) const
{
listElement output=_listvector[0];
for(unsigned int i=0;i<_listvector.size();i++)
if(_listvector[i].name==name)
output=_listvector[i];
return output;
} |
Comment faire de même mais en renvoyant une référence constante ?
Simplement en... renvoyant une référence constante 
1
2
3
4
5
6
7
8
| inline listElement const & ListClass::getElementName(const std::string &name) const
{
listElement output=_listvector[0];
for(unsigned int i=0;i<_listvector.size();i++)
if(_listvector[i].name==name)
output=_listvector[i];
return output;
} |
Nota: typiquement, ce genre de fonction n'a pas vraiment d'intérêt à être inlinée... mais bon, ce n'est qu'un détail
Getter renvoyant un pointeur ?
Répondre avec citation
A méditer: La solution la plus simple est toujours la moins compliquée
Partager