Quelle est la différence entre une copie et une copie?
Quelle est la différence entre une copie et une copie?
30 réponses
copies superficielles dupliquées aussi peu que possible. D'une copie d'une collection est une copie de la structure de collecte, pas les éléments. Avec une copie peu profonde, deux collections partagent maintenant les éléments individuels.
les copies profondes dupliquent tout. Une copie profonde d'une collection est deux collections avec tous les éléments de la collection originale dupliquée.
Largeur vs profondeur; pensez en termes d'un arbre de références avec votre objet comme noeud racine.
superficiel:
les variables A et B se réfèrent à des zones différentes de mémoire, lorsque B est assigné à A les deux variables se réfèrent à la même zone de mémoire. Les modifications ultérieures du contenu de l'un ou l'autre se reflètent instantanément dans le contenu de d'autres, comme ils partagent le contenu.
Profonde:
les variables A et B se réfèrent à différentes zones de mémoire, quand B est assigné à A les valeurs dans la zone de mémoire que A points à sont copiés dans la zone de mémoire à laquelle B points. Les modifications ultérieures au contenu de l'un ou l'autre restent uniques à A ou B; le contenu n'est pas partagé.
en bref, cela dépend de ce qui pointe à quoi. Dans une copie superficielle, l'objet B indique l'emplacement de l'objet a dans la mémoire. En copie profonde, toutes les choses dans l'emplacement de la mémoire de l'objet a sont copiées à l'emplacement de la mémoire de l'objet B.
cet article wiki a un grand diagramme.
spécialement pour les développeurs iOS:
si B est une copie peu profonde de A , alors pour les données primitives c'est comme B = [A assign]; et pour les objets c'est comme B = [A retain] ;
B et un point au même emplacement de mémoire
si B est une copie profonde de A , alors c'est comme B = [A copy];
B et Un point à différents emplacements de mémoire
B adresse mémoire identique à celle de A
B a le même contenu que A
copie superficielle: copie les valeurs de membre d'un objet dans un autre.
copie profonde: copie les valeurs membres d'un objet dans un autre.
Tout objet pointeur est dupliqué et copié en profondeur.
exemple:
class String
{
int size;
char* data;
};
String s1("Ace"); // s1.size = 3 s1.data=0x0000F000
String s2 = shallowCopy(s1);
// s2.size =3 s2.data = 0X0000F000
String s3 = deepCopy(s1);
// s3.size =3 s3.data = 0x0000F00F
// (With Ace copied to this location.)
Je n'ai pas vu de réponse courte, facile à comprendre ici--donc je vais essayer.
avec une copie superficielle, tout objet pointé vers la source est aussi pointé vers la destination (de sorte qu'aucun objet référencé n'est copié).
avec une copie profonde, tout objet pointé vers la source est copié et la copie est pointée vers la destination (donc il y aura maintenant 2 de chaque objet référencé). Cela se répète dans l'arbre des objets.
{Imaginez deux objets: A et B de même type _t(par rapport à C++) et vous envisagez d'superficiel/profond de la copie de A à B}
Copie Superficielle: Il suffit de faire une copie de la référence à A dans B. pensez-y comme une copie de L'adresse de A. Ainsi, les adresses de A et B seront les mêmes, c'est-à-dire qu'elles indiqueront le même emplacement mémoire, c'est-à-dire le contenu des données.
copie en Profondeur: Tout simplement fait un copie de tous les membres de A, attribue la mémoire dans un endroit différent pour B et assigne ensuite les membres copiés à B Pour réaliser la copie profonde. De cette manière, si l'Un devient inexistant B est toujours valide dans la mémoire. Le terme correct à utiliser serait Clonage, où vous savez qu'ils sont tous les deux totalement la même, mais tout de même différent (c.-à-d. stocké comme deux entités différentes dans l'espace de mémoire). Vous pouvez également fournir votre emballage de clone où vous pouvez décider via la liste d'inclusion / exclusion quelles propriétés sélectionnez pendant la copie profonde. C'est une pratique assez courante lorsque vous créez des API.
vous pouvez choisir de faire une copie peu profonde ONLY_IF vous comprenez les enjeux impliqués. Quand vous avez un nombre énorme de pointeurs à traiter en C++ ou C, faire une copie superficielle d'un objet est vraiment une mauvaise idée.
EXAMPLE_OF_DEEP COPY_ un exemple est, lorsque vous essayez de faire le traitement d'image et la reconnaissance d'objet vous devez masquer "le mouvement non pertinent et répétitif" hors de vos zones de traitement. Si vous utilisez des pointeurs d'image, alors vous pourriez avoir la spécification pour enregistrer ces images de masque. MAINTENANT... si vous faites une copie superficielle de l'image, lorsque les références pointeur sont tuées à partir de la pile, vous avez perdu la référence et sa copie, c'est-à-dire qu'il y aura une erreur d'exécution de violation d'accès à un moment donné. Dans ce cas, ce dont vous avez besoin est une copie profonde de votre image en la clonant. De cette façon, vous peut récupérer les masques en cas de besoin dans l'avenir.
EXAMPLE_OF_SHALLOW_COPY Je ne suis pas extrêmement bien informé par rapport aux utilisateurs de StackOverflow alors n'hésitez pas à supprimer cette partie et de mettre un bon exemple si vous pouvez clarifier. Mais je pense vraiment que ce n'est pas une bonne idée de faire des copies superficielles si vous savez que votre programme va fonctionner pendant une période infinie de temps i.e. opération "push-pop" continue au-dessus de la pile avec des appels de fonction. Si vous si vous montrez quelque chose à un amateur ou à une personne novice (par exemple un tutoriel c/c++), alors c'est probablement correct. Mais si vous utilisez une application telle que le système de surveillance et de détection, ou le système de suivi Sonar, vous n'êtes pas censé garder la copie superficielle de vos objets autour parce qu'il tuera votre programme tôt ou tard.
Juste pour le plaisir de la compréhension facile que vous pourriez suivre cet article: https://www.cs.utexas.edu/~scottm/cs307/handouts/deepCopying.htm
Copie Peu Profonde:
Copie En Profondeur:
char * Source = "Hello, world.";
char * ShallowCopy = Source;
char * DeepCopy = new char(strlen(Source)+1);
strcpy(DeepCopy,Source);
'ShallowCopy' pointe vers le même emplacement dans la mémoire comme "Source". "DeepCopy" indique un emplacement différent dans la mémoire, mais le contenu est le même.
Qu'est-ce qu'une copie superficielle?
la copie superficielle est une copie bit-wise d'un objet. Un nouvel objet est créé, qui est une copie exacte des valeurs dans l'objet d'origine. Si l'un des champs de l'objet est une référence à d'autres objets, seules les adresses de référence sont copiées, c'est-à-dire que seule l'adresse mémoire est copiée. 
dans cette figure, le MainObject1 a les champs field1 de type int, et ContainObject1 du type ContainObject . Lorsque vous faites une copie peu profonde de MainObject1 , MainObject2 est créé avec field2 contenant la valeur copiée de field1 et pointant toujours vers ContainObject1 lui-même. Notez que puisque field1 est de type primitif, sa valeur est copiée sur field2 mais puisque ContainedObject1 est un objet, MainObject2 pointe toujours sur ContainObject1 . Ainsi, tout changement apporté à ContainObject1 dans MainObject1 sera reflété dans MainObject2 .
si c'est une copie superficielle, voyons ce qu'est une copie profonde?
Qu'est-ce que la copie profonde?
une copie profonde copie tous les champs, et fait des copies de la mémoire allouée dynamiquement pointée vers les champs. Une copie en profondeur se produit lorsqu'un objet est copié avec les objets auxquels il se réfère.
dans cette figure, les principaux Objectifs1 ont des champs field1 du type int, et ContainObject1 du type ContainObject . Lorsque vous faites une copie de MainObject1 , MainObject2 est créé avec field2 contenant la valeur copiée de field1 et ContainObject2 contenant la valeur copiée de ContainObject1 . Remarque les changements apportés à ContainObject1 dans MainObject1 ne refléteront pas MainObject2 .
dans la programmation orientée objet, un type inclut une collection de champs membres. Ces champs peuvent être stockées soit par valeur ou par référence (c'est à dire, un pointeur vers une valeur).
Dans une copie, une nouvelle instance de la création du type et les valeurs sont copiées dans la nouvelle instance. Les pointeurs de référence sont aussi copiés comme les valeurs. Par conséquent, les références pointent vers les objets originaux. Tout changement aux membres stockés par référence apparaître à la fois l'original et la copie, car aucune copie n'a été faite de l'objet référencé.
dans une copie profonde, les champs qui sont stockés par valeur sont copiés comme avant, mais les pointeurs vers les objets stockés par référence ne sont pas copiés. Au lieu de cela, une profonde copie de l'objet référencé, et un pointeur vers le nouvel objet est stocké. Tout changement apporté à ces objets référencés n'affectera pas les autres copies de l'objet.
'ShallowCopy' pointe vers le même emplacement dans la mémoire comme "Source". "DeepCopy" indique un emplacement différent dans la mémoire, mais le contenu est le même.
var source = { firstName="Jane", lastname="Jones" };
var shallow = ShallowCopyOf(source);
var deep = DeepCopyOf(source);
source.lastName = "Smith";
WriteLine(source.lastName); // prints Smith
WriteLine(shallow.lastName); // prints Smith
WriteLine(deep.lastName); // prints Jones
Copie peu profonde - variable de référence à l'intérieur des objets originaux et des objets copiés peu profonds ont une référence à objet "commun .
Deep Copy - variable de référence à l'intérieur des objets originaux et des objets copiés en profondeur ont une référence à différent objet.
clone fait toujours une copie superficielle.
public class Language implements Cloneable{
String name;
public Language(String name){
this.name=name;
}
public String getName() {
return name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
principal la classe est la suivante -
public static void main(String args[]) throws ClassNotFoundException, CloneNotSupportedException{
ArrayList<Language> list=new ArrayList<Language>();
list.add(new Language("C"));
list.add(new Language("JAVA"));
ArrayList<Language> shallow=(ArrayList<Language>) list.clone();
//We used here clone since this always shallow copied.
System.out.println(list==shallow);
for(int i=0;i<list.size();i++)
System.out.println(list.get(i)==shallow.get(i));//true
ArrayList<Language> deep=new ArrayList<Language>();
for(Language language:list){
deep.add((Language) language.clone());
}
System.out.println(list==deep);
for(int i=0;i<list.size();i++)
System.out.println(list.get(i)==deep.get(i));//false
}
sortie de ci-dessus sera -
false true true
false false false
tout changement apporté à l'objet original se reflétera dans l'objet superficiel et non dans l'objet profond.
list.get(0).name="ViSuaLBaSiC";
System.out.println(shallow.get(0).getName()+" "+deep.get(0).getName());
Sortie - ViSuaLBaSiC C
je voudrais donner l'exemple, plutôt que la définition formelle.
var originalObject = {
a : 1,
b : 2,
c : 3,
};
ce code montre une copie superficielle :
var copyObject1 = originalObject;
console.log(copyObject1.a); // it will print 1
console.log(originalObject.a); // it will also print 1
copyObject1.a = 4;
console.log(copyObject1.a); //now it will print 4
console.log(originalObject.a); // now it will also print 4
var copyObject2 = Object.assign({}, originalObject);
console.log(copyObject2.a); // it will print 1
console.log(originalObject.a); // it will also print 1
copyObject2.a = 4;
console.log(copyObject2.a); // now it will print 4
console.log(originalObject.a); // now it will print 1
Ce code indique un copie :
var copyObject2 = Object.assign({}, originalObject);
console.log(copyObject2.a); // it will print 1
console.log(originalObject.a); // it will also print 1
copyObject2.a = 4;
console.log(copyObject2.a); // now it will print 4
console.log(originalObject.a); // !! now it will print 1 !!
Clonage Superficiel:
Définition: "une copie superficielle d'un objet copie l'objet 'principal', mais ne copie pas les objets intérieurs."
Lorsqu'un objet personnalisé (par exemple. Employee) n'a que des variables primitives de type chaîne, puis vous utilisez le clonage superficiel.
Employee e = new Employee(2, "john cena");
Employee e2=e.clone();
Vous revenir super.clone(); dans la méthode clone() redéfinie et votre travail est terminé.
Profonde Clonage :
Définition: "contrairement à la copie superficielle, une copie profonde est une copie entièrement indépendante d'un objet."
Signifie lorsqu'un objet employé détient un autre objet sur mesure:
Employee e = new Employee(2, "john cena", new Address(12, "West Newbury", "Massachusetts");
alors vous devez écrire le code pour cloner l'objet 'Address' aussi bien dans la méthode overridden clone (). Sinon, L'objet Address ne clonera pas et il provoque un bug lorsque vous changez la valeur de L'adresse dans L'objet Employee cloné, ce qui reflète l'Original aussi.
struct sample
{
char * ptr;
}
void shallowcpy(sample & dest, sample & src)
{
dest.ptr=src.ptr;
}
void deepcpy(sample & dest, sample & src)
{
dest.ptr=malloc(strlen(src.ptr)+1);
memcpy(dest.ptr,src.ptr);
}
en termes simples, une copie superficielle est similaire à Call By Reference et une copie profonde est similaire à Call By Value
En Appel Par Référence, à la Fois formelle et réelle des paramètres d'une fonction se réfère au même emplacement de la mémoire et de la valeur.
En Appel Par Valeur, à la Fois formelle et réelle des paramètres de fonctions se réfère à l'emplacement de mémoire différent, mais ayant la même valeur.
imaginez qu'il y ait deux tableaux appelés arr1 et arr2.
arr1 = arr2; //shallow copy
arr1 = arr2.clone(); //deep copy
Copie
une copie profonde copie tous les champs, et fait des copies de la mémoire allouée dynamiquement pointée vers les champs. Une copie en profondeur se produit lorsqu'un objet est copié avec les objets auxquels il se réfère.
"Copie Peu Profonde
la copie superficielle est une copie bit-wise d'un objet. Un nouvel objet est créé, qui est une copie exacte des valeurs dans l'objet d'origine. Si tous les champs de l'objet sont des références à d'autres objets, seules les adresses de référence sont copiées, c'est-à-dire que seule l'adresse mémoire est copiée.
peu profond copier, c'est créer un nouvel objet puis copier les champs non statiques de l'objet courant vers le nouvel objet. Si un champ est une valeur type --> une copie bit-par-bit du champ est effectuée; pour un type de référence --> la référence est copiée mais l'objet référencé n'est pas; donc l'objet original et son clone se réfèrent au même objet.
Profonde copie est la création d'une nouvelle objet et copie les champs non statiques de l'objet courant vers le nouvel objet. Si un champ est un type de valeur --> une copie morceau par morceau du champ est effectuée. Si un champ est un type de référence --> une nouvelle copie de l'objet est effectuée. Les classes à cloner doivent être marquées comme [sérialisable].
tiré de [blog]: http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html
copie consiste à utiliser le contenu d'un objet pour créer une autre instance de la même classe. Dans une copie profonde, les deux objets peuvent contenir la même information mais l'objet cible aura ses propres tampons et ressources. la destruction de l'un ou l'autre objet n'affectera pas l'objet restant. L'opérateur de tâche surchargé créerait une copie profonde des objets.
copie superficielle consiste à copier le contenu d'un objet dans une autre instance de la même classe, créant ainsi une image miroir. Grâce à la copie directe des références et des pointeurs, les deux objets partageront le même contenu externe contenu de l'autre objet pour être imprévisible.
explication:
en utilisant un constructeur de copie, nous copions simplement les valeurs de données membre par membre. Cette méthode de copie est appelée copie superficielle. Si l'objet est une classe simple, composée de types construits et aucun pointeur, cela serait acceptable. Cette fonction utiliserait les valeurs et les objets et son comportement ne serait pas modifié avec une copie superficielle, seules les adresses des pointeurs qui sont des membres sont copiées et non la valeur à laquelle l'adresse pointe. Les valeurs de données de l'objet serait alors modifié par inadvertance par la fonction. Lorsque la fonction sort de scope, la copie de l'objet avec toutes ses données est retirée de la pile.
si l'objet a des pointeurs, une copie profonde doit être exécutée. Avec la copie profonde d'un objet, la mémoire est attribuée à l'objet en magasin libre et les éléments pointés vers sont copiés. Une copie profonde est utilisée pour les objets qui sont retournés à partir d'une fonction.
Pour ajouter plus d'autres réponses,
- une copie superficielle d'un objet exécute la copie par la valeur pour les types de valeur propriétés basées, et copie par référence pour les propriétés basées sur les types de référence.
- une copie profonde d'un objet effectue la copie par valeur pour les types de valeur basés propriétés, ainsi que copie par valeur pour les types de référence basés propriétés de profondeur dans la hiérarchie (de types de référence)
la copie superficielle ne créera pas de nouvelle référence mais la copie profonde créera la nouvelle référence.
Voici le programme pour expliquer la profonde et copie.
public class DeepAndShollowCopy {
int id;
String name;
List<String> testlist = new ArrayList<>();
/*
// To performing Shallow Copy
// Note: Here we are not creating any references.
public DeepAndShollowCopy(int id, String name, List<String>testlist)
{
System.out.println("Shallow Copy for Object initialization");
this.id = id;
this.name = name;
this.testlist = testlist;
}
*/
// To performing Deep Copy
// Note: Here we are creating one references( Al arraylist object ).
public DeepAndShollowCopy(int id, String name, List<String> testlist) {
System.out.println("Deep Copy for Object initialization");
this.id = id;
this.name = name;
String item;
List<String> Al = new ArrayList<>();
Iterator<String> itr = testlist.iterator();
while (itr.hasNext()) {
item = itr.next();
Al.add(item);
}
this.testlist = Al;
}
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Oracle");
list.add("C++");
DeepAndShollowCopy copy=new DeepAndShollowCopy(10,"Testing", list);
System.out.println(copy.toString());
}
@Override
public String toString() {
return "DeepAndShollowCopy [id=" + id + ", name=" + name + ", testlist=" + testlist + "]";
}
}
Copying ararys:
tableau est une classe, ce qui signifie qu'il est de type de référence donc array1 = array2 résultats dans deux variables qui font référence au même tableau.
Mais regardez cet exemple:
static void Main()
{
int[] arr1 = new int[] { 1, 2, 3, 4, 5 };
int[] arr2 = new int[] { 6, 7, 8, 9, 0 };
Console.WriteLine(arr1[2] + " " + arr2[2]);
arr2 = arr1;
Console.WriteLine(arr1[2] + " " + arr2[2]);
arr2 = (int[])arr1.Clone();
arr1[2] = 12;
Console.WriteLine(arr1[2] + " " + arr2[2]);
}
clone superficiel signifie que seule la mémoire représentée par la matrice clonée est copiée.
si le tableau contient des objets de type valeur, les valeurs sont copié ;
si le tableau contient le type de référence, seules les références sont copiées - il en résulte deux tableaux dont les membres font référence aux mêmes objets .
pour créer une copie profonde-où le type de référence est dupliqué, vous devez boucler le tableau et cloner chaque élément manuellement.
une copie peu profonde construit un nouvel objet composé et y insère ses références à l'objet original.
contrairement à la copie superficielle, la copie profonde construit un nouvel objet composé et insère des copies des objets originaux de l'objet composé original.
prenons un exemple.
import copy
x =[1,[2]]
y=copy.copy(x)
z= copy.deepcopy(x)
print(y is z)
imprime faux.
voyons comment.
objet composé Original x=[1,[2]] (appelé composé parce qu'il a un objet à l'intérieur de l'objet (Inception))
comme vous pouvez le voir dans l'image, il y a une liste à l'intérieur de la liste.
puis nous en créons une copie superficielle en utilisant y = copy.copy(x) . Ce que fait python ici, c'est qu'il va créer un nouvel objet composé mais les objets à l'intérieur d'eux pointent vers les objets originaux.
dans l'image, il a créé une nouvelle copie pour la liste extérieure. mais la liste interne reste la même que celle d'origine.
maintenant nous en créons une copie profonde en utilisant z = copy.deepcopy(x) . ce que fait python ici, c'est qu'il va créer de nouveaux objets pour la liste externe aussi bien que la liste interne. comme indiqué dans l'image ci-dessous (en rouge).
imprime à la fin du code False , car y et z ne sont pas les mêmes objets.
HTH.
ajoutant à toutes les définitions ci-dessus, une copie de plus et la plus couramment utilisée deep, est dans le constructeur de copie (ou l'oprator de tâche de surcharge) de la classe.
copie superficielle -- > est quand vous ne fournissez pas le constructeur de copie. Ici, seul l'objet est copié, mais pas tous les membres de la classe sont copiés.
copie profonde --> est lorsque vous avez décidé d'implémenter le constructeur de copie ou l'assignation de surcharge dans votre classe et permet la copie tous les membres de la classe.
MyClass& MyClass(const MyClass& obj) // copy constructor for MyClass
{
// write your code, to copy all the members and return the new object
}
MyClass& operator=(const MyClass& obj) // overloading assignment operator,
{
// write your code, to copy all the members and return the new object
}
Le constructeur de copie est utilisée pour initialiser le nouvel objet avec l'objet créé précédemment de la même classe. Par défaut compilateur a écrit une copie superficielle. La copie superficielle fonctionne bien quand l'allocation de mémoire dynamique n'est pas impliquée parce que quand l'allocation de mémoire dynamique est impliquée alors les deux objets pointent vers le même emplacement de mémoire dans un tas, donc pour supprimer ce problème nous avons écrit la copie profonde pour que les deux objets aient leur propre copie d'attributs dans une mémoire. Pour lire les détails avec des exemples complets et des explications vous pouvez voir l'article c++ constructors .
pour ajouter juste un peu plus de confusion entre la copie superficielle et tout simplement assigner un nouveau nom de variable à la liste.
"Disons que nous avons:
x = [
[1,2,3],
[4,5,6],
]
cet énoncé crée 3 listes: 2 listes intérieures et une liste extérieure. Une référence à la liste externe est ensuite disponible sous le nom de x. Si nous ne
y = x
aucune donnée n'est copiée. Nous avons toujours les mêmes 3 listes en mémoire quelque part. Tout ce que cela a fait est de faire l'extérieur liste disponible sous le nom de y, en plus de son nom précédent x. Si nous ne
y = list(x)
ou
y = x[:]
cela crée une nouvelle liste avec le même contenu que X. La liste x contenait une référence aux 2 listes intérieures, de sorte que la nouvelle liste contiendra également une référence à ces mêmes 2 listes intérieures. Une seule liste est copiée-la liste extérieure. Maintenant, il y a 4 listes en mémoire, les deux listes internes, la liste externe, et la copie de la liste externe. Original la liste extérieure est disponible sous le nom x et la nouvelle liste extérieure sous le nom Y.
les listes intérieures n'ont pas été copiées! Vous pouvez accéder et modifier les listes internes de x ou y à ce point!
si vous avez une liste bidimensionnelle (ou supérieure), ou n'importe quelle structure de données imbriquée, et que vous voulez faire une copie complète de tout, alors vous voulez utiliser la fonction deepcopy() dans le module de copie. Votre solution fonctionne également pour 2-D listes, comme itère sur les éléments de la liste externe et fait une copie de chacun d'eux, puis construit une nouvelle liste externe pour tous les l'intérieur des copies."