Comment “retour d'un objet” en C++?
Je sais que le titre sonne familier car il y a beaucoup de questions similaires, mais je vous demande un aspect différent du problème (je sais faire la différence entre avoir des choses sur la pile et de les mettre sur le tas).
En Java, je peux toujours retourner des références à des "locaux" objets
public Thing calculateThing() {
Thing thing = new Thing();
//do calculations and modify thing
return thing;
}En C++, pour faire quelque chose de similaire, j'ai 2 options
(1) je peux utiliser des références à chaque fois que j'ai besoin de "retour" d'un objet
void calculateThing(Thing& thing) {
//do calculations and modify thing
}Puis l'utiliser comme ceci
Thing thing;
calculateThing(thing);(2) Ou je peux retourner un pointeur vers un objet alloué dynamiquement
Thing* calculateThing() {
Thing* thing(new Thing());
//do calculations and modify thing
return thing;
}Puis l'utiliser comme ceci
Thing* thing = calculateThing();
delete thing;En utilisant la première approche que j'ai de ne pas avoir à libérer de la mémoire manuellement, mais pour moi, cela rend le code difficile à lire. Le problème avec la deuxième approche est, je me souviens de delete thing;, qui n'a pas l'air très agréable. Je ne veux pas retourner une valeur copiée parce qu'il est inefficace (je pense), donc voici les questions
- Est-il une troisième solution (qui ne nécessite pas de copie de la valeur)?
- Est-il un problème si je m'en tiens à la première solution?
- Quand et pourquoi devrais-je utiliser la deuxième solution?
- +1 pour bien mettre la question aux voix.
- Très pédant, c'est un peu imprécis de dire que "les fonctions de retourner quelque chose". Plus précisément, l'évaluation d'un appel de fonction produit une valeur. La valeur est toujours un objet (sauf si c'est une fonction void). La distinction est que la valeur est une glvalue ou un prvalue -- qui est déterminé par déclarée type de retour est une référence ou pas.
Vous devez vous connecter pour publier un commentaire.
Le prouver.
Rechercher RVO et NRVO, et dans C++0x déplacez-sémantique. Dans la plupart des cas en C++03, un paramètre de sortie est juste un bon moyen de rendre votre code laid, et en C++0x vous fait être blesser par vous-même en utilisant un paramètre de sortie.
Il suffit d'écrire un code propre, retour par valeur. Si la performance est un problème de profil, il (arrêter de deviner), et de trouver ce que vous pouvez faire pour le réparer. Il ne sera probablement pas de retour des choses à partir de fonctions.
Cela dit, si vous êtes morts d'écrire comme ça, vous auriez probablement souhaitez faire le paramètre de sortie. Il évite l'allocation dynamique de la mémoire, ce qui est plus sûr et généralement plus rapide. Il n'a besoin que vous avez d'une certaine façon de construire l'objet avant de faire l'appel de la fonction, ce qui n'est pas toujours logique pour tous les objets.
Si vous souhaitez utiliser l'allocation dynamique, le moins que l'on puisse faire est de le mettre dans un pointeur intelligent. (Cela devrait être fait tous le temps de toute façon), Alors vous n'avez pas à vous soucier de la suppression de quoi que ce soit, les choses sont exception-safe, etc. Le seul problème est qu'il est probablement plus lent que le retour par la valeur de toute façon!
+1de moi. Ajoutez à cela le fait que le retour par valeur permet d'économiser le coût de la dynamique de l'allocation/libération de mémoire, peuvent, en fait, la vitesse jusqu' le code.std::movesur une lvalue), de sorte qu'il est sûr de prendre tout simplement les de leurs ressources au lieu de les copier. En fournissant un moyen de dire au compilateur comment déplacer les ressources en tenant compte de votre...Il suffit de créer l'objet et de le retourner
Je pense que vous ferez vous-même une faveur si vous oubliez d'optimisation et il suffit d'écrire un code lisible (vous aurez besoin de lancer un profiler plus tard, mais il n'est pas pré-optimiser).
Thing thing();déclare une fonction locale et de retourner unThing.Il suffit de retourner un objet comme celui-ci:
Cela va appeler le constructeur de copie sur les Choses, de sorte que vous pouvez faire votre propre mise en œuvre de cette. Comme ceci:
Cela pourrait effectuer un peu plus lent, mais il pourrait ne pas être du tout un problème.
Mise à jour
Le compilateur va probablement optimiser l'appel au constructeur de copie, donc il n'y aura pas de frais généraux supplémentaires. (Comme dreamlax souligné dans le commentaire).
Thing thing();déclare une fonction locale de retourner unThing, également, la norme permet au compilateur d'omettre le constructeur de copie dans le cas où vous avez présenté; toute moderne compilateur va probablement le faire.Avez-vous essayé d'utiliser des pointeurs intelligents (si la Chose est vraiment grand et lourd objet), comme auto_ptr:
auto_ptrs sont obsolètes; utilisationshared_ptrouunique_ptrà la place.Un moyen rapide de déterminer si un constructeur de copie est appelé, est l'ajout de vous connecter à votre classe du constructeur de copie:
Appel
someFunction; le nombre de "constructeur de Copie est appelé" lignes que vous obtiendrez varie entre 0, 1 et 2. Si vous ne recevez rien, alors votre compilateur a optimisé la valeur de retour (ce qui, il est autorisé à le faire). Si vous obtenez de ne pas obtenir de 0, et votre constructeur de copie est ridiculement cher, puis recherche de solutions de rechange à retourner les instances de vos fonctions.Tout d'abord vous avez une erreur dans le code, vous dire
Thing *thing(new Thing());, et seulementreturn thing;.shared_ptr<Thing>. Deref comme tho c'était un pointeur. Il sera supprimé pour vous lors de la dernière référence à l'Thingcontenu est hors de portée.Je suis sûr que C++ expert viendra avec une meilleure réponse, mais personnellement, j'aime bien la deuxième approche. À l'aide de pointeurs intelligents aide avec le problème de l'oubli à
deleteet comme vous le dites, il semble plus propre que d'avoir à créer un objet avant de la main (et encore avoir à le supprimer si vous le souhaitez allouer sur le tas).