In the C programming language the effect of call be reference can be achieved by passing a reference as a value. Knowledge of this reference can then be used to alter the value held in it. This mechanism thus only simulates call by reference and should (more accurately) be referred to as call be reference value.

C Example:

#include <stdio.h>

void meanValue(float *, float);

void main(void)
{
float value_1, value_2;

scanf("%d %s\n",&value_1,&value_2):

meanValue(&value_1, value_2);

printf("Mean value_1 = %f\n",value_1);
}

void meanValue(float *num_1, float mum_2)
{
printf("num_1 = %f, num_2 = %f\n",*num_1,num_2);
*num_1 = (*num_1+num_2)/2.0;
}

Remember that the operator & is interpreted as "the address of ...". And the operator * when followed by a pointer is interpreted as "the variable pointed at by ...".

Call by reference value is used in C to pass arrays. This has the efficiency advantage that we do not have make a copy of the array; of course when doing this we must appreciate that we are working with the actual data item. An example where we pass a string to a function is given below. Remember that, in C, when we use an array name on its own it acts as a "pointer" to the start of the array!

#include <stdio.h>

void toUpper(char *);

/* ------ MAIN ------ */

void main(void) {
    char myString[32];
	
    printf("Input a string of no more than 32 lower case characters\n");
    scanf("%s",myString);
	
    printf("Echo myString = %s\n",myString);
	
    /* Convert to Upper Casae */
	
    toUpper(myString);
	
    /* Output result */
	
    printf("Upper case = %s\n",myString);
    }

/* ------ TO UPPER CASE ------ */

void toUpper(char *text) {
    int index=0;
   
    while (text[index] != '\0') {
   	text[index] = text[index]-32;
	index++;
	}
    }

Call by result is used in Ada to implement out mode parameter passing. The formal parameter acts as an uninitialised local variable which is given a value during execution of the procedure. The value of the formal parameter is then assigned to the actual parameter on returning from the routine.

Ada Example:

with CS_IO; use CS_IO;

procedure OUT_MODE_EXAMPLE is
        VALUE_1, VALUE_2: float;
        MEAN: float;

        procedure MEAN_VALUE (NUM_1, NUM_2: in float; NUM_3: out float) is
        begin
                NUM_3:= (NUM_1+NUM_2)/2.0;
        end MEAN_VALUE;

begin
        MEAN_VALUE(VALUE_1, VALUE_2, MEAN);
        put("The mean is ");
        put(MEAN);new_line;
        new_line;
end OUT_MODE_EXAMPLE;

Call by copy restore (also known as call by value result) is an amalgamation of call by value and call by result. The formal parameter acts as a local variable which is initialised to the value of the actual parameter. Within the routine, changes to the formal parameter only affect the local copy. On returning from the routine the final value of the formal parameter is assigned to the actual parameter. Call by copy restore is supported by Ada to achieve "in-out" parameter operation. It has the same disadvantages as those associated with call by value.

Ada Example:

with CS_IO; use CS_IO;

procedure IN_OUT_MODE_EXAMPLE is
        VALUE_1, VALUE_2: float;

        procedure MEAN_VALUE (NUM_1: in out float; NUM_2: in float) is
        begin
                NUM_1:= (NUM_1+NUM_2)/2.0;
        end MEAN_VALUE;

begin
        get(VALUE_1);get(VALUE_2);
        put("BEFORE MEAN VALUE: VALUE_1 = ");
        put(VALUE_1);put(", VALUE_2 = ");put(VALUE_2);new_line;
        MEAN_VALUE(VALUE_1, VALUE_2);
        put("The mean is ");
        put(VALUE_1);new_line;
        put("AFTER MEAN VALUE: VALUE_1 = ");
        put(VALUE_1);put(", VALUE_2 = ");put(VALUE_2);new_line;
end IN_OUT_MODE_EXAMPLE;

The normal procedure when calling a routine is to list all the actual parameters in order separated by commas. This is called Positional Parameter Association (PPA). PPA means that any actual parameters supplied must agree with the formal parameters in number, order and type. Most imperative languages (Ada and C included) support PPA. Example

procedure POS_PARAM_ASSOC is
   ----------------------------------------------
   -- ADD_UP procedure
   procedure ADD_UP(X_VAL,Y_VAL,Z_VAL:INTEGER) is
   begin
      PUT(X_VAL+Y_VAL+Z_VAL);
      NEW_LINE;
   end ADD_UP;
    ----------------------------------------------
-- Top level
begin
   ADD_UP(2,4,6);
end POS_PARAM_ASSOC;    

The alternative is keyword or named parameter association (see below).

Named parameter association (ada) example:

procedure NAMED_PARAM_ASSOC is
   ----------------------------------------------
   -- ADD_UP procedure
   procedure ADD_UP(X_VAL,Y_VAL,Z_VAL:INTEGER) is
   begin
      PUT(X_VAL+Y_VAL+Z_VAL);
      NEW_LINE;
   end ADD_UP;
   ----------------------------------------------
-- Top level
begin
   ADD_UP(X_VAL=>2, Y_VAL=>4, Z_VAL=>6);
   ADD_UP(Z_VAL=>6, X_VAL=>2, Y_VAL=>4);
   ADD_UP(2,        Z_VAL=>6, Y_VAL=>4);
end NAMED_PARAM_ASSOC;     

• Note that the parameters do not need to be orderer in a particular way.
• Note also that we can mix positional and named parameter association provided that the positional parameters precede the named parameters.
• The claimed advantage is that this gives a clearer reading of the code.
• Anybody reading the code does not need to know exactly the formal parameters used or the order in which they appear before being able to understand the significance of the call.

The above all assumes that we wish to pass data items. Some languages support passing of procedures (e.g. Pascal). Example: in numerical analysis, where methods for finding (say) roots of functions etc. can be written to be independent of any particular routine, it useful to be able to pass appropriate functions to solving routine.