Retourner une reference d'une valeur stockée dans une std::map

Bonjour à tous, il y a quelque de très simple dont je ne trouve la syntaxe correcte.
Code:

1 2 3 4 5 6 7 8 9 bool ofxTALifxClient::find_bulb(string label, ofxTALifxBulb& _bulb) { for (auto& bulb : bulbs) { if (bulb.second.label == label) { _bulb = bulb.second; return true; } } return false; }
Le compilateur me retourne :
object of type 'ofxTALifxBulb' cannot be assigned because its copy assignment operator is implicitly deleted
note: copy assignment operator of 'ofxTALifxBulb' is implicitly deleted because field 'udpMan' is of reference type 'ofxTALifxUdpManager &'

Je saisi à peu près le problème, causé par le fait que ofxTALifxBulb a un constructeur tel que

Code:

ofxTALifxBulb::ofxTALifxBulb(ofxTALifxUdpManager& _udpMan) : udpMan(_udpMan)

Mais je n'arrive pas à trouver la bonne formulation pour que cette fonction stocke en _bulb une référence à l'entrée de la map en cours d'itération...

Merci d'avance pour votre aide !

Salut,

ta syntaxe nécessite l'opérateur = sur ofxTALifxBulb, qui d'après le compilateur n'existe pas. Et il n'existe pas parce que c'est impossible de copier une référence, elle doit être assignée à l'initialisation. (c'est texto ce que le compilo te dit.)
Tu peux tenter de passer par pointeurs, mais bon vu que ton objet est également non défault-constructible à priori, ça me parait au mieux tordu.
Ou alors... retourner l'itérateur de la map. :calim2:

Merci ! Retourner l'iterateur me semble une idée pas trop mauvaise !

Code:

1
2
3
4
5
6
7
8
bulb_map_iterator ofxTALifxClient::find_bulb(string label) {
    for (bulb_map_iterator it = bulbs.begin(); it != bulbs.end(); it++) {
        if (it->second.label == label) {
            return it;
        }
    }
    return bulbs.end();
}

et du coup je l'utilise aussi simplement que

Code:

1
2
3
4
bulb_map_iterator it = find_bulb(target);
    if(it != bulbs.end()) {
        it->second.SetColor(H,S,B,T);
    }

Citation:

Envoyé par Paganoni

Merci ! Retourner l'iterateur me semble une idée pas trop mauvaise !

Mais il y a encore mieux : rien ne t'empêche de renvoyer seulement une partie de ton itérateur (la deuxième partie de la paire); qui correspond à l'élément que tu souhaite obtenir.

En plus, cela te permettra de mettre une assertion qui pourrait s'avérer intéressante: l'élément que tu recherche doit exister, et, si ce n'est pas le cas, c'est que c'est une erreur de programmation.

Tu pourrais donc avoir un code proche de
Code:

1 2 3 4 5 ofxTALifxBulb& _bulb & find(std::string const & label){ auto it = bulbs.find(name); assert(it!= bulbs.end() && "inexistant label"); return it->second; }
Ce code présentera l'énorme avantage de t'indiquer que le bulb recherché n'existe pas en période de test. Et chaque fois que ce sera le cas, tu saura que la logique de la fonction qui tente d'y faire appel doit être revue ;)

Maintenant, il y a également une autre solution. Elle est connue sous le terme de "null object". L'idée est d'avoir une instance de la classe qui puisse être utilisé lorsque l'on n'a pas d'objet valide à proposer. Cette instance:
renvoie systématiquement false (ou une valeur nulle) à toute question qui pourrait lui être posée
bloque systématiquement la récursivité lorsqu'elle est utilisée
ne fait tout simplement rien lorsque elle recoit une instruction autre.
se renvoye elle-même si on demande son parent ou ses enfants
Cela permet de "taire silencieusement" l'absence de l'objet recherché, tout en évitant de placer le programme dans un état invalide

Tu pourrais donc créer une instance statique de ce null object dans ta fonction et le renvoyer à chaque fois que l'élément recherché n'existe pas. Ta fonction prendrait alors la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 ofxTALifxBulb& find(std::string const & label){ auto it = bulbs.find(name); /* l'assertion garde son intérêt, dans le sens où une logique adaptée au niveau de la fonctin appelante * permettrait d'éviter ce genre de situation */ assert(it!=bulbs.end() && "inexistant bulb label"); if(it== bulbs.end()){ /* l'objet nul ne doit vraiment être instancié que la première fois qu'on en a besoin */ ofxTALifxBulb nullObject; return nullObject; } return it->second; }
NOTE Cette méthode permet de ne pas décider de passer par un pointeur pour représenter le fait que l'élément recherché n'existe pas, sans risquer de placer le programme dans un état invalide, tout en nous évitant d'avoir à tester si l'élément renvoyé est valide ou non : quoi qu'il advienne, nous récupérons un objet considéré valide, même s'il répond non à toutes les questions que l'on peut poser ou qu'il ne fait jamais rien de ce que l'on peut lui demande.

Elle fournit donc un comportement cohérent pour les cas (qui peuvent toujours survenir) de production pour lesquels l'assertion n'a pas suffit en période de tests à repérer l'erreur de logique qui est à l'origine de l'absence de l'objet recherché (ce qui peut toujours arriver), tout en évitant d'avoir à lancer une exception qui, si elle n'était pas rattrapées finirait par faire planter le programme.

Cette méthode donne donc certaines garanties que l'on peut juger intéressantes, mais il ne faut pas perdre de vue que, si l'objet nul est renvoyé à un moment ou à un autre, c'est que cela cache sans doute un problème plus profond ;)

NOTE 2 : Il me semble intéressant de parler de std::optional (enfin, de std::experimental::optional car la fonctionnalité est encore en cours d'expérimentation et de tests) qui fournit justement une abstraction permettant de représenter le fait qu'un élément peut ne pas exister. Etant donné que nous partons sur l'idée de renvoyer une référence, il faudrait sans doute le coupler à un std::reference_wrapper, mais cela peut également s'avérer être une solution sympa ;)