Wat is het verschil tussen een diepe kopie en een ondiepe kopie?

Wat is het verschil tussen een diepe kopie en een ondiepe kopie?


Antwoord 1, Autoriteit 100%

Ondiepe exemplaren dupliceren zo min mogelijk. Een ondiepe kopie van een verzameling is een kopie van de verzamelconstructie, niet de elementen. Met een ondiepe kopie delen twee collecties nu de individuele elementen.

Diepe kopieën dupliceren alles. Een diepe kopie van een verzameling is twee collecties met alle elementen in de originele collectie gedupliceerd.


Antwoord 2, Autoriteit 109%

breedte vs diepte; Denk in termen van een rewijzer met uw object als het wortelknooppunt.

Ondiep:

De variabelen A en B verwijzen naar verschillende geheugengebieden, wanneer B is toegewezen aan een twee variabelen verwijzen naar hetzelfde geheugengebied. Latere wijzigingen aan de inhoud van beide worden onmiddellijk weerspiegeld in de inhoud van andere, terwijl ze de inhoud delen.

DIEP:

De variabelen A en B verwijzen naar verschillende geheugengebieden, wanneer B wordt toegewezen aan een waarden in het geheugengebied waarvoor een punten wordt gekopieerd naar het geheugengebied waarnaar B-punten is. Latere wijzigingen aan de inhoud van ofwel blijven uniek voor A of B; De inhoud wordt niet gedeeld.


Antwoord 3, Autoriteit 20%

Kortom, het hangt af van wat wijst naar wat. In een ondiepe kopie, object B PUNTEN om A’s locatie in het geheugen te bezoeken. In deep-exemplaar worden alle dingen in Object A’s geheugenlocatie gekopieerd naar de geheugenlocatie van het object B.

Dit wiki-artikel heeft een geweldig diagram.

http://en.wikipedia.org/wiki/Object_copy


Antwoord 4, Autoriteit 19%

Probeer te overwegen na beeld

Bijvoorbeeld Object.MemberWiseClone Creëert een ondiep kopie link

en gebruik iclonable interface U kunt diep kopiëren zoals beschreven hier


Antwoord 5, Autoriteit 8%

Speciaal voor iOS-ontwikkelaars:

Indien Bis een ondiepe kopie van A, dan voor primitieve gegevens is het als B = [A assign];En voor objecten is het als B = [A retain];

B en een punt naar dezelfde geheugenlocatie

Als Bis een diepe kopie van A, dan is het als B = [A copy];

B en een punt naar verschillende geheugenlocaties

B-geheugenadres is hetzelfde als A’s

B heeft dezelfde inhoud als A’s


Antwoord 6, Autoriteit 8%

Ondiepe kopie: & nbsp; kopieert de ledenwaarden van het ene object in de andere.

Diepe kopie: & nbsp; & nbsp; & nbsp; & nbsp; kopieert de ledenwaarden van het ene object in de andere.
                  &sp;Annbsp;   .

Voorbeeld:

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.)

Antwoord 7, autoriteit 6%

Voor het gemak van begrip zou je dit artikel kunnen volgen:
https://www.cs.utexas.edu/~scottm/cs307/handouts/deepCopying. htm


Ondiepe kopie:


Deep Copy:


Antwoord 8, autoriteit 6%

Ik heb hier geen kort, gemakkelijk te begrijpen antwoord gezien, dus ik zal het proberen.

Met een ondiepe kopie wordt elk object waarnaar wordt verwezen door de bron ook verwezen door de bestemming (zodat er geen objecten waarnaar wordt verwezen worden gekopieerd).

Met een diepe kopie wordt elk object waarnaar wordt verwezen door de bron gekopieerd en wordt naar de kopie verwezen door de bestemming (dus zullen er nu 2 zijn van elk object waarnaar wordt verwezen). Dit keert terug in de objectboom.


Antwoord 9, autoriteit 4%

{Stel je twee objecten voor: A en B van hetzelfde type _t (met betrekking tot C++) en je denkt aan oppervlakkig/diep kopiëren van A naar B}

