There are four main cases where you should use pass-by-reference over pass-by-value: If you are calling a function that needs to modify its arguments, use pass-by-reference or pass-by-pointer. Otherwise, you’ll get a copy of the argument. If you’re calling a function that needs to take a large object as a parameter, pass it by const … Read more
Object-oriented programming is done best if you structure your code into clean, understandable abstractions. Numbers, as an abstraction, are immutable and have no identity (i.e. a “five” is always a “five” and there is no such thing as “multiple instances of five”). What you’re trying to invent is a “mutable number” which is mutable and … Read more
You cannot bind a literal to an lvalue reference to non-const (because modifying the value of a literal is not an operation that makes sense). You can however bind a literal to a reference to const. So this will compile if you declare fillRect as: void fillRect(int const& x, int const& y, int const& width, … Read more
A reference is not a pointer, they’re different although they serve similar purpose. You can think of a reference as an alias to another variable, i.e. the second variable having the same address. It doesn’t contain address itself, it just references the same portion of memory as the variable it’s initialized from. So string s … Read more
If you know what you’re doing, you can make a vector of references using std::reference_wrapper: #include <functional> #include <vector> int main() { std::vector<std::reference_wrapper<int>> iv; int a = 12; iv.push_back(a); // or std::ref(a) // now iv = { 12 }; a = 13; // now iv = { 13 }; } Note of course that any … Read more
Java always passes arguments by value NOT by reference. Let me explain this through an example: public class Main { public static void main(String[] args) { Foo f = new Foo(“f”); changeReference(f); // It won’t change the reference! modifyReference(f); // It will modify the object that the reference variable “f” refers to! } public static … 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
I tried to use Array.filter() function, but it returns a new array instead of a reference to the original array. which I can not use to mutate the original array. It returns a new array, but the array’s entries are still references to the same objects. So filter is just fine for this. var filteredUsers … Read more
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