Editing Object copying

{{Short description|Technique in object-oriented programming}}
In [[object-oriented programming]], '''object copying''' is [[object creation|creating]] a copy of an existing [[object (computer science)|object]], a unit of data in object-oriented programming. The resulting object is called an ''object copy'' or simply ''copy'' of the original object. Copying is basic but has subtleties and can have significant overhead. There are several ways to copy an object, most commonly by a [[copy constructor]] or [[cloning (programming)|cloning]]. Copying is done mostly so the copy can be modified or moved, or the current value preserved. If either of these is unneeded, a reference to the original data is sufficient and more efficient, as no copying occurs.

Objects in general store [[Composite data type|composite data]]. While in simple cases copying can be done by allocating a new, uninitialized object and copying all fields ([[attribute (computing)|attributes]]) from the original object, in more complex cases this does not result in desired behavior.

== Methods of copying ==
The design goal of most objects is to give the resemblance of being made out of one monolithic block even though most are not. As objects are made up of several different parts, copying becomes nontrivial. Several strategies exist to treat this problem.

Consider an object A, which contains fields x<sub>i</sub> (more concretely, consider if A is a string and x<sub>i</sub> is an array of its characters). There are different strategies for making a copy of A, referred to as ''shallow copy'' and ''deep copy''. Many languages allow generic copying by one or either strategy, defining either one ''copy'' operation or separate ''shallow copy'' and ''deep copy'' operations.{{sfn|Grogono|Sakkinen|2000}} Note that even shallower is to use a [[reference (computer science)|reference]] to the existing object A, in which case there is no new object, only a new reference.

The terminology of ''shallow copy'' and ''deep copy'' dates to [[Smalltalk]]-80.{{sfn|Goldberg|Robson|1983|pages=97–99|ps=. "There are two ways to make copies of an object. The distinction is whether or not the values of the object's variables are copied. If the values are not copied, then they are shared (<code>shallowCopy</code>); if the values are copied, then they are not shared (<code>deepCopy</code>)."}} The same distinction holds for comparing objects for equality: most basically there is a difference between identity (same object) and equality (same value), corresponding to shallow equality and (1 level) deep equality of two object references, but then further whether equality means comparing only the fields of the object in question or dereferencing some or all fields and comparing their values in turn (e.g., are two linked lists equal if they have the same nodes, or if they have same values?).{{Clarify|date=November 2017}}

=== Shallow copy ===
{{multiple image
| align             = right
| image1            = 49psq.png
| width1            = 135
| alt1              = A and B refer to different areas in memory.
| caption1          = Variable reference to different memory space
| image2            = QqE2L.png
| width2            = 135
| alt2              = The assignment of variable B to A.
| caption2          = The assignment of variable B to A.
| footer            = 
| image3            = Cys27.png
| width3            = 135
| alt3              = Variables referring to same area of memory.
| caption3          = Variables referring to same area of memory.
}}

