language agnostic – What’s the difference between death by referral vs. passing by value?

Numerous answers here (and in specific the most extremely upvoted answer) are factually inaccurate, because they misinterpret what “call by recommendation” really suggests. Here's my attempt to set matters directly.

TL; DR

In simplest terms:

• call by worth means that you pass worths as function arguments
• call by reference means that you pass variables as function arguments

In metaphoric terms:

• Call by value is where I make a note of something on a paper and hand it to you. Possibly it's a URL, possibly it's a complete copy of War and Peace. No matter what it is, it's on a piece of paper which I have actually offered to you, therefore now it is successfully your notepad. You are now free to doodle on that paper, or utilize that notepad to find something elsewhere and fiddle with it, whatever.
• Call by recommendation is when I give you my notebook which has something written down in it. You may scribble in my note pad (perhaps I desire you to, perhaps I do not), and afterwards I keep my note pad, with whatever doodles you've put there. Likewise, if what either you or I composed there is information about how to discover something elsewhere, either you or I can go there and fiddle with that information.

What “call by value” and “call by reference” do not imply

Note that both of these principles are entirely independent and orthogonal from the principle of recommendation types (which in Java is all types that are subtypes of Things, and in C# all class types), or the concept of guideline types like in C (which are semantically equivalent to Java's “referral types”, merely with different syntax).

The concept of referral type represents a URL: it is both itself a piece of details, and it is a recommendation (a pointer, if you will) to other info. You can have many copies of a URL in various locations, and they do not alter what site they all link to; if the website is updated then every URL copy will still result in the updated details. Alternatively, changing the URL in any one place will not affect any other composed copy of the URL.

Keep in mind that C++ has a notion of “references” (e.g. int &) that is not like Java and C#'s “referral types”, however is like “call by recommendation”. Java and C#'s “recommendation types”, and all types in Python, resemble what C and C++ call “guideline types” (e.g. int *).

OK, here's the longer and more formal description.

Terminology

To start with, I want to highlight some crucial little bits of terminology, to assist clarify my response and to ensure we're all describing the exact same concepts when we are utilizing words. (In practice, I believe the vast bulk of confusion about subjects such as these comes from utilizing words in manner ins which to not completely interact the meaning that was intended.)

To start, here's an example in some C-like language of a function statement:

void foo(int param)

And here's an example of calling this function:

void bar()

Using this example, I want to specify some essential little bits of terms:

• foo is a function declared on line 1 (Java insists on making all functions approaches, but the idea is the same without loss of generality; C and C++ make a difference in between declaration and definition which I will not enter into here)
• param is a official specification to foo, likewise declared on line 1
• arg is a variable, particularly a local variable of the function bar, declared and initialized on line 2
• arg is also an argument to a particular invocation of foo on line 3

There are 2 really important sets of concepts to differentiate here. The very first is worth versus variable:

• A worth is the result of evaluating an expression in the language. For instance, in the bar function above, after the line int arg = 1;, the expression arg has the worth 1.
• A variable is a container for worths. A variable can be mutable (this is the default in a lot of C-like languages), read-only (e.g. declared using Java's last or C#'s readonly) or deeply immutable (e.g. using C++'s const).

The other important set of ideas to differentiate is specification versus argument:

• A specification (likewise called a formal parameter) is a variable which need to be provided by the caller when calling a function.
• An argument is a value that is supplied by the caller of a function to please a particular formal parameter of that function

Call by value

In call by worth, the function's official specifications vary that are newly created for the function invocation, and which are initialized with the worths of their arguments.

This works exactly the same way that any other type of variables are initialized with values. For instance:

int arg = 1; int another_variable = arg;

Here arg and another_variable are completely independent variables– their values can alter independently of each other. Nevertheless, at the point where another_variable is stated, it is initialized to hold the exact same value that arg holds– which is 1.

Since they are independent variables, modifications to another_variable do not impact arg:

int arg = 1; int another_variable = arg; another_variable = 2; assert arg == 1;// real assert another_variable == 2;// true

This is exactly the like the relationship between arg and param in our example above, which I'll repeat here for proportion:

void foo(int param) void bar()

It is precisely as if we had actually written the code this way:

// getting in function “bar” here int arg = 1;// going into function “foo” here int param = arg; param += 1;// leaving function “foo” here// exiting function “bar” here

That is, the specifying attribute of what call by value methods is that the callee (foo in this case) gets values as arguments, however has its own different variables for those values from the variables of the caller (bar in this case).

Returning to my metaphor above, if I'm bar and you're foo, when I call you, I hand you a piece of paper with a worth composed on it. You call that notepad param. That worth is a copy of the worth I have actually written in my note pad (my regional variables), in a variable I call arg.

(As an aside: depending on hardware and operating system, there are different calling conventions about how you call one function from another. The calling convention is like us choosing whether I compose the worth on a piece of my paper and after that hand it to you, or if you have a piece of paper that I compose it on, or if I compose it on the wall in front of both of us. This is a fascinating topic too, however far beyond the scope of this already long answer.)

Call by reference

In call by reference, the function's formal specifications are just brand-new names for the same variables that the caller supplies as arguments.

Going back to our example above, it's comparable to:

// going into function “bar” here int arg = 1;// going into function “foo” here// aha! I keep in mind that “param” is just another name for “arg” arg/ * param */ += 1;// exiting function “foo” here// leaving function “bar” here

Because param is just another name for arg– that is, they are the same variable, modifications to param are shown in arg. This is the basic method which call by reference differs from call by worth.

Extremely couple of languages support call by recommendation, however C++ can do it like this:

void foo(int & param) void bar()

In this case, param does not just have the same value as arg, it really is arg (just by a different name) therefore bar can observe that arg has been incremented.

Keep in mind that this is not how any of Java, JavaScript, C, Objective-C, Python, or nearly any other popular language today works. This suggests that those languages are not call by reference, they are call by value.

Addendum: call by object sharing

If what you have is call by worth, but the real worth is a referral type or pointer type, then the “value” itself isn't really fascinating (e.g. in C it's just an integer of a platform-specific size)– what's intriguing is what that value points to.

If what that reference type (that is, pointer) indicate is mutable then an intriguing effect is possible: you can modify the pointed-to value, and the caller can observe modifications to the pointed-to worth, although the caller can not observe modifications to the pointer itself.

To borrow the analogy of the URL again, the reality that I offered you a copy of the URL to a site is not particularly interesting if the thing we both appreciate is the site, not the URL. The reality that you doodling over your copy of the URL doesn't impact my copy of the URL isn't a thing we appreciate (and in reality, in languages like Java and Python the “URL”, or reference type value, can't be customized at all, only the important things indicated by it can).

Barbara Liskov, when she created the CLU programming language (which had these semantics), recognized that the existing terms “call by value” and “call by recommendation” weren't especially beneficial for explaining the semantics of this brand-new language. So she created a brand-new term: call by item sharing.

When going over languages that are technically call by value, but where typical key ins use are referral or guideline types (that is: nearly every modern-day necessary, object-oriented, or multi-paradigm programs language), I discover it's a lot less confusing to simply avoid talking about call by worth or call by reference. Stick to call by object sharing (or just call by things) and nobody will be confused.:–RRB- Source