I always thought Java uses **pass-by-reference**.

However, I&#39;ve seen [a blog post][1] that claims that Java uses **pass-by-value**.

I don&#39;t think I understand the distinction they&#39;re making.

What is the explanation?

  [1]: http://javadude.com/articles/passbyvalue.htm


Is Java &quot;pass-by-reference&quot; or &quot;pass-by-value&quot;?

In C#, I have always thought that non-primitive variables were passed by reference and primitive values passed by value.

So when passing to a method any non-primitive object, anything done to the object in the method would effect the object being passed. (C# 101 stuff)

However, I have noticed that when I pass a System.Drawing.Image object, that this does not seem to be the case? If I pass a system.drawing.image object to another method, and load an image onto that object, then let that method go out of scope and go back to the calling method, that image is not loaded on the original object?

Why is this?

Passing Objects By Reference or Value in C#

I found myself confused with the `array` and `slice` data types.

From Go docs, arrays are described as follows:

&gt; There are major differences between the ways arrays work in Go and C. In Go,
&gt;
&gt; - Arrays are values. Assigning one array to another copies all the elements.
&gt; - In particular, if you pass an array to a function, it will receive a copy of the array, not a pointer to it.
&gt; - The size of an array is part of its type. The types [10]int and [20]int are distinct.

Functions:

&gt; As in all languages in the C family, everything in Go is passed by
&gt; value. That is, a function always gets a copy of the thing being
&gt; passed, as if there were an assignment statement assigning the value
&gt; to the parameter. For instance, passing an int value to a function
&gt; makes a copy of the int, and passing a pointer value makes a copy of
&gt; the pointer, but not the data it points to.

Why does `sort.Ints(arrayValue)` modify the passed variable when I declared it as an array, not as a slice?

Code

    var av = []int{1,5,2,3,7}
      
    fmt.Println(av)
    sort.Ints(av)
    fmt.Println(av)
    return

Output

    [1 5 2 3 7]
    [1 2 3 5 7]

Array and slice data types

&gt; **Possible Duplicate:**  
&gt; [Is Java “pass-by-reference”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference)  

&lt;!-- End of automatically inserted text --&gt;

I found an unusual Java method today:

    private void addShortenedName(ArrayList&lt;String&gt; voiceSetList, String vsName)
    {
         if (null == vsName)
           vsName = &quot;&quot;;
         else
           vsName = vsName.trim();
         String shortenedVoiceSetName = vsName.substring(0, Math.min(8, vsName.length()));
         //SCR10638 - Prevent export of empty rows.
         if (shortenedVoiceSetName.length() &gt; 0)
         {
           if (!voiceSetList.contains(&quot;#&quot; + shortenedVoiceSetName))
             voiceSetList.add(&quot;#&quot; + shortenedVoiceSetName);
         }
    }

According to everything I&#39;ve read about Java&#39;s behavior for passing variables, complex objects or not, this code should do exactly nothing.  So um...am I missing something here?  Is there some subtlety that was lost on me, or does this code belong on thedailywtf?

Java is NEVER pass-by-reference, right?...right?

1) When an array is passed as an argument to a method or function, is it passed by reference, or by value?

2) When assigning an array to a variable, is the new variable a reference to the original array, or is it new copy?  
What about doing this:

    $a = array(1,2,3);
    $b = $a;

Is `$b` a reference to `$a`?

Are arrays in PHP copied as value or as reference to new variables, and when passed to functions?

When learning a new programming language, one of the possible roadblocks you might encounter is the question whether the language is, by default, *pass-by-value or pass-by-reference*.

So here is my question to all of you, in your favorite language, *how* is it actually done? And what are the *possible pitfalls*?

Your favorite language can, of course, be anything you have ever played with: [popular][1], [obscure][2], [esoteric][3], [new][4], [old][5]...

  [1]: http://www.ruby-lang.org/en/
  [2]: http://www.devtopics.com/a-obscure-programming-language-of-the-month/
  [3]: http://en.wikipedia.org/wiki/Brainfuck
  [4]: http://www.nvidia.com/object/cuda_get.html
  [5]: http://en.wikipedia.org/wiki/FORTRAN

Pass by reference or pass by value?

Are PHP variables passed by value or by reference?

Are PHP Variables passed by value or by reference?

I am new to C++ programming, but I have experience in Java. I need guidance on how to pass objects to functions in C++.

Do I need to pass pointers, references, or non-pointer and non-reference values? I remember in Java there are no such issues since we pass just the variable that holds reference to the objects.

It would be great if you could also explain where to use each of those options.

How to pass objects to functions in C++?

Is it better in C++ to pass by value or pass by constant reference?

I am wondering which is better practice.  I realize that pass by constant reference should provide for better performance in the program because you are not making a copy of the variable.  

Is it better in C++ to pass by value or pass by constant reference?

I understand that if I pass a value-type (`int`, `struct`, etc.) as a parameter (without the `ref` keyword), a copy of that variable is passed to the method, but if I use the `ref` keyword a reference to that variable is passed, not a new one.

But with reference-types, like classes, even without the `ref` keyword, a reference is passed to the method, not a copy. So what is the use of the `ref` keyword with reference-types?

----------

Take for example:

    var x = new Foo();

What is the difference between the following?

    void Bar(Foo y) {
        y.Name = &quot;2&quot;;
    }

and

    void Bar(ref Foo y) {
        y.Name = &quot;2&quot;;
    }


What is the use of &quot;ref&quot; for reference-type variables in C#?

    class D {
        public static void main(String args[]) {
            Integer b2=128;
            Integer b3=128;
            System.out.println(b2==b3);
        }
    }


Output:

    false


----------


    class D {
        public static void main(String args[]) {
            Integer b2=127;
            Integer b3=127;
            System.out.println(b2==b3);
        }
    }

Output:

    true

Note: Numbers between -128 and 127 are true.

Why is 128==128 false but 127==127 is true when comparing Integer wrappers in Java?

What is the difference between 

1. a parameter passed by reference
2. a parameter passed by value?

Could you give me some examples, please?

What&#39;s the difference between passing by reference vs. passing by value?

If I pass a dataframe to a function and modify it inside the function, is it pass-by-value or pass-by-reference?

I run the following code

    a = pd.DataFrame({&#39;a&#39;:[1,2], &#39;b&#39;:[3,4]})
    def letgo(df):
        df = df.drop(&#39;b&#39;,axis=1)
    letgo(a)

the value of `a` does not change after the function call. Does it mean it is pass-by-value?

I also tried the following

    xx = np.array([[1,2], [3,4]])
    def letgo2(x):
        x[1,1] = 100
    def letgo3(x):
        x = np.array([[3,3],[3,3]])
It turns out `letgo2()` does change `xx` and `letgo3()` does not. Why is it like this?

python pandas dataframe, is it pass-by-value or pass-by-reference

I&#39;m really new to Swift and I just read that classes are passed by reference and arrays/strings etc. are copied.

Is the pass by reference the same way as in Objective-C or Java wherein you actually pass &quot;a&quot; reference or is it proper pass by reference?

Is Swift Pass By Value or Pass By Reference

How can I pass an integer by reference in Python?

I want to modify the value of a variable that I am passing to the function. I have read that everything in Python is pass by value, but there has to be an easy trick. For example, in Java you could pass the reference types of `Integer`, `Long`, etc.

 1. How can I pass an integer into a function by reference?
 2. What are the best practices?



Passing an integer by reference in Python

Here is a simplified version of something I&#39;m trying to run:

    for (var i = 0; i &lt; results.length; i++) {
        marker = results[i];
        google.maps.event.addListener(marker, &#39;click&#39;, function() { 
            change_selection(i);
        }); 
    }

but I&#39;m finding that every listener uses the value of results.length (the value when the for loop terminates). How can I add listeners such that each uses the value of i at the time I add it, rather than the reference to i? 

How do I pass the value (not the reference) of a JS variable to a function?

If I have a function that needs to work with a `shared_ptr`, wouldn&#39;t it be more efficient to pass it a reference to it (so to avoid copying the `shared_ptr` object)?
What are the possible bad side effects?
I envision two possible cases:

1) inside the function a copy is made of the argument, like in

    ClassA::take_copy_of_sp(boost::shared_ptr&lt;foo&gt; &amp;sp)  
    {  
         ...  
         m_sp_member=sp; //This will copy the object, incrementing refcount  
         ...  
    }  

2) inside the function the argument is only used, like in  
    
    Class::only_work_with_sp(boost::shared_ptr&lt;foo&gt; &amp;sp) //Again, no copy here  
    {    
        ...  
        sp-&gt;do_something();  
        ...  
    }  

I can&#39;t see in both cases a good reason to pass the `boost::shared_ptr&lt;foo&gt;` by value instead of by reference. Passing by value would only &quot;temporarily&quot; increment the reference count due to the copying, and then decrement it when exiting the function scope.
Am I overlooking something?

Just to clarify, after reading several answers: I perfectly agree on the premature-optimization concerns, and I always try to first-profile-then-work-on-the-hotspots. My question was more from a purely technical code-point-of-view, if you know what I mean.

C++ - passing references to std::shared_ptr or boost::shared_ptr

In Go, I am trying to make a scramble slice function for my traveling salesman problem. While doing this I noticed when I started editing the slice I gave the scramble function was different every time I passed it in.

After some debugging I found out it was due to me editing the slice inside the function. But since Go is supposed to be a &quot;pass by value&quot; language, how is this possible? 

https://play.golang.org/p/mMivoH0TuV

I have provided a playground link to show what I mean.
By removing line 27 you get a different output than leaving it in, this should not make a difference since the function is supposed to make its own copy of the slice when passed in as an argument.  
Can someone explain the phenomenon?

Are slices passed by value?

I was reading my C++ book (Deitel) when I came across a function to calculate the volume of a cube. The code is the following:

    double cube (const double side){
        return side * side * side;
    }

The explanation for using the &quot;const&quot; qualifier was this one: &quot;The const qualified should be used to enforce the principle of least privilege, telling the compiler that the function does not modify variable side&quot;.

**My question**: isn&#39;t the use of &quot;const&quot; redundant/unnecessary here since the variable is being passed by value, so the function can&#39;t modify it anyway?

Isn&#39;t &quot;const&quot; redundant when passing by value?

Does JavaScript pass by references or pass by values?

Here is an example from *[JavaScript: The Good Parts][1]*. I am very confused about the `my` parameter for the rectangle function. It is actually `undefined`, and redefined inside the function. There are no original reference. If I remove it from the function parameter, the inside area function is not able to access it.

Is it a closure? But no function is returned.

    var shape = function (config) {
        var that = {};
        that.name = config.name || &quot;&quot;;
        that.area = function () {
            return 0;
        };
        return that;
    };

    var rectangle = function (config, my) {
        my = my || {};
        my.l = config.length || 1;
        my.w = config.width || 1;
        var that = shape(config);
        that.area = function () {
            return my.l * my.w;
        };
        return that;
    };

    myShape = shape({
        name: &quot;Unhnown&quot;
    });

    myRec = rectangle({
        name: &quot;Rectangle&quot;,
        length: 4,
        width: 6
    });

    console.log(myShape.name + &quot; area is &quot; + myShape.area() + &quot; &quot; + myRec.name + &quot; area is &quot; + myRec.area());

  [1]: https://en.wikipedia.org/wiki/Douglas_Crockford#Bibliography





Does JavaScript pass by reference?

I can&#39;t understand where the `final` keyword is *really* handy when it is used on method parameters.  

If we exclude the usage of anonymous classes, readability and intent declaration then it seems almost worthless to me. 

Enforcing that some data remains constant is not as strong as it seems. 

- If the parameter is a primitive then it will have no effect since the parameter is passed to the method as a value and changing it will have no effect outside the scope. 

- If we are passing a parameter by reference, then the reference itself is a local variable and if the reference is changed from within the method, that would not have any effect from outside of the method scope. 

Consider the simple test example below.
This test passes although the method changed the value of the reference given to it, it has no effect.

    public void testNullify() {
        Collection&lt;Integer&gt; c  = new ArrayList&lt;Integer&gt;();		
        nullify(c);
        assertNotNull(c);		
        final Collection&lt;Integer&gt; c1 = c;
        assertTrue(c1.equals(c));
        change(c);
        assertTrue(c1.equals(c));
    }

    private void change(Collection&lt;Integer&gt; c) {
        c = new ArrayList&lt;Integer&gt;();
    }

    public void nullify(Collection&lt;?&gt; t) {
        t = null;
    }


Why should I use the keyword &quot;final&quot; on a method parameter in Java?

Every once in a while I come across the notion that R has **copy-on-modify semantics**, for example in [Hadley&#39;s devtools wiki](https://github.com/hadley/devtools/wiki/Functions).

&gt; Most R objects have copy-on-modify semantics, so modifying a function
&gt; argument does not change the original value


I can trace this term back to the R-Help mailing list.  For example, Peter Dalgaard wrote in [July 2003](https://stat.ethz.ch/pipermail/r-help/2003-July/036437.html):

&gt; R is a functional language, with lazy evaluation and weak dynamic
&gt; typing (a variable can change type at will: a &lt;- 1 ; a &lt;- &quot;a&quot; is
&gt; allowed). Semantically, everything is copy-on-modify although some
&gt; optimization tricks are used in the implementation to avoid the worst
&gt; inefficiencies.

Similarly, Peter Dalgaard wrote in [Jan 2004](http://tolstoy.newcastle.edu.au/R/help/04/01/0331.html):

 
&gt; R has copy-on-modify semantics (in principle and sometimes in 
&gt; practice) so once part of an object changes, you may have to look in 
&gt; new places for anything that contained it, including possibly the 
&gt; object itself.

Even further back, in [Feb 2000](https://stat.ethz.ch/pipermail/r-help/2000-February/009952.html) Ross Ihaka said:

&gt; We put quite a bit of work into making this happen.  I would describe
&gt; the semantics as &quot;copy on modify (if necessary)&quot;.  Copying is done
&gt; only when objects are modified.  The (if necessary) part means that if
&gt; we can prove that the modification cannot change any non-local
&gt; variables then we just go ahead and modify without copying.

**It&#39;s not in the manual**

No matter how hard I&#39;ve searched, I can&#39;t find a reference to &quot;copy-on-modify&quot; in the [R manuals](http://cran.r-project.org/manuals.html), neither in [R Language Definition](http://cran.r-project.org/doc/manuals/r-release/R-lang.html) nor in [R Internals](http://cran.r-project.org/doc/manuals/r-release/R-ints.html)

**Question**

My question has two parts:

1. Where is this formally documented?
2. How does copy-on-modify work?

For example, is it proper to talk about &quot;pass-by-reference&quot;, since a *promise* gets passed to the function?


What exactly is copy-on-modify semantics in R, and where is the canonical source?

I&#39;m looking for some good comprehensive reading material on when JavaScript passes something by value and when by reference and when modifying a passed item affects the value outside a function and when not.  I&#39;m also interested in when assigning to another variable is by reference vs. by value and whether that follows any different rules than passing as a function parameter.

I&#39;ve done a lot of searching and find lots of specific examples (many of them here on SO) from which I can start to piece together pieces of the real rules, but I haven&#39;t yet found a single, well written document that describes it all.

Also, are there ways in the language to control whether something is passed by reference or by value?

Here are some of the types of questions I want to understand.  These are just examples - I&#39;m actually looking to understand the rules the language goes by, not just the answers to specific examples.  But, here are some examples:

    function f(a,b,c) {
       a = 3;
       b.push(&quot;foo&quot;);
       c.first = false;
    }
    
    var x = 4;
    var y = [&quot;eeny&quot;, &quot;miny&quot;, &quot;mo&quot;];
    var z = {first: true};
    f(x,y,z);

When are the contents of x, y and z changed outside the scope of f for all the different types?

    function f() {
        var a = [&quot;1&quot;, &quot;2&quot;, &quot;3&quot;];
        var b = a[1];
        a[1] = &quot;4&quot;;
        // what is the value of b now for all possible data types that the array in &quot;a&quot; might hold?
    }
    
    function f() {
        var a = [{yellow: &quot;blue&quot;}, {red: &quot;cyan&quot;}, {green: &quot;magenta&quot;}];
        var b = a[1];
        a[1].red = &quot;tan&quot;;
        // what is the value of b now and why?
        b.red = &quot;black&quot;;
        // did the value of a[1].red change when I assigned to b.red?
    }

If I want to make a fully independent copy of an object (no references whatsoever), what&#39;s the best practice way to do that?

JavaScript by reference vs. by value

Since we have move semantics in C++, nowadays it is usual to do

    void set_a(A a) { _a = std::move(a); }

The reasoning is that if `a` is an rvalue, the copy will be elided and there will be just one move. 

But what happens if `a` is an lvalue? It seems there will be a copy construction and then a move assignment (assuming A has a proper move assignment operator). Move assignments can be costly if the object has too many member variables. 

On the other hand, if we do

    void set_a(const A&amp; a) { _a = a; }

There will be just one copy assignment. Can we say this way is preferred over the pass-by-value idiom if we will pass lvalues?


Is the pass-by-value-and-then-move construct a bad idiom?

When you pass a collection like list, array to another function in python, does it make a copy of it, or is it just a pointer?





Passing values in Python

The primitive types (number, string, etc.) are passed by value, but objects are unknown, because they can be both passed-by-value (in case we consider that a variable holding an object is in fact a reference to the object) and passed-by-reference (when we consider that the variable to the object holds the object itself).

Although it doesn&#39;t really matter at the end, I want to know what is the correct way to present the arguments passing conventions. Is there an excerpt from JavaScript specification, which defines what should be the semantics regarding this?


Is JavaScript a pass-by-reference or pass-by-value language?

This came up in a code review discussion recently, but without a satisfactory conclusion. The types in question are analogues to the C++ string_view TS. They are simple non-owning wrappers around a pointer and a length, decorated with some custom functions:

    #include &lt;cstddef&gt;

    class foo_view {
    public:
        foo_view(const char* data, std::size_t len)
            : _data(data)
            , _len(len) {
        }
    
        // member functions related to viewing the &#39;foo&#39; pointed to by &#39;_data&#39;.
    
    private:
        const char* _data;
        std::size_t _len;
    };

The question arose as to whether there is an argument either way to prefer to pass such view types (including the upcoming string_view and array_view types) by value or by const reference.

Arguments in favor of pass by value amounted to &#39;less typing&#39;, &#39;can mutate the local copy if the view has meaningful mutations&#39;, and &#39;probably no less efficient&#39;.

Arguments in favor of pass-by-const-reference amounted to &#39;more idiomatic to pass objects by const&amp;&#39;, and &#39;probably no less efficient&#39;.

Are there any additional considerations that might swing the argument conclusively one way or the other in terms of whether it is better to pass idiomatic view types by value or by const reference.

For this question it is safe to assume C++11 or C++14 semantics, and sufficiently modern toolchains and target architectures, etc.


C++ view types: pass by const&amp; or by value?

I would like to emulate the pass-by-value behaviour in python. In other words, I would like to make absolutely sure that the function I write do not modify user supplied data. 



One possible way is to use deep copy:
    
    from copy import deepcopy
    def f(data):
        data = deepcopy(data)
        #do stuff
        

is there more efficient or more _pythonic_ way to achieve this goal, making as few assumptions as possible about the object being passed (such as .clone() method)



 **Edit** 

I&#39;m aware that technically everything in python is passed by value. I was interested in *emulating* the behaviour, i.e. making sure I don&#39;t mess with the data that was passed to the function. I guess the most general way is to clone the object in question either with its own clone mechanism or with deepcopy.

Emulating pass-by-value behaviour in python

A simple question for which I couldn&#39;t find the answer here.

What I understand is that while passing an argument to a function during call, e.g.

    void myFunction(type myVariable)
    {
    }

    void main()
    {
        myFunction(myVariable);
    }

For simple datatypes like `int`, `float`, etc. the function is called by value.

But if `myVariable` is an array, only the starting address is passed (even though our function is a call by value function).

If `myVariable` is an object, also only the address of the object is passed rather than creating a copy and passing it.

So back to the question. Does C++ pass a object by reference or value?

Does C++ pass objects by value or reference?

So, I have some code, kind of like the following, to add a struct to a list of structs:

    void barPush(BarList * list,Bar * bar)
    {
    	// if there is no move to add, then we are done
    	if (bar == NULL) return;//EMPTY_LIST;
    
    	// allocate space for the new node
    	BarList * newNode = malloc(sizeof(BarList));
    	
        // assign the right values
    	newNode-&gt;val = bar;
    	newNode-&gt;nextBar = list;
    
    	// and set list to be equal to the new head of the list
        list = newNode; // This line works, but list only changes inside of this function
    }

These structures are defined as follows:

    typedef struct Bar
    {
        // this isn&#39;t too important
    } Bar;
    
    #define EMPTY_LIST NULL
    
    typedef struct BarList
    {
    	Bar * val;
    	struct	BarList * nextBar;
    } BarList;


and then in another file I do something like the following:

	BarList * l;

	l = EMPTY_LIST;
	barPush(l,&amp;b1); // b1 and b2 are just Bar&#39;s
	barPush(l,&amp;b2);


However, after this, l still points to EMPTY_LIST, not the modified version created inside of barPush. Do I have to pass list in as a pointer to a pointer if I want to modify it, or is there some other dark incantation required? 

All Pass by-Value Solutions on Gang of Coders

Total of 30 Pass by-Value Solutions

Is Java "pass-by-reference" or "pass-by-value"?