Comment "retourner un objet" en C++ ?

Question

Je sais que le titre semble familier car il y a beaucoup de questions similaires, mais je demande un aspect différent du problème (je connais la différence entre avoir des choses sur la pile et les mettre sur le tas).

En Java, je peux toujours renvoyer des références à des objets "locaux".

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 possibilités

(1) Je peux utiliser des références chaque fois que j'ai besoin de "retourner" un objet.

void calculateThing(Thing& thing) {
    // do calculations and modify thing
}

Ensuite, utilisez-le comme ceci

Thing thing;
calculateThing(thing);

(2) Ou je peux renvoyer un pointeur vers un objet alloué dynamiquement.

Thing* calculateThing() {
    Thing* thing(new Thing());
    // do calculations and modify thing
    return thing;
}

Ensuite, utilisez-le comme ceci

Thing* thing = calculateThing();
delete thing;

En utilisant la première approche, je n'aurai pas à libérer la mémoire manuellement, mais pour moi, cela rend le code difficile à lire. Le problème avec la deuxième approche est que je dois me rappeler de delete thing; ce qui n'est pas très joli. Je ne veux pas retourner une valeur copiée parce que c'est inefficace (je pense), alors voici les questions que je me pose

• Existe-t-il une troisième solution (qui ne nécessite pas de copier la valeur) ?
• Y a-t-il un problème si je m'en tiens à la première solution ?
• Quand et pourquoi dois-je utiliser la deuxième solution ?

Answer 1

Je ne veux pas retourner une valeur copiée parce que c'est inefficace.

Prouvez-le.

Recherchez RVO et NRVO, et dans C++0x la sémantique du mouvement. Dans la plupart des cas en C++03, un paramètre out n'est qu'un bon moyen d'enlaidir votre code, et en C++0x vous vous feriez du mal en utilisant un paramètre out.

Il suffit d'écrire du code propre, de retourner par valeur. Si la performance est un problème, établissez un profil (arrêtez de deviner), et trouvez ce que vous pouvez faire pour le résoudre. Il ne s'agira probablement pas de retourner des choses à partir de fonctions.

---

Cela dit, si vous tenez absolument à écrire comme ça, vous devriez probablement 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. Cela nécessite que vous ayez un moyen de construire l'objet avant d'appeler la fonction, ce qui n'a pas toujours de sens pour tous les objets.

Si vous voulez utiliser l'allocation dynamique, le moins que l'on puisse faire est de la mettre dans un pointeur intelligent. (Cela devrait être fait tout le temps de toute façon). Ainsi, vous n'avez pas à vous soucier de la suppression de quoi que ce soit, les choses sont protégées contre les exceptions, etc. Le seul problème est que c'est probablement plus lent que de retourner par valeur de toute façon !

Answer 2

Il suffit de créer l'objet et de le retourner

Thing calculateThing() {
    Thing thing;
    // do calculations and modify thing
     return thing;
}

Je pense que vous vous rendrez service si vous oubliez l'optimisation et que vous vous contentez d'écrire du code lisible (vous aurez besoin d'utiliser un profileur plus tard - mais ne pré-optimisez pas).

Answer 3

Il suffit de retourner un objet comme ceci :

Thing calculateThing() 
{
   Thing thing();
   // do calculations and modify thing
   return thing;
}

Cela invoquera le constructeur de copie sur les choses, donc vous pourriez vouloir faire votre propre implémentation de cela. Comme ceci :

Thing(const Thing& aThing) {}

Cela peut être un peu plus lent, mais ce n'est peut-être pas un problème du tout.

Mise à jour

Le compilateur optimisera probablement l'appel au constructeur de la copie, de sorte qu'il n'y aura pas de surcharge supplémentaire. (Comme dreamlax l'a souligné dans le commentaire).

Answer 4

Avez-vous essayé d'utiliser des pointeurs intelligents (si la Chose est un objet vraiment gros et lourd), comme shared_ptr :

    std::shared_ptr calculateThing()
    {
        std::shared_ptr<Thing> thing(new Thing);
        // .. some calculations
        return thing;
    }

    // ...
    {
        std::shared_ptr<Thing> thing = calculateThing();
        // working with thing

        // shared_ptr frees thing 
    }

Answer 5

Un moyen rapide de déterminer si un constructeur de copie est appelé est d'ajouter une journalisation au constructeur de copie de votre classe :

MyClass::MyClass(const MyClass &other)
{
    std::cout << "Copy constructor was called" << std::endl;
}

MyClass someFunction()
{
    MyClass dummy;
    return dummy;
}

Appelez someFunction Le nombre de lignes "Copy constructor was called" que vous obtiendrez variera entre 0, 1 et 2. Si vous n'en obtenez aucune, alors votre compilateur a optimisé la valeur de retour (ce qu'il est autorisé à faire). Si vous n'obtenez pas 0, alors votre constructeur de copie est ridiculement cher, entonces rechercher des moyens alternatifs pour renvoyer les instances de vos fonctions.