in the java world, pass value to method … (this strategy more like your article “call by reference”, but it is called pass by value)

Yes, in Java the terminology “by-value” is used. But the semantics is what is described in this article as “by-sharing”. As noticed above in the last paragraph terminology versions, both terminologies can be used: either “by-sharing” or “by-value when the value is the reference”.

Hi Dmitry

Yes, but do you know a language where all function arguments are by reference. So for example,

function f(x) {
  x = 5
};

a = 10;
f(a);
and now a = 5.

It would be a weird language to work with.

Morten.

C# can do this

 function f(ref x) {
    x = 5;
 }
 a = 10;
 f(a); 

a will be the 5

Java can call by sharing?I doubt…

http://www.javaworld.com/javaworld/javaqa/2000-05/03-qa-0526-pass.html

Nope, I’m not aware about such a language. Seems, it wouldn’t be very useful

Dmitry.

Yes, but do you know a language where all function arguments are by reference. So for example,

function f(x) {
  x = 5
};

a = 10;
f(a);

and now a = 5.

It would be a weird language to work with.

Morten.

Are there languages that use call by reference?

First, we should understand that mentioned strategies are just abstract descriptions.

However, in some languages, the concept and the exact meaning of a reference can vary. The nearest example of by-reference strategy can be shown with C++ and its reference sugar:

// C++

void call_by_reference(int& x)
{
  x = 20; // external *mutation*
}

void call_by_pointer(int* x)
{
  *x = 20; // also external *mutation*
  x = new int; // and this is already *rebinding*
  *x = 30; // mutation of the other memory block
}

void call_by_value(int x)
{
  x = 20; // just local mutation
}

int _tmain(int argc, _TCHAR* argv[])
{
  int y = 0;

  call_by_reference(y);
  call_by_pointer(&y);
  call_by_value(y);

  return 0;
}

Thus, as said, this by-reference of C++ is just a syntactic sugar (in general, and if to see the assembly generated code) for the by-pointer (which is described above by-sharing) strategy — i.e. for not to dereference a pointer every time.

The main point is in the operation of assignment. Because often enough there are questions on JS such as “Why if an object is passed by reference I can’t replace it via assignment?”. The answer is — it’s not by-reference (from C++ viewpoint), but “by-pointer” (or “by-value, where value is an address”), where assignment (without dereferencing) just changes the pointer’s address.

Also take a look on this explanation of a name binding concept, which also accurately explains the difference. Thus, the assignment means a rebinding. And changing of a properties means mutation.

Dmitry.

Very good Javascript series. Excellent. I have read several of
your articles, and they are really good.

One question about this article. Are there languages that use
call by reference? You don’t give any examples. The closest I
could think of is in C by using pointers to pointers.

int f(struct example **x)
{
  *x = malloc(sizeof **x);
  ......
}

or you could wrap a struct inside a struct.

But are there languages with more direct examples, where f(x) would really be by reference?

Morten.