You can do it for a const reference, but not for a non-const one. This is because C++ does not allow a temporary (the default value in this case) to be bound to non-const reference. One way round this would be to use an actual instance as the default: static int AVAL = 1; void … Read more
For function parameter operator we use: let (it’s default operator, so we can omit let) to make a parameter constant (it means we cannot modify even local copy); var to make it variable (we can modify it locally, but it wont affect the external variable that has been passed to the function); and inout to … Read more
You have three options: Use a StringBuilder: StringBuilder zText = new StringBuilder (); void fillString(StringBuilder zText) { zText.append (“foo”); } Create a container class and pass an instance of the container to your method: public class Container { public String data; } void fillString(Container c) { c.data += “foo”; } Create an array: new String[] … Read more
When you compile a number literal in Java and assign it to a Integer (capital I) the compiler emits: Integer b2 =Integer.valueOf(127) This line of code is also generated when you use autoboxing. valueOf is implemented such that certain numbers are “pooled”, and it returns the same instance for values smaller than 128. From the … Read more
You can change what foo points to using y: Foo foo = new Foo(“1”); void Bar(ref Foo y) { y = new Foo(“2”); } Bar(ref foo); // foo.Name == “2”
It used to be generally recommended best practice1 to use pass by const ref for all types, except for builtin types (char, int, double, etc.), for iterators and for function objects (lambdas, classes deriving from std::*_function). This was especially true before the existence of move semantics. The reason is simple: if you passed by value, … Read more
Because you’re passing the value of the pointer to the method and then dereferencing it to get the integer that is pointed to.
Rules of thumb for C++11: Pass by value, except when you do not need ownership of the object and a simple alias will do, in which case you pass by const reference, you must mutate the object, in which case, use pass by a non-const lvalue reference, you pass objects of derived classes as base … Read more
Passing by pointer Caller has to take the address -> not transparent A 0 value can be provided to mean nothing. This can be used to provide optional arguments. Pass by reference Caller just passes the object -> transparent. Has to be used for operator overloading, since overloading for pointer types is not possible (pointers … Read more
The other answerers are all correct, but a friend asked me to explain this to him and what it really boils down to is how Ruby handles variables, so I thought I would share some simple pictures / explanations I wrote for him (apologies for the length and probably some oversimplification): Q1: What happens when … Read more