It is important to realise that everything in C# is passed by value, unless you specify ref or out in the signature. What makes value types (and hence structs) different from reference types is that a value type is accessed directly, while a reference type is accessed via its reference. If you pass a reference … Read more
As Rytmis said, Java passes references by value. What this means is that you can legitimately call mutating methods on the parameters of a method, but you cannot reassign them and expect the value to propagate. Example: private void goodChangeDog(Dog dog) { dog.setColor(Color.BLACK); // works as expected! } private void badChangeDog(Dog dog) { dog = … Read more
Java always passes arguments by value, NOT by reference. In your example, you are still passing obj by its value, not the reference itself. Inside your method changeName, you are assigning another (local) reference, obj, to the same object you passed it as an argument. Once you modify that reference, you are modifying the original … Read more
Whilst something like this does what you expect: void func(int *p) { *p = 1; } int a = 2; func(&a); // a is now 1 this does not void func(int *p) { p = new int; } int *p = NULL; func(p); // p is still NULL In both cases, the function works with … Read more
My take on it: It’s not a bad idea, but the issue is minor and your energy might be better spent on other things. In your question you provided a good example of when it might catch an error, but occasionally you also end up doing something like this: void foo(const int count /* … … Read more
I found myself disagreeing with the highest-voted answer, so I went looking for expert opinons and here they are. From http://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2011-Scott-Andrei-and-Herb-Ask-Us-Anything Herb Sutter: “when you pass shared_ptrs, copies are expensive” Scott Meyers: “There’s nothing special about shared_ptr when it comes to whether you pass it by value, or pass it by reference. Use exactly the … Read more
There’s an extended discussion of how Java passes variables at an earlier question “Is Java pass by reference?”. Java really passes object references by value. In your code, the references for the arrays (which are objects) are passed into calculate(). These references are passed by value, which means that any changes to the values of … Read more
The intent seems to be to differenciate between invocations with temporaries (i.e. 9) and ‘regular’ argument passing. The first case may allow the function implementation to employ optimizations since it is clear that the arguments will be disposed afterwards (which is absolutely senseless for integer literals, but may make sense for user-defined objects). However, the … Read more
There is no pythonic way of doing this. Python provides very few facilities for enforcing things such as private or read-only data. The pythonic philosophy is that “we’re all consenting adults”: in this case this means that “the function shouldn’t change the data” is part of the spec but not enforced in the code. If … Read more
It depends on what you mean by “cost”, and properties of the host system (hardware, operating system) with respect to operations. If your cost measure is memory usage, then the calculation of cost is obvious – add up the sizes of whatever is being copied. If your measure is execution speed (or “efficiency”) then the … Read more