When only a copy of an argument is passed to a function, it is said to be passed

When a function is called, the arguments in a function can be passed by value or passed by reference.

Callee is a function called by another and the caller is a function that calls another function (the callee).

The values that are passed in the function call are called the actual parameters.

The values received by the function (when it is called ) are called the formal parameters.

Pass by value

Pass by value means that a copy of the actual parameter’s value is made in memory, i.e. the caller and callee have two independent variables with the same value. If the callee modifies the parameter value, the effect is not visible to the caller.

Overview:

1. Passes an argument by value.
2. Callee does not have any access to the underlying element in the calling code.
3. A copy of the data is sent to the callee.
4. Changes made to the passed variable do not affect the actual value.

Pass by reference

Pass by reference (also called pass by address) means to pass the reference of an argument in the calling function to the corresponding formal parameter of the called function so that a copy of the address of the actual parameter is made in memory, i.e. the caller and the callee use the same variable for the parameter. If the callee modifies the parameter variable, the effect is visible to the caller’s variable.

Overview:

1. Passes an argument by reference.
2. Callee gives a direct reference to the programming element in the calling code.
3. The memory address of the stored data is passed.
4. Changes to the value have an effect on the original data.

The following code illustrates the concept.

void incrementCount(int count)//pass by value
{
  count=count+1;//increments the value of count inside the function
}
int main()
{
 int count=0;// initialze the variable count
 int result=0;// initialze the variable result
 incrementCount(count);//call increment function
 cout<<"Pass by value\n";
 cout<<"Count:";
 cout<<count;//prints the value of count after the function call
 return 0;
}

In this example, we can clearly see that the value of variable “count” is not updated if it is passed by value. However, it gets updated when the variable “count” is passed by reference.

When to use pass by value?

If we are building multi-threaded application, then we don’t have to worry of objects getting modified by other threads. In distributed application pass by value can save the over network overhead to keep the objects in sync.

When to use pass by reference?

In pass by reference, no new copy of the variable is made, so overhead of copying is saved. This makes programs efficient especially when passing objects of large structs or classes.

RELATED TAGS

general cs

by reference

by value

Copyright ©2022 Educative, Inc. All rights reserved

C functions exchange information by means of parameters and arguments. The term parameter refers to any declaration within the parentheses following the function name in a function declaration or definition; the term argument refers to any expression within the parentheses of a function call.

The following rules apply to parameters and arguments of C functions:

• Except for functions with variable-length argument lists, the number of arguments in a function call must be the same as the number of parameters in the function definition. This number can be zero.

• The maximum number of arguments (and corresponding parameters) is 253 for a single function.
• Arguments are separated by commas. However, the comma is not an operator in this context, and the arguments can be evaluated by the compiler in any order. There is, however, a sequence point before the actual call.

• Arguments are passed by value; that is, when a function is called, the parameter receives a copy of the argument's value, not its address. This rule applies to all scalar values, structures, and unions passed as arguments.

• Modifying a parameter does not modify the corresponding argument passed by the function call. However, because arguments can be addresses or pointers, a function can use addresses to modify the values of variables defined in the calling function.

• In the old style, parameters that are not explicitly declared are assigned a default type of int .

• The scope of function parameters is the function itself. Therefore, parameters of the same name in different functions are unrelated.

5.6.1 Argument Conversions

In a function call, the types of the evaluated arguments must match the types of their corresponding parameters. If they do not match, the following conversions are performed in a manner that depends on whether a prototype is in scope for the function:

• Arguments to functions specified with prototypes are converted to the parameter types specified in the prototype, except that arguments corresponding to an ellipsis (...) are converted as if no prototype were in scope. (In this case, the rules in the following bullet apply.) For example:

  void f(char, short, float, ...);
  
  char c1, c2;
  short s1,s2;
  float f1,f2;
  
  f(c1, s1, f1, c2, s2, f2);
  

  The arguments c1 , s1 , and f1 are passed with their respective types, while the arguments c2 , s2 , and f2 are converted to int , int , and double , respectively.