One method of copying an object is the ''shallow copy''. In that case a new object B is [[object creation|created]], and the fields values of A are copied over to B.<ref>{{cite web|title=C++ Shallow vs Deep Copy Explanation|url=http://www.fredosaurus.com/notes-cpp/oop-condestructors/shallowdeepcopy.html}}</ref><ref>{{cite web|title=.NET Shallow vs Deep Copy Explanation|url=http://www.codeproject.com/Articles/28952/Shallow-Copy-vs-Deep-Copy-in-NET}}</ref><ref>{{cite web|title=Generic Shallow vs Deep Copy Explanation|url=https://secweb.cs.odu.edu/~zeil/cs361/web/website/Lectures/big3/pages/shallowvsdeep.html|access-date=2013-04-10|archive-url=https://web.archive.org/web/20160304115828/https://secweb.cs.odu.edu/~zeil/cs361/web/website/Lectures/big3/pages/shallowvsdeep.html|archive-date=2016-03-04|url-status=dead}}</ref> This is also known as a ''field-by-field copy'',<ref>Core Java: Fundamentals, Volume 1, [https://books.google.com/books?id=QTZvAQAAQBAJ&pg=PA295&dq=%22field+copy%22 p. 295]</ref><ref>''[[Effective Java]]'', Second Edition, [https://books.google.com/books?id=ka2VUBqHiWkC&pg=PA54&dq=%22field+copy%22 p. 54]</ref><ref>"[https://stackoverflow.com/questions/2890340/what-is-this-field-by-field-copy-done-by-object-clone What is this field-by-field copy done by Object.clone()?]", ''Stack Overflow''</ref> ''field-for-field copy'', or ''field copy''.<ref>"Josh Bloch on Design: A Conversation with Effective Java Author, Josh Bloch", by Bill Venners, ''JavaWorld'', January 4, 2002, [http://www.artima.com/intv/bloch13.html p. 13]</ref> If the field value is a reference to an object (e.g., a memory address) it copies the reference, hence referring to the same object as A does, and if the field value is a primitive type, it copies the value of the primitive type. In languages without primitive types (where everything is an object), all fields of the copy B are references to the same objects as the fields of original A. The referenced objects are thus ''shared'', so if one of these objects is modified (from A or B), the change is visible in the other. Shallow copies are simple and typically cheap, as they can usually be implemented by simply copying the bits exactly.

=== Deep copy ===
{{multiple image
| align             = right
| image1            = deep copy in progress.svg
| width1            = 200
| alt1              = A deep copy in progress.
| caption1          = A deep copy in progress.
| image2            = deep copy done.svg
| width2            = 200
| alt2              = A deep copy has been completed
| caption2          = A deep copy has been completed.
| footer            = 
}}

An alternative is a deep copy, meaning that fields are dereferenced: rather than references to objects being copied, new copy of objects are created for any referenced objects, and references to these are placed in B. Later modifications to the contents of either remain unique to A or B, as the contents are not shared.

=== Combination ===
In more complex cases, some fields in a copy should have shared values with the original object (as in a shallow copy), corresponding to an "association" relationship; and some fields should have copies (as in a deep copy), corresponding to an "aggregation" relationship. In these cases a custom implementation of copying is generally required; this issue and solution dates to Smalltalk-80.{{sfn|Goldberg|Robson|1983|page=97 |ps=. "The default implementation of <code>copy</code> is <code>shallowCopy</code>. In subclasses in which copying must result in a special combination of shared and unshared variables, the method associated with copy is usually reimplemented, rather than the method associated with <code>shallowCopy</code> or <code>deepCopy</code>."}} Alternatively, fields can be marked as requiring a shallow copy or deep copy, and copy operations automatically generated (likewise for comparison operations).{{sfn|Grogono|Sakkinen|2000}} This is not implemented in most object-oriented languages, however, though there is partial support in Eiffel.{{sfn|Grogono|Sakkinen|2000}}

== Implementation ==

Nearly all [[object-oriented]] [[programming language]]s provide some way to copy objects. As most languages do not provide most objects for programs, a programmer must define how an object should be copied, just as they must define if two objects are identical or even comparable in the first place. Many languages provide some default behavior.

How copying is solved varies from language to language, and what concept of an object it has.

=== Lazy copy ===

A lazy copy is an implementation of a deep copy. When initially copying an object, a (fast) shallow copy is used. A counter is also used to track how many objects share the data. When the program wants to modify an object, it can determine if the data is shared (by examining the counter) and can do a deep copy if needed.

Lazy copy looks to the outside just as a deep copy, but takes advantage of the speed of a shallow copy whenever possible. The downside are rather high but constant base costs because of the counter. Also, in certain situations, [[circular reference]]s can cause problems.

Lazy copy is related to [[copy-on-write]].

=== In Java ===
The following presents examples for one of the most widely used object-oriented languages, [[Java (programming language)|Java]], which should cover nearly every way that an object-oriented language can treat this problem.

Unlike in C++, objects in Java are always accessed indirectly through [[reference (computer science)|references]]. Objects are never created implicitly but instead are always passed or assigned by a reference variable. (Methods in Java are always ''pass by value'', however, it is the value of the reference variable that is being passed.)<ref name="Passing Information to a Method or a Constructor">{{cite web|title=Passing Information to a Method or a Constructor|url=http://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html|access-date=8 October 2013}}</ref> The [[Java virtual machine|Java Virtual Machine]] manages [[garbage collection (computer science)|garbage collection]] so that objects are cleaned up after they are no longer reachable.  There is no automatic way to copy any given object in Java.

Copying is usually performed by a [[clone (Java method)|clone() method]] of a class. This method usually, in turn, calls the clone() method of its parent class to obtain a copy, and then does any custom copying procedures. Eventually this gets to the clone() method of <code>Object</code> (the uppermost class), which creates a new instance of the same class as the object and copies all the fields to the new instance (a "shallow copy"). If this method is used, the class must implement the {{Javadoc:SE|java/lang|Cloneable}} marker interface, or else it will [[exception handling|throw]] a "Clone Not Supported Exception". After obtaining a copy from the parent class, a class' own clone() method may then provide custom cloning capability, like deep copying (i.e. duplicate some of the structures referred to by the object) or giving the new instance a new unique ID.

The return type of clone() is <code>Object</code>, but implementers of a clone method could write the type of the object being cloned instead due to Java's support for [[covariant return types]]. One advantage of using clone() is that since it is an [[method overriding (programming)|overridable method]], we can call clone() on any object, and it will use the clone() method of its class, without the calling code needing to know what that class is (which would be needed with a copy constructor).

A disadvantage is that one often cannot access the clone() method on an abstract type. Most [[interface (object-oriented programming)|interfaces]] and [[abstract class]]es in Java do not specify a public clone() method. Thus, often the only way to use the clone() method is if the class of an object is known, which is contrary to the abstraction principle of using the most generic type possible. For example, if one has a List reference in Java, one cannot invoke clone() on that reference because List specifies no public clone() method. Implementations of List like Array List and Linked List all generally have clone() methods, but it is inconvenient and bad abstraction to carry around the class type of an object.

Another way to copy objects in Java is to [[serialization|serialize]] them through the {{Javadoc:SE|java/io|Serializable}} interface.  This is typically used for [[persistence (computer science)|persistence]] and [[wire protocol]] purposes, but it does create copies of objects and, unlike clone, a deep copy that gracefully handles cycled graphs of objects is readily available with minimal effort from a programmer.

Both of these methods suffer from a notable problem: the [[constructor (computer science)|constructor]] is not used for objects copied with clone or serialization.  This can lead to bugs with improperly initialized data, prevents the use of [[final (Java)|<code>final</code>]] member fields, and makes maintenance challenging. Some utilities attempt to overcome these issues by using reflection to deep copy objects, such as the deep-cloning library.<ref>[https://code.google.com/p/cloning/ Java deep-cloning library]</ref>

=== In Eiffel ===

Runtime objects in [[Eiffel (programming language)|Eiffel]] are accessible either indirectly through [[reference (computer science)|references]] or as ''expanded'' objects which fields are embedded within the objects that use them. That is, fields of an object are stored either [[Internal storage|externally or internally]].

The Eiffel class <code lang="eiffel">ANY</code> contains features for shallow and deep copying and cloning of objects. All Eiffel classes inherit from <code lang="eiffel">ANY</code>, so these features are available within all classes, and are applicable both to reference and expanded objects.

The <code lang="eiffel">copy</code> feature effects a shallow, field-by-field copy from one object to another. In this case no new object is created. If <code lang="eiffel">y</code> were copied to <code lang="eiffel">x</code>, then the same objects referenced by <code lang="eiffel">y</code> before the application of <code lang="eiffel">copy</code>, will also be referenced by <code lang="eiffel">x</code> after the <code lang="eiffel">copy</code> feature completes.

To effect the creation of a new object which is a shallow duplicate of <code lang="eiffel">y</code>, the feature <code lang="eiffel">twin</code> is used. In this case, one new object is created with its fields identical to those of the source.

The feature <code lang="eiffel">twin</code> relies on the feature <code lang="eiffel">copy</code>, which can be redefined in descendants of <code lang="eiffel">ANY</code>, if needed. The result of <code lang="eiffel">twin</code> is of the anchored type <code lang="eiffel">like Current</code>.

Deep copying and creating deep twins can be done using the features <code lang="eiffel">deep_copy</code> and <code lang="eiffel">deep_twin</code>, again inherited from class <code lang="eiffel">ANY</code>. These features have the potential to create many new objects, because they duplicate all the objects in an entire object structure. Because new duplicate objects are created instead of simply copying references to existing objects, deep operations will become a source of performance issues more readily than shallow operations.

=== In other languages ===
In [[C Sharp (programming language)|C#]], rather than using the interface <code>ICloneable</code>, a generic extension method can be used to create a deep copy using reflection. This has two advantages: First, it provides the flexibility to copy every object without having to specify each property and variable to be copied manually. Second, because the type is generic, the compiler ensures that the destination object and the source object have the same type.

In [[Objective-C]], the methods <code>copy</code> and <code>mutableCopy</code> are inherited by all objects and intended for performing copies; the latter is for creating a mutable type of the original object. These methods in turn call the <code>copyWithZone</code> and <code>mutableCopyWithZone</code> methods, respectively, to perform the copying. An object must implement the corresponding <code>copyWithZone</code> method to be copyable.

In [[OCaml]], the [[library (computing)|library]] function [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Oo.html#VALcopy Oo.copy] performs shallow copying of an object.

In [[Python (programming language)|Python]], the library's copy module provides shallow copy and deep copy of objects through the <code>copy()</code> and <code>deepcopy()</code> functions, respectively.<ref>[https://docs.python.org/library/copy.html Python copy module]</ref> Programmers may define special methods <code>__copy__()</code> and <code>__deepcopy__()</code> in an object to provide custom copying implementation.

In [[Ruby (programming language)|Ruby]], all objects inherit two methods for performing shallow copies, [https://docs.ruby-lang.org/en/master/Kernel.html#method-i-clone clone] and [https://docs.ruby-lang.org/en/master/Object.html#method-i-dup dup].  The two methods differ in that <code>clone</code> copies an object's tainted state, frozen state, and any [[singleton pattern|singleton]] methods it may have, whereas <code>dup</code> copies only its tainted state.  Deep copies may be achieved by dumping and loading an object's byte stream or YAML serialization.[http://www.ruby-doc.org/docs/ProgrammingRuby/html/classes.html#S5] Alternatively, you can use the deep_dive gem to do a controlled deep copy of your object graphs. [https://rubygems.org/gems/deep_dive]

In [[Perl]], nested structures are stored by the use of references, thus a developer can either loop over the entire structure and re-reference the data or use the <code lang='perl'>dclone()</code> function from the module [https://metacpan.org/module/Storable Storable].

In [[Visual Basic for Applications|VBA]], an assignment of variables of type <code>Object</code> is a shallow copy, an assignment for all other types (numeric types, String, user defined types, arrays) is a deep copy. So the keyword <code>Set</code> for an assignment signals a shallow copy and the (optional) keyword <code>Let</code> signals a deep copy. There is no built-in method for deep copies of Objects in VBA.

== See also ==
* [[Copy constructor]]
* [[Operator overloading]]
* [[Reference counting]]
* [[Copy-on-write]]
* [[Clone (Java method)]]

==Notes==
{{reflist}}

== References ==
* {{Cite book |isbn        = 978-0-201-11371-6
 |title       = Smalltalk-80: The Language and its Implementation
 |last1       = Goldberg
 |first1      = Adele
 |author-link1 = Adele Goldberg (computer scientist)
 |last2       = Robson
 |first2      = David
 |year        = 1983
 |publisher   = Xerox Palo Alto Research Center
 |location    = Palo Alto, California
 |url         = https://archive.org/details/smalltalk80langu00gold

 |url-access  = registration
}}
* {{Cite conference |title= Copying and Comparing: Problems and Solutions |last1= Grogono |first1= Peter |last2= Sakkinen |first2= Markku |conference= ECOOP 2000 — Object-Oriented Programming |date= 12 May 2000 |editor= Elisa Bertino |book-title= Lecture Notes in Computer Science |volume= 1850 
 |pages= 226–250 |publisher= Springer Berlin Heidelberg |doi= 10.1007/3-540-45102-1_11 |url= http://users.encs.concordia.ca/~grogono/Writings/CopyCompare.pdf |access-date= 2015-06-23}}

{{DEFAULTSORT:Object Copy}}
[[Category:Object (computer science)]]