Avantages de la sémantique de copie sur écriture

Je me demande quels sont les avantages possibles de la copie sur écriture? Naturellement, je ne m'attends pas à des opinions personnelles, mais à des scénarios pratiques du monde réel où cela peut être techniquement et pratiquement bénéfique de manière tangible. Et par tangible, je veux dire quelque chose de plus que vous sauver la saisie d'un &caractère.

Pour clarifier, cette question se situe dans le contexte des types de données, où l'affectation ou la construction de copie crée une copie implicite superficielle, mais les modifications qui y sont apportées créent une copie profonde implicite et lui appliquent les modifications à la place de l'objet d'origine.

La raison pour laquelle je pose la question est que je ne trouve aucun avantage à avoir COW comme comportement implicite par défaut. J'utilise Qt, qui a implémenté COW pour beaucoup de types de données, pratiquement tous qui ont un stockage sous-jacent alloué dynamiquement. Mais en quoi cela profite-t-il vraiment à l'utilisateur?

Un exemple:

QString s("some text");
QString s1 = s; // now both s and s1 internally use the same resource

qDebug() << s1; // const operation, nothing changes
s1[o] = z; // s1 "detaches" from s, allocates new storage and modifies first character
           // s is still "some text"

Que gagnons-nous en utilisant COW dans cet exemple?

Si tout ce que nous avons l'intention de faire, c'est d'utiliser des opérations const, s1est redondant, autant l'utiliser s.

Si nous avons l'intention de changer la valeur, alors COW ne retarde la copie de ressource que jusqu'à la première opération non-const, au prix (quoique minime) de l'incrémentation du nombre de références pour le partage implicite et le détachement du stockage partagé. Il semble que tous les frais généraux impliqués dans COW soient inutiles.

Ce n'est pas très différent dans le contexte de la transmission de paramètres - si vous n'avez pas l'intention de modifier la valeur, passez comme référence const, si vous voulez modifier, vous faites soit une copie profonde implicite si vous ne voulez pas modifier l'objet d'origine, ou passez par référence si vous souhaitez le modifier. Encore une fois, COW semble être une surcharge inutile qui ne permet rien, et ajoute seulement une limitation selon laquelle vous ne pouvez pas modifier la valeur d'origine même si vous le souhaitez, car tout changement se détachera de l'objet d'origine.

Donc, selon que vous connaissez COW ou que vous n'en avez pas conscience, cela peut entraîner un code avec une intention obscure et des frais généraux inutiles, ou un comportement complètement déroutant qui ne correspond pas aux attentes et vous laisse vous gratter la tête.

Il me semble qu'il existe des solutions plus efficaces et plus lisibles, que vous souhaitiez éviter une copie en profondeur inutile ou que vous ayez l'intention d'en créer une. Alors, où est l'avantage pratique de la vache? Je suppose qu'il doit y avoir un certain avantage car il est utilisé dans un cadre aussi populaire et puissant.

De plus, d'après ce que j'ai lu, COW est désormais explicitement interdit dans la bibliothèque standard C ++. Je ne sais pas si les con que j'y vois ont quelque chose à voir avec ça, mais de toute façon, il doit y avoir une raison à cela.

La copie lors de l'écriture est utilisée dans des situations où vous créerez très souvent une copie de l'objet et ne la modifierez pas. Dans ces situations, il est rentable.

Comme vous l'avez mentionné, vous pouvez passer un objet const, et dans de nombreux cas, cela suffit. Cependant, const garantit seulement que l'appelant ne peut pas le muter (sauf si const_cast, bien sûr). Il ne gère pas les cas de multithreading et il ne gère pas les cas où il y a des rappels (qui pourraient muter l'objet d'origine). Le passage d'un objet COW par valeur met les défis de la gestion de ces détails sur le développeur de l'API, plutôt que sur l'utilisateur de l'API.

Les nouvelles règles pour C + 11 interdisent notamment à COW std::string. Les itérateurs d'une chaîne doivent être invalidés si le tampon de sauvegarde est détaché. Si l'itérateur était implémenté en tant que char*(par opposition à a string*et à un index), ces itérateurs ne sont plus valides. La communauté C ++ devait décider de la fréquence à laquelle les itérateurs pouvaient être invalidés, et la décision était que cela operator[]ne devrait pas être l'un de ces cas. operator[]sur un std::stringretourne un char&, qui peut être modifié. Ainsi, operator[]aurait besoin de détacher la chaîne, invalider les itérateurs. Cela a été considéré comme un métier médiocre, et contrairement aux fonctions comme end()et cend(), il n'y a aucun moyen de demander la version const de operator[]short de const cast la chaîne. ( lié ).

COW est toujours vivant et bien en dehors de la STL. En particulier, je l'ai trouvé très utile dans les cas où il est déraisonnable pour un utilisateur de mes API de s'attendre à ce qu'il y ait un objet lourd derrière ce qui semble être un objet très léger. Je souhaiterai peut-être utiliser COW en arrière-plan pour m'assurer qu'ils n'auront jamais à se préoccuper de ces détails de mise en œuvre.

Pour les chaînes et autres, il semble que cela pessimiserait des cas d'utilisation plus courants qu'improbable, car le cas commun pour les chaînes est souvent de petites chaînes, et là, les frais généraux de COW auraient tendance à dépasser de loin le coût de la simple copie de la petite chaîne. Une petite optimisation de la mémoire tampon me semble beaucoup plus logique pour éviter l'allocation de tas dans de tels cas au lieu des copies de chaînes.

Cependant, si vous avez un objet plus lourd, comme un androïde, et que vous vouliez le copier et simplement remplacer son bras cybernétique, COW semble tout à fait raisonnable comme moyen de conserver une syntaxe mutable tout en évitant de copier en profondeur l'intégralité de l'androïde juste pour donner à la copie un bras unique. Le rendre juste immuable en tant que structure de données persistante à ce stade pourrait être supérieur, mais un "COW partiel" appliqué sur des pièces Android individuelles semble raisonnable dans ces cas.

Dans un tel cas, les deux copies de l'androïde partageraient / auraient par exemple le même torse, les jambes, les pieds, la tête, le cou, les épaules, le bassin, etc. Les seules données qui seraient différentes entre elles et non partagées sont le bras qui a été fait unique pour le deuxième androïde sur l'écrasement de son bras.