Ondiepe kopie:
Maakt gewoon een kopie van de verwijzing naar A naar B. Zie het als een kopie van het adres van A.
Dus de adressen van A en B zullen hetzelfde zijn, d.w.z. ze zullen naar dezelfde geheugenlocatie verwijzen, d.w.z. gegevensinhoud.

Diep kopiëren:
Maakt eenvoudig een kopie van alle leden van A, wijst geheugen toe aan een andere locatie voor B en wijst vervolgens de gekopieerde leden toe aan B om een diepe kopie te verkrijgen. Op deze manier, als A niet meer bestaat, is B nog steeds geldig in het geheugen. De juiste term om te gebruiken zou klonen zijn, waarbij je weet dat ze allebei totaal hetzelfde zijn, maar toch verschillend (d.w.z. opgeslagen als twee verschillende entiteiten in de geheugenruimte). U kunt ook uw kloon-wrapper opgeven waar u via de opname-/uitsluitingslijst kunt beslissen welke eigenschappen u wilt selecteren tijdens diep kopiëren. Dit is een vrij gebruikelijke praktijk bij het maken van API’s.

U kunt ervoor kiezen om een Ondiepe Kopie te doen ALLEEN_ALSu begrijpt wat de inzet is. Als je een enorm aantal pointers hebt om mee om te gaan in C++ of C, is het ECHTeen slecht idee om een oppervlakkige kopie van een object te maken.

EXAMPLE_OF_DEEP COPY_Een voorbeeld is dat wanneer u beeldverwerking en objectherkenning probeert uit te voeren, u “Irrelevante en repetitieve bewegingen” uit uw verwerkingsgebieden moet maskeren. Als u afbeeldingsaanwijzers gebruikt, beschikt u mogelijk over de specificatie om die maskerafbeeldingen op te slaan. NU… als u een ondiepe kopie van de afbeelding maakt, wanneer de verwijzingen naar de aanwijzer van de stapel worden GEDOOD, bent u de referentie en de kopie ervan kwijt, d.w.z. er zal op een bepaald moment een runtime-fout van toegangsschending zijn. In dit geval hebt u een diepe kopie van uw afbeelding nodig door deze te KLONEN. Op deze manier kunt u de maskers terugvinden voor het geval u ze in de toekomst nodig heeft.

example_of_shallow_copy Ik ben niet erg goed geïnformeerd in vergelijking met de gebruikers in Stackoverflow dus voel je vrij om dit deel te verwijderen en een goed voorbeeld te geven als je kunt verduidelijken. Maar ik denk echt dat het geen goed idee is om ondiepe kopie te doen als je weet dat je programma wordt uitgevoerd voor een oneindige periode van tijd d.w.z. continue “push-pop” -bewerking over de stapel met functie-oproepen. Als u iets demonstreert aan een amateur of beginnende persoon (bijvoorbeeld C / C++ tutorial-spul), dan is het waarschijnlijk in orde. Maar als u een aanvraag gebruikt, zoals surveillance en detectiesysteem of SONAR-volgsysteem, moet u niet oppervlakkig blijven kopiëren van uw objecten omdat het uw programma vroeg of laat zal doden.


Antwoord 10, Autoriteit 4%

char * Source = "Hello, world.";
char * ShallowCopy = Source;    
char * DeepCopy = new char(strlen(Source)+1);
strcpy(DeepCopy,Source);        

‘Shallowcopy’ wijst op dezelfde locatie in het geheugen als ‘Source’ doet.
‘Deepcopy’ wijst op een andere locatie in het geheugen, maar de inhoud is hetzelfde.


Antwoord 11, Autoriteit 4%

Wat is ondiepe kopie?

Ondiepe kopie is een bit-wijze kopie van een object. Er wordt een nieuw object gemaakt dat heeft een exacte kopie van de waarden in het originele object. Als een van de velden van het object verwijzingen naar andere objecten zijn, worden alleen de referentiesadressen gekopieerd, d.w.z., alleen het geheugenadres wordt gekopieerd.

In deze afbeelding heeft het MainObject1velden field1van het type int en ContainObject1van het type ContainObject. Wanneer u een ondiepe kopie van MainObject1maakt, wordt MainObject2gemaakt met field2dat de gekopieerde waarde van field1bevat en toch wijzend naar ContainObject1zelf. Merk op dat aangezien field1van het primitieve type is, de waarde ervan wordt gekopieerd naar field2maar aangezien ContainedObject1een object is, MainObject2wijst nog steeds naar ContainObject1. Dus alle wijzigingen die zijn aangebracht in ContainObject1in MainObject1worden weergegeven in MainObject2.

Als dit een oppervlakkige kopie is, laten we dan eens kijken wat een diepe kopie is?

Wat is Deep Copy?

Een diepe kopie kopieert alle velden en maakt kopieën van dynamisch toegewezen geheugen waarnaar door de velden wordt verwezen. Een diepe kopie vindt plaats wanneer een object wordt gekopieerd samen met de objecten waarnaar het verwijst.

In deze afbeelding hebben de MainObject1 velden field1van het type int en ContainObject1van het type ContainObject. Wanneer u een diepe kopie maakt van MainObject1, wordt MainObject2gemaakt met field2met daarin de gekopieerde waarde van field1en ContainObject2met daarin de gekopieerde waarde van ContainObject1. Houd er rekening mee dat wijzigingen die zijn aangebracht in ContainObject1in MainObject1niet worden weergegeven in MainObject2.

goed artikel


Antwoord 12, autoriteit 2%

In objectgeoriënteerde programmering omvat een type een verzameling lidvelden. Deze velden kunnen worden opgeslagen op waarde of door verwijzing (d.w.z. een aanwijzer naar een waarde).

In een ondiepe kopie wordt een nieuw exemplaar van het type gemaakt en worden de waarden gekopieerd naar het nieuwe exemplaar. De referenties worden ook net als de waarden gekopieerd. Daarom wijzen de referenties naar de originele objecten. Alle wijzigingen in de leden die door verwijzing worden opgeslagen, verschijnen in zowel het origineel als de kopie, aangezien er geen kopie is gemaakt van het object waarnaar wordt verwezen.

In een diepe kopie worden de velden die op waarde worden opgeslagen, zoals eerder gekopieerd, maar de aanwijzingen op objecten die worden opgeslagen door referentie worden niet gekopieerd. In plaats daarvan wordt een diepe kopie gemaakt van het object waarnaar wordt verwezen en wordt een aanwijzer naar het nieuwe object opgeslagen. Alle wijzigingen die worden aangebracht aan die waarnaar wordt verwezen, hebben geen invloed op andere exemplaren van het object.


Antwoord 13

‘Shallowcopy’ wijst op dezelfde locatie in het geheugen als ‘Source’ doet. ‘Deepcopy’ wijst op een andere locatie in het geheugen, maar de inhoud is hetzelfde.


Antwoord 14

ondiep klonen:
Definitie: “Een ondiepe kopie van een object kopieert het ‘hoofd’ object, maar kopieert de innerlijke objecten niet.”
Wanneer een aangepast object (bijv. Employee) alleen primitieve, stringtype variabelen heeft, dan gebruikt u ondiepe klonen.

Employee e = new Employee(2, "john cena");
Employee e2=e.clone();

U retourneert super.clone();in de methode met betrekking tot de opgeheven kloon () en uw taak is voorbij.

diep klonen :
Definitie: “In tegenstelling tot de ondiepe kopie is een diepe kopie een volledig onafhankelijke kopie van een object.”
Betekent wanneer een werknemerobject een ander aangepast object bevat:

