Copie d\'objet

Une des procédures les plus communes qui se produit dans des programmes informatiques est la copie des données. Un objet est un type de données composé dans des langues de la programmation orientée objectivement . La copie d'objet décrit ainsi l'action où un objet a ses attributs copiés à un autre objet du même type de données. Un objet peut être copié afin de réutiliser l'ensemble ou une partie de ses données dans un nouveau contexte.

Profondément contre peu profond contre la copie paresseuse

Le but de conception de la plupart des objets est d'inciter le programmeur à penser qu'elles sont fabriquées à partir d'un bloc monolithique quoique les la plupart ne soient pas. Pendant que des objets se composent de plusieurs différentes pièces, la copie devient non insignifiante. Plusieurs stratégies existent pour attaquer ce problème.

Considérer deux objets, A et B, que chacun se rapporte à deux blocs de mémoire x_i et y_i. Penser à A et à B comme cordes et à x_i et à y_i comme les caractères qu'ils contiennent.

Les paragraphes suivants expliquent différentes stratégies pour copier A dans le B.

Copie peu profonde

L'un d'entre eux est la copie peu profonde. Dans ce processus B est attaché au même bloc de mémoire que l'A.

Ceci a comme conséquence une situation dans laquelle quelques données sont partagées entre A et B, de ce fait la modification de celui changera l'autre. Le bloc de mémoire original de B n'est maintenant plus mentionné de n'importe où. Si la langue n'a pas la collection d'ordures automatique le bloc de mémoire original de B a été probablement coulé.

L'avantage des copies peu profondes est que leur vitesse d'exécution est rapide et ne dépend pas de la taille des données.

Au niveau du bit les copies des objets qui ne se composent pas d'un bloc monolithique sont les copies peu profondes.

Copie profonde

Une alternative sont les copies profondes. Ici les données sont réellement copiées plus de.

Le résultat est différent du résultat qu'une copie peu profonde donne. L'avantage est qu'A et B ne dépendent pas de l'un l'autre mais au coût d'une copie plus chère plus lente.

Copie paresseuse

Une copie paresseuse est une combinaison des deux stratégies ci-dessus. En copiant au commencement un objet, la copie peu profonde (rapide) d'a est employée. Un compteur est également employé pour dépister combien d'objets partagent les données. Quand le programme veut modifier un objet, il peut déterminer si les données sont partagées (en examinant le compteur) et peut faire une copie profonde au besoin.

La copie paresseuse regarde à l'extérieur juste comme une copie profonde mais tire profit de la vitesse d'une copie peu profonde autant que possible. Les du côté incliné sont des coûts bas plutôt élevés mais constants en raison du compteur. Également en certaine circulaire de de situation les références peuvent également poser des problèmes.

La copie paresseuse est liée au Copie-sur-écrivent .

Comment copier des objets

Presque tous les langages de programmation orientés par objet de du fournissent une certaine manière de copier des objets. Car la plupart des objets ne sont pas fournis par les langues elle-même le programmeur doit définir comment un objet devrait être copié, juste comme il doit définir si deux objets sont identiques ou même comparables en premier lieu. Beaucoup de langues fournissent un certain comportement de défaut.

Comment la copie est résolue varie de la langue à la langue et quel concept d'un objet il a. Les exemples suivants de présents pour deux de l'objet le plus employé couramment ont orienté les langues, le C++ et le Java , qui devrait couvrir presque chaque manière comment une langue orientée par objet peut attaquer ce problème.

Copie dans C++

voient également :

du constructeur de copie de Dans l'essai défini pour l'utilisateur d'objets de C++ pour se comporter juste comme le builtin ceux, ceci implique qu'il doit être possible de construire un objet basé sur le modèle d'un autre objet. Une construction de langues spéciale, le constructeur de copie de est fournie pour traiter le problème.

lang=" de vecteur de classe { public : Vecteur () ;

Vecteur (const Vector&other) : X (other.z) { } privé : international X, y, z ; } ;

Diriger a ; Diriger b (a) ; // b est une copie d'a

Noter que si le programmeur ne fournit pas un constructeur de copie le compilateur produira d'un défaut un. Dans certaines situations il est également utile de rejeter la copie tout à fait.

Quoique C++ ne l'impose pas au niveau de langue, on le considère en tant que bonne pratique de laisser le constructeur de copie font une copie profonde, juste comme tous les objets intégrés. (Les objets d'indicateur dans un certain sens font également les copies profondes comme les données ont indiqué n'est pas considérés une partie de l'indicateur.)

Copie dans Java

À la différence de dans C++, des objets dans Java sont accédés indirectement par des références. Des objets ne sont implicitement jamais créés mais à la place sont toujours passés ou assignés par la référence. La machine virtuelle prend soin de la référence comptant de sorte que des objets soient nettoyés après plus en service. Il n'y a aucune manière automatique de copier n'importe quel objet donné dans Java.

On permet des objets qui mettent en application l'interface soient copiés. Tous les objets ont une méthode de la méthode de clone de () ; cependant, l'appeler sur une classe qui ne met pas en application l'interface de Cloneable a comme conséquence un CloneNotSupportedException étant jetée. La méthode de clone de défaut () crée un nouvel exemple et copie tous les champs au nouvel exemple (un " ; copy" peu profond ;). Une classe peut dépasser la méthode de clone de défaut () pour fournir des possibilités faites sur commande de clonage, comme profondément copier (c. reproduire certaines des structures visées par l'objet) ou donner au nouvel exemple une nouvelle identification unique

Un inconvénient est que le type de retour de clone () est objet, et les besoins d'être explicitement moulé de nouveau dans le type approprié (techniquement une méthode faite sur commande de clone () pourrait renvoyer un autre type d'objet ; mais c'est généralement imprudent). Un avantage d'employer le clone () est que puisque c'est une méthode non prioritaire, nous pouvons appeler le clone () sur n'importe quel objet, et c'emploiera la méthode de clone () de sa classe réelle, sans code appelant devant savoir ce qu'est cette classe (qui serait nécessaire avec un constructeur de copie).

Une autre manière de copier des objets dans Java est au fabriquent en série ils par l'interface. Ceci est typiquement employé pour des buts de persistance et de protocole de fil, mais il crée des copies des objets et à la différence de clone, une copie profonde qui manipule avec élégance les graphiques faits un cycle des objets est facilement disponible avec l'effort minimal du programmeur.

Tous les deux méthodes souffrent d'un problème notable : le constructeur n'est pas employé pour des objets copiés avec le clone ou la fabrication en série. Ceci peut mener aux bogues avec des données incorrectement initialisées, empêche l'utilisation des champs « finaux » de membre, et fait la remise en question d'entretien.

Voir également

Constructeur de copie de
Surcharge d'opérateur
Référence de comptant
le Copie-sur-écrivent

Random links: