Pass by value and pass by reference C#

Question

I will call what you are passing in a to a function the actual parameters, and where you receive them, the parameters in the function, the formal parameters. They are also called actual and formal arguments.

When passing parameters, what it is called and what happens can be confusing. It is less essential that you call it the "correct" thing than you know exactly what is happening. It is critical to have a good mental model, a valid memory picture of the process.

Nội dung chính Show

What is difference between pass by value and pass by reference in C?
What is pass by value & pass by reference?
Does C have pass by reference?
What is difference between call by value and call by reference in C?

Recall that when you call a function, a chunk of memory called an activation record is allocated. Critical to the discussion here is that this memory holds the formal parameter values and function local variables.

By definition, pass by value means you are making a copy in memory of the actual parameter's value that is passed in, a copy of the contents of the actual parameter. Use pass by value when when you are only "using" the parameter for some computation, not changing it for the client program.

In pass by reference (also called pass by address), a copy of the address of the actual parameter is stored. Use pass by reference when you are changing the parameter passed in by the client program.

Consider a swapping function to demonstrate pass by value vs. pass by reference. This function, which swaps ints, cannot be done in Java.

   main() {
      int i = 10, j = 20;
      swapThemByVal(i, j);
      cout << i << "  " << j << endl;     // displays 10  20
      swapThemByRef(i, j);
      cout << i << "  " << j << endl;     // displays 20  10
      ...
   }

   void swapThemByVal(int num1, int num2) {
      int temp = num1;
      num1 = num2;
      num2 = temp;
   }

   void swapThemByRef(int& num1, int& num2) {
      int temp = num1;
      num1 = num2;
      num2 = temp;
   }

First, we show the memory picture for swapThemByVal. The activation record holds the memory for the two parameters, num1 and num2, and the local variable, temp. A copy of the values from main, in the contents of i and j, are copied. All the manipulation is done in the activation record.


                       +-------------+                +-------------+  
        swapThemByVal: |+--+         | swapThemByVal: |+--+         |  
        (at start)     ||..| temp    | (after         ||10| temp    |  
main:                  |+--+         |  assignments)  |+--+         |  
  +----+               |+--+         |                |+--+         |  
i | 10 |               ||10| num1    |                ||20| num1    |  
  +----+               |+--+         |                |+--+         |  
  +----+               |+--+         |                |+--+         |  
j | 20 |               ||20| num2    |                ||10| num2    |  
  +----+               |+--+         |                |+--+         |  
                       +-------------+                +-------------+

The contents of memory of i and j don't change. The contents of memory in the function's activation record changes, but when the function terminates, the memory is released and the changes are lost.

Contrast this with passing by reference. The addresses of i and j are passed (noted by the arrows) by reference. The compiler knows they are references so when the parameters are referred to in the function, the compiler dereferences num1 and num2 automatically so i and j of main's memory are changed.

                       +-------------+
        swapThemByRef: |+--+         |
                       ||..| temp    |
main:                  |+--+         |
  +----+               |+--+         |
i | 10 | <-------------||--| num1    |
  +----+               |+--+         |
  +----+               |+--+         |
j | 20 | <-------------||--| num2    |
  +----+               |+--+         |
                       +-------------+

After the assignments:


                       +-------------+
        swapThemByRef: |+--+         |
                       ||10| temp    |
main:                  |+--+         |
  +----+               |+--+         |
i | 20 | <-------------||--| num1    |
  +----+               |+--+         |
  +----+               |+--+         |
j | 10 | <-------------||--| num2    |
  +----+               |+--+         |
                       +-------------+

This is the essence of pass by value vs. pass by reference. It doesn't matter if the parameters are primitive types, arrays, or objects, either a copy is made or an address is stored. As noted elsewhere, when objects are copied, the copy constructor is called to do the copying.

Typically if you aren't going to change a variable, you use pass by value. But if you are passing something in that uses a lot of memory, i.e., passing an object or passing an array, even if you aren't changing it, you use what I like to call fake pass by value.

For efficiency, you pass by reference so only the address is passed, but you put a const in front of it. This casts it to a constant for use in the function. Note that if this function passes to some other function, it is now constant object or array. For example:

main() {
   SomeBigClass x(100);
   // initialize and do whatever with x
   doSomething(x);
   ...
}

void doSomething(const SomeBigClass& x) {
   ...
}

What is difference between pass by value and pass by reference in C?

Definition. Pass by value refers to a mechanism of copying the function parameter value to another variable while the pass by reference refers to a mechanism of passing the actual parameters to the function. Thus, this is the main difference between pass by value and pass by reference.

What is pass by value & pass by reference?

Pass by Value: The method parameter values are copied to another variable and then the copied object is passed, that's why it's called pass by value. Pass by Reference: An alias or reference to the actual parameter is passed to the method, that's why it's called pass by reference.

Does C have pass by reference?

Pass by Reference A reference parameter "refers" to the original data in the calling function. Thus any changes made to the parameter are ALSO MADE TO THE ORIGINAL variable. Arrays are always pass by reference in C.

What is difference between call by value and call by reference in C?

In the case of Call by Value, when we pass the value of the parameter during the calling of the function, it copies them to the function's actual local argument. In the case of Call by Reference, when we pass the parameter's location reference/address, it copies and assigns them to the function's local argument.

Pass-by name Pass-by value-result Example Reference in C