Employee e = new Employee(2, "john cena", new Address(12, "West Newbury", "Massachusetts");

Dan moet u de code schrijven om het object ‘Adres’ ook te klonen in de methode met betrekking tot de opdrachten klonen (). Anders zal het adresobject niet klonen en het veroorzaakt een fout wanneer u de waarde van het adres in Cloned Employee-object wijzigt, dat ook de originele weerspiegelt.


Antwoord 15

Ik wil graag voorbeeld geven in plaats van de formele definitie.

var originalObject = { 
    a : 1, 
    b : 2, 
    c : 3,
};

Deze code toont een ondiepe kopie :

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

Deze code toont een diepe kopie :

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 !!

Antwoord 16

Diepe kopie

Een diepe kopie kopieert alle velden en maakt kopieën van dynamisch toegewezen geheugen gericht op door de velden. Een diepe kopie treedt op wanneer een object wordt gekopieerd, samen met de objecten waarnaar het verwijst.

Ondiepe kopie

Ondiepe kopie is een bit-wijze kopie van een object. Er wordt een nieuw object gemaakt dat heeft een exacte kopie van de waarden in het originele object. Als een van de velden van het object verwijzingen naar andere objecten zijn, worden alleen de referentiesadressen gekopieerd, d.w.z., alleen het geheugenadres is gekopieerd.


Antwoord 17

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

Antwoord 18

Ondiepe kopie – Referentie-variabele Inside Original en Sh Onlow-gekopieerde objecten hebben betrekking op Common Object.

Deep Copy – Referentie Variabele Inside Oorspronkelijke en diepe gekopieerde objecten hebben betrekking op anders .

Clone altijd is ondiepe kopie.

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();
    }
}

Hoofdklasse volgt –

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
} 

Uitvoer van bovenstaande zal-

vals waar waar

false false false

Elke wijziging die in het oorspronkelijke object wordt aangebracht, wordt weerspiegeld in een ondiep object, niet in een diep object.

 list.get(0).name="ViSuaLBaSiC";
  System.out.println(shallow.get(0).getName()+"  "+deep.get(0).getName());

OutPut-ViSuaLBaSiC C


Antwoord 19

In eenvoudige bewoordingen is een Shallow Copy vergelijkbaar met Call By Reference en een Deep Copy is vergelijkbaar met Call By Value

In Call By Reference verwijzen zowel formele als feitelijke parameters van een functie naar dezelfde geheugenlocatie en de waarde.

In Call By Value verwijzen zowel formele als feitelijke parameters van een functie naar verschillende geheugenlocaties maar met dezelfde waarde.


Antwoord 20

Stel je voor dat er twee arrays zijn genaamd arr1 en arr2.

arr1 = arr2;   //shallow copy
arr1 = arr2.clone(); //deep copy

Antwoord 21

Een ondiepe kopie construeert een nieuw samengesteld object en voegt de verwijzingen erin naar het originele object in.

In tegenstelling tot oppervlakkige kopie, construeert deepcopy een nieuw samengesteld object en voegt het ook kopieën in van de originele objecten van het originele samengestelde object.

Laten we een voorbeeld nemen.

import copy
x =[1,[2]]
y=copy.copy(x)
z= copy.deepcopy(x)
print(y is z)

Bovenstaande code wordt FALSE afgedrukt.

Eens kijken hoe.

Oorspronkelijk samengesteld object x=[1,[2]](aangeroepen als samengesteld omdat het een object in het object heeft (Inception))

zoals je op de afbeelding kunt zien, is er een lijst in de lijst.

Vervolgens maken we er een ondiepe kopie van met behulp van y = copy.copy(x). Wat python hier doet, is dat het een nieuw samengesteld object maakt, maar objecten erin wijzen naar de originele objecten.

In de afbeelding is een nieuwe kopie gemaakt voor de buitenste lijst. maar de binnenste lijst blijft hetzelfde als de originele.

Nu maken we er een deepcopy van met z = copy.deepcopy(x). wat python hier doet, is dat het een nieuw object maakt voor zowel de buitenste als de binnenlijst. zoals weergegeven in de onderstaande afbeelding (rood gemarkeerd).

Aan het eind drukt de code Falseaf, omdat y en z niet dezelfde objecten zijn.

