Firstly, you never set an object to null. That concept has no meaning. You can assign a value of null to a variable, but you need to distinguish between the concepts of “variable” and “object” very carefully. Once you do, your question will sort of answer itself 🙂 Now in terms of “shallow copy” vs … Read more
On small embedded architectures (8/16-bitters) — always pass by pointer, as non-trivial structures don’t fit into such tiny registers, and those machines are generally register-starved as well. On PC-like architectures (32 and 64 bit processors) — passing a structure by value is OK provided sizeof(mystruct_t) <= 2*sizeof(mystruct_t*) and the function does not have many (usually … Read more
No. A shallow copy in this particular context means that you copy “references” (pointers, whatever) to objects, and the backing store of these references or pointers is identical, it’s the very same object at the same memory location. A deep copy, in contrast, means that you copy an entire object (struct). If it has members … Read more
Does anyone know what I am doing wrong? Trying to use assignment to copy a struct with a flexible array member. From the standard (6.7.2.1): The assignment *s1 = *s2 only copies the member n [i.e. the part of the struct that isn’t a flexible array]; if any of the array elements are within the … Read more
[:] Shallow copies the list, making a copy of the list structure containing references to the original list members. This means that operations on the copy do not affect the structure of the original. However, if you do something to the list members, both lists still refer to them, so the updates will show up … Read more
From the link here Shallow copies duplicate as little as possible. A shallow copy of a collection is a copy of the collection structure, not the elements. With a shallow copy, two collections now share the individual elements. Deep copies duplicate everything. A deep copy of a collection is two collections with all of the … Read more
Forget about deep copy, even shallow copy isn’t safe, if the object you’re copying has a property with enumerable attribute set to false. MDN : The Object.assign() method only copies enumerable and own properties from a source object to a target object take this example var o = {}; Object.defineProperty(o,’x’,{enumerable: false,value : 15}); var ob={}; … Read more
EVERYTHING in python are objects, and python never makes copies unless explicity asked to do so. When you do innerList = [0] * 10 you create a list with 10 elements, all of them refering to the same int object 0. Since integer objects are immutable, when you do innerList[1] = 15 You are changing … Read more
slice does not alter the original array. It returns a shallow copy of elements from the original array. Elements of the original array are copied into the returned array as follows: For object references (and not the actual object), slice copies object references into the new array. Both the original and new array refer to … Read more
Forget about deep copy, even shallow copy isn’t safe, if the object you’re copying has a property with enumerable attribute set to false. MDN : The Object.assign() method only copies enumerable and own properties from a source object to a target object take this example var o = {}; Object.defineProperty(o,’x’,{enumerable: false,value : 15}); var ob={}; … Read more