To get a shallow copy, just use the constructor of Dictionary<TKey, TValue> as it takes an IEnumerable<KeyValuePair<TKey, TValue>>. It will add this collection into the new instance. Dictionary<int, int> flagsn = new Dictionary<int, int>(flags);
[:] creates a slice, usually used to get just a part of a list. Without any minimum/maximum index given, it creates a copy of the entire list. Here’s a Python session demonstrating it: >>> a = [1,2,3] >>> b1 = a >>> b2 = a[:] >>> b1.append(50) >>> b2.append(51) >>> a [1, 2, 3, 50] … Read more
Use the constructor: HashSet<type> set2 = new HashSet<type>(set1); Personally I wish LINQ to Objects had a ToHashSet extension method as it does for List and Dictionary. It’s easy to create your own of course: public static HashSet<T> ToHashSet<T>(this IEnumerable<T> source) { if (source == null) { throw new ArgumentNullException(“source”); } return new HashSet<T>(source); } (With … Read more
So, for this problem, you have to understand what is the shallow copy and deep copy. Shallow copy is a bit-wise copy of an object which makes a new object by copying the memory address of the original object. That is, it makes a new object by which memory addresses are the same as the … 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
[:] 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
According to the Standard, if no copy constructor is provided by the programmer for a class, the compiler will synthesize a constructor which exhibits default memberwise initialization. (12.8.8) However, in 12.8.1, the Standard also says, A class object can be copied in two ways, by initialization (12.1, 8.5), including for function argument passing (5.2.2) and … Read more
I’d say, default operator= is a copy. It copies each member. The distinction between a shallow copy and a deep copy doesn’t arise unless the members being copied are some kind of indirection such as a pointer. As far as the default operator= is concerned, it’s up to the member being copied what “copy” means, … 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
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