HTH.


Antwoord 22

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);
}

Antwoord 23

Als u meer wilt toevoegen aan andere antwoorden,

  • een ondiepe kopie van een object voert kopiëren op waarde uit voor waardetypen
    gebaseerde eigenschappen, en kopieer op referentie voor op referentietypes gebaseerde eigenschappen.
  • een diepe kopie van een object voert kopiëren op waarde uit voor waardetypen gebaseerd
    Eigenschappen, evenals kopie op waarde voor referentietypen gebaseerd
    Eigenschappen diep in de hiërarchie (van referentietypen)

Antwoord 24

genomen van [blog]: http: // SickProgrammersarea.blogspot.in/2014/03/Technical-interview-questions-on-c_6.html

Diepe kopie omvat het gebruik van de inhoud van één object om een ​​ander exemplaar van dezelfde klasse te maken. In een diepe kopie kunnen de twee objecten HT dezelfde informatie bevatten, maar het doelobject heeft zijn eigen buffers en middelen. De vernietiging van beide object heeft geen invloed op het resterende object. De overbelaste toewijzingsoperator zou een diepe kopie van objecten creëren.

Ondiepe kopie houdt in dat het kopiëren van de inhoud van één object in een ander exemplaar van dezelfde klasse wordt gekopieerd, waardoor een spiegelbeeld wordt gemaakt. Dankzij het rechte kopiëren van referenties en wijzers delen de twee objecten dezelfde extern ingesloten inhoud van het andere object om onvoorspelbaar te zijn.

Uitleg:

Een kopieerconstructeur gebruiken We kopiëren eenvoudigweg het lid van de gegevens door lid. Deze kopiewijze wordt ondiepe kopie genoemd. Als het object een eenvoudige klasse is, bestaande uit gebouwen in typen en geen aanwijzers zou dit acceptabel zijn. Deze functie zou de waarden en de objecten gebruiken en het gedrag ervan zou niet worden gewijzigd met een ondiepe kopie, alleen de adressen van aanwijzingen die leden worden gekopieerd en niet de waarde waarnaar het adres naar wijst. De gegevenswaarden van het object zouden dan per ongeluk worden gewijzigd door de functie. Wanneer de functie uit de reikwijdte gaat, wordt de kopie van het object met al zijn gegevens uitgeput van de stapel.

Als het object pointers heeft, moet een diepe kopie worden uitgevoerd. Met de diepe kopie van een object wordt geheugen toegewezen voor het object in de vrije opslag en worden de elementen waarnaar wordt verwezen gekopieerd. Een diepe kopie wordt gebruikt voor objecten die worden geretourneerd door een functie.


Antwoord 25

Ik begreep het uit de volgende regels.

Ondiepe kopie kopieert een object waardetype(int, float, bool) velden naar het doelobject en de referentietypes van het object (string, klasse, enz.) worden gekopieerd als verwijzingenin doelobject. In dit doel verwijzen referentietypes naar de geheugenlocatie van het bronobject.

Deep copy kopieert de waarde en referentietypes van een object naar een compleet nieuwe kopie van de doelobjecten. Dit betekent dat zowel de waardetypes als de referentietypes een nieuwe geheugenlocatie zullen krijgen.


Antwoord 26

Ondiepe kopie zal geen nieuwe referentie creëren, maar diepe kopie zal de nieuwe referentie creëren.

Hier is het programma om de diepe en oppervlakkige kopie uit te leggen.

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 + "]";
    }
}

Antwoord 27

Ondiepkopiëren is een nieuw object maken en vervolgens de niet-statische velden van het huidige object naar het nieuwe object kopiëren. Als een veld een waardetype is –> een bit-voor-bit kopie van het veld wordt uitgevoerd; voor een referentietype–> de verwijzing wordt gekopieerd maar het verwezen object niet; daarom verwijzen het originele object en zijn kloon naar hetzelfde object.

