shallow-copy

This error occurs during run time, and I'm not sure what's causing it - the code looks correct to me. #include <iostream> #include <string> using namespace std; struct Room { int d_noSeat; bool d_hasProjector; Room() = default; Room(const Room& r); }; class Event { Room* d_room; std::string d_name; public: Event(); Event(const Event& e); ~Event(); void set(Room r, const std::string& name); void print(); }; Event::Event() : d_room(0), d_name("") {}; void Event::print() { std::cout << "Event: " << d_name; if (d_room != 0) { std::cout << " in size " << d_room->d_noSeat; if (d_room->d_hasProjector

As per the JAVA documentation, the super.clone() when called returns a shallow copy of the object. In the code below I have two objects name and id ; and one primitive variable num . When the super.clone() method is called on the first object, it seems to be creating a deep copy of the objects(name and id) in addition to an expected copy of only num. After cloning the object obj, I have changed its name and id fields. These changes should be reflected in the cloned object if a shallow copy was being made. Am I right? public class Cloning implements Cloneable { String name; int num; Integer id;

Lets say I have this class public class Employee { public string FirstName { get; set; } public string LastName { get; set; } public bool isActive { get; set; } } And use it like this: List<Employee> Employees = new List<Employee>(); Employees.Add(new Employee { FirstName = "firstname", LastName = "lastname", isActive = true }); List<Employee> EmployeesCopy = new List<Employee>(Employees); EmployeesCopy[0].isActive = false; Why does change in isActive property of EmployeesCopy also modify property in the original list? Because the new list still contains references to the same employee objects

I have a structure containing character arrays with no any other member functions. I am doing assignment operation between two instances of these structures. If I'm not mistaken, it is doing shallow copy. Is shallow copy safe in this case? I've tried this in C++ and it worked but I would just like to confirm if this behavior is safe. Alok Singhal If by "shallow copy", you mean that after assignment of a struct containing an array, the array would point to the original struct 's data, then: it can't. Each element of the array has to be copied over to the new struct . "Shallow copy" comes into

This should be a fairly common question, but I haven't found a straightforward answer anywhere. If I instantiate an object within a function in VB.NET and return it, does it return it by reference or by value. IE - should I be worried about performance if I write something like this: Public Function ret_obj_func() As big_object Dim ret_obj As New big_obj(<lots of stuff>) Return ret_obj End Function If I call this function from somewhere else, will it instantiate the object in the ret_obj and then create a deep copy to pass back a copy to the caller, Or will it just pass back a reference? It

I have a general question about deep- and shallow-copy in the context of the pass-by-reference- and pass-by-value-concept of C#: In C# it is a requirement to explicitly create methods that accept pointers/references to be able to pass such to the method. However, at least objects passed as parameters to methods/constructors are behaving differently from the rest. It seems they are always passed by reference if no extra cloning is done as described here: http://zetcode.com/lang/csharp/oopii/ . Why are objects automatically passed by reference? Is there any particular benefit from forcing the