• Arguments to functions that have no prototype in scope are not converted to the types of the parameters. Instead, the expressions in the argument list are converted according to the following rules:

  • Any arguments of type float are converted to double .

  • Any arguments of types char , unsigned char , short , or unsigned short are converted to int .

  • When compiling in common C compatibility mode, DEC C converts any arguments of types unsigned char or unsigned short to unsigned int .

No other default conversions are performed on arguments. If a particular argument must be converted to match the type of the corresponding parameter, use the cast operator. For more information about the cast operator, see Section 6.4.6.

5.6.2 Function and Array Identifiers as Arguments

Function and array identifiers can be specified as arguments to a function. Function identifiers are specified without parentheses, and array identifiers are specified without brackets. When so specified, the function or array identifier is evaluated as the address of that function or array. Also, the function must be declared or defined, even if its return value is an integer. Example 5-1 shows how and when to declare functions passed as arguments, and how to pass them.

Example 5-1 Declaring Functions Passed as Arguments

 int x() { return 25; }             /* Function definition and   */
int z[10];                          /* array defined before use  */

 fn(int f1(), int (*f2)(), int a1[]))  /* Function definition       */
{
    f1();                           /* Call to function f1       */
      .
      .
      .
}

void caller(void)
{
    int y();                        /* Function declaration      */
      .
      .
      .
    fn(x, y, z);                    /* Function call: functions  */
                                    /* x and y, and array z      */
                                    /* passed as addresses       */
      .
      .
      .
}
int y(void) { return 30; }          /* Function definition       */

Key to Example 5-1:

1. Without being declared in a separate declaration, function x can be passed in an argument list because its definition, located before the function caller , serves as its declaration.

2. Parameters that represent functions can be declared either as functions or as pointers to functions. Parameters that represent arrays can be declared either as arrays or as pointers to the element type of the array. For example:

   fn(int f1(), int f2(), int a1[])      /* f1, f2 declared as     */
   {...}                                 /* functions; a1 declared */
                                         /* as array of int.       */
   
   fn(int (*f1)(), int (*f2)(), int *a1) /* f1, f2 declared as     */
   {...}                                 /* pointers to functions; */
                                         /* a1 declared as pointer */
                                         /* to int.                */
   

   When such parameters are declared as functions or arrays, the compiler automatically converts the corresponding arguments to pointers.

3. Because its function definition is located after the function caller , function y must be declared before passing it in an argument list.

4. When passing functions as arguments, do not include parentheses. Similarly, when specifying arrays, do not include subscripts.

5.6.3 Passing Arguments to the main Function

The function called at program startup is named main . The main function can be defined with no parameters or with two parameters (for passing command-line arguments to a program when it begins executing). The two parameters are referred to here as argc and argv, though any names can be used because they are local to the function in which they are declared. A main function has the following syntax:

int main(void) { . . . }

int main(int argc, char *argv[ ]) { . . . })

If the value of argc is greater than zero, the array members argv[0] through argv[argc - 1] inclusive contain pointers to strings, which are given implementation-defined values by the host environment before program startup. The intent is to supply the program with information determined before program startup from elsewhere in the host environment. If the host environment cannot supply strings with letters in both uppercase and lowercase, the host environment ensures that the strings are received in lowercase.

If the value of argc is greater than zero, the string pointed to by argv[0] represents the program name; argv[0][0] is the null character if the program name is not available from the host environment. If the value of argc is greater than one, the strings pointed to by argv[1] through argv[argc - 1] represent the program parameters.

The parameters argc and argv, and the strings pointed to by the argv array, can be modified by the program and keep their last-stored values between program startup and program termination.

In the main function definition, parameters are optional. However, only the parameters that are defined can be accessed.

See your platform-specific DEC C documentation for more information on the passing and return of arguments to the main function.

When an argument is only a copy of the arguments value is passed?

When only a copy of an argument is sent to the function it is said to be passed by?

What is an argument passed to a function?

Which method of passing arguments to a function copies the address of an argument?