Diepkopiëren is het maken van een nieuw object en het kopiëren van de niet-statische velden van het huidige object naar het nieuwe object. Als een veld een waardetypeis –> een bit-voor-bit kopie van het veld wordt uitgevoerd. Als een veld een referentietypeis –> er wordt een nieuwe kopie van het verwezen object gemaakt. De te klonen klassen moeten worden gemarkeerd als [Serializable].


Antwoord 28

Arary’s kopiëren :

Array is een klasse, wat betekent dat het een referentietype is, dus array1 = array2 resultaten
in twee variabelen die verwijzen naar dezelfde array.

Maar kijk naar dit voorbeeld:

 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]);
    }

ondiepe kloonbetekent dat alleen het geheugen dat wordt vertegenwoordigd door de gekloonde array wordt gekopieerd.

Als de array objecten van het type waarde bevat, worden de waarden gekopieerd;

als de array het referentietype bevat, worden alleen de referenties gekopieerd – met als resultaat dat er twee arrays zijn waarvan de leden naar dezelfde objecten verwijzen.

Als u een diepe kopie wilt maken, waarbij referentietypes worden gedupliceerd, moet u door de array lopen en elk element handmatig klonen.


Antwoord 29

De kopieerconstructor wordt gebruikt om het nieuwe object te initialiseren met het eerder gemaakte object van dezelfde klasse. Standaard schreef de compiler een ondiepe kopie. Ondiepe kopie werkt prima wanneer dynamische geheugentoewijzing niet betrokken is, omdat wanneer dynamische geheugentoewijzing betrokken is, beide objecten in een hoop naar dezelfde geheugenlocatie zullen wijzen. Daarom hebben we om dit probleem te verhelpen een diepe kopie geschreven, zodat beide objecten hun eigen kopie van attributen hebben in een herinnering.
Om de details met volledige voorbeelden en uitleg te lezen, kunt u het artikel C++ constructorsbekijken .


Antwoord 30

Om iets meer toe te voegen voor verwarring tussen oppervlakkige kopie en eenvoudig een nieuwe variabelenaam toe te wijzen aan de lijst.

“Stel dat we hebben:

x = [
    [1,2,3],
    [4,5,6],
    ]

Deze verklaring creëert 3 lijsten: 2 binnenlijsten en één buitenlijst. Een verwijzing naar de buitenste lijst wordt dan beschikbaar gesteld onder de naam x. Als we dat doen

y = x

er worden geen gegevens gekopieerd. We hebben nog steeds dezelfde 3 lijsten ergens in het geheugen. Dit alles heeft de buitenste lijst beschikbaar gemaakt onder de naam y, naast de vorige naam x. Als we dat doen

y = list(x)

of

y = x[:]

Hiermee wordt een nieuwe lijst gemaakt met dezelfde inhoud als x. Lijst x bevatte een verwijzing naar de 2 binnenlijsten, dus de nieuwe lijst zal ook een verwijzing naar diezelfde 2 binnenlijsten bevatten. Er wordt slechts één lijst gekopieerd: de buitenste lijst.
Nu zijn er 4 lijsten in het geheugen, de twee binnenste lijsten, de buitenste lijst en de kopie van de buitenste lijst. De originele buitenste lijst is beschikbaar onder de naam x, en de nieuwe buitenste lijst wordt beschikbaar gemaakt onder de naam y.

De binnenlijsten zijn niet gekopieerd! Je kunt nu de binnenste lijsten openen en bewerken vanuit x of y!

Als je een tweedimensionale (of hogere) lijst hebt, of een andere geneste datastructuur, en je wilt van alles een volledige kopie maken, dan wil je de deepcopy()-functie in de kopieermodule gebruiken. Uw oplossing werkt ook voor 2D-lijsten, omdat de items in de buitenste lijst worden herhaald en een kopie van elk ervan wordt gemaakt, en vervolgens een nieuwe buitenste lijst wordt gemaakt voor alle binnenste kopieën.”

bron: https://www.reddit.com/r/ learnpython/comments/1afldr/why_is_copying_a_list_so_damn_difficult_in_python/

Other episodes