c  go  java  js  lua  py  vbs  rkt  scm  pro  

This page looks at some variations and ways for parameter passing involving record structures.

You should be familiar with variations and ways for parameter passing involving variables and arrays at C: routine variations for variables .

The problem is to initialize two fields of different record structures and then call a function or procedure to add those fields in some way.

The following examples are some of the ways in which two integers can be added. In doing so, various methods are used involving record structures.

The structure will be called data and consists of one integer field value.
struct data { int value; };
The use of one field may be useful if it is expected that this record structure will sometime in the future need additional fields. The code is ready for that without change.

Three local variables are needed in main.
// local variables struct data x1; struct data y2; struct data z3;

To keep the code simple, the values are directly assigned.
// local assignment x1.value = 2; y2.value = 3;

Here is the sum calculated by in-line code.
// explicit in-line coding z3.value = x1.value + y2.value; printf("The sum of %d and %d is %d (in-line code)\n",x1.value,y2.value,z3.value);

Call by value passes a copy of the values to the function. Here is the function.
// add function using call by value struct data add1(struct data a1, struct data b2) { struct data c3; c3.value = a1.value + b2.value; return c3; }
Here is the corresponding call in main.
// call by value z3 = add1(x1,y2); printf("The sum of %d and %d is %d (call by value)\n",x1.value,y2.value,z3.value);

Call by reference passes a reference (pointer) of the values to the function. Here is the function.
// add function using call by reference struct data add2v1(struct data * a1, struct data * b2) { struct data c3; c3.value = (*a1) .value + (*b2) .value; return c3; }
The usual way to do call by reference using a pointer is to use "*a1.value". But this causes an error since field value is not being passed by reference. One must write "(*a1).value" instead.

Here is the corresponding call in main.
// call by reference z3 = add2v1(&x1,&y2); printf("The sum of %d and %d is %d (call by reference v1)\n",x1.value,y2.value,z3.value);

As a shortcut for the notation "(*a1).", one can (and should) use "a1 -> ". And since parameters a1 and b2 are not going to be changed, the const keywoard can be added.
// add function using call by reference struct data add2v2(const struct data *a1, const struct data *b2) { struct data c3; c3.value = a1 -> value + b2 -> value; return c3; }
The call in main remains the same.
// call by reference z3 = add2v2(&x1,&y2); printf("The sum of %d and %d is %d (call by reference v2)\n",x1.value,y2.value,z3.value);

It is often necessary to change a function f (as an expression) to or from a procedure p (as a statement). Here is the general example form (for integers).
z3 = f(x1, y2); // function call form p(x1, y2, &z3); // procedure call form
The function f or procedure p must be written accordingly. Here is the general example form (for integers), written on one line to show the differences.
// function definition form int f(int a1, int b2) { int c3 = a1 + b2; return c3; } // procedure definition form void p(int a1, int b2, int *c3) { *c3 = a1 + b2; }
Here is the C code.
#include <stdio.h> // function definition form int f(int a1, int b2) { int c3 = a1 + b2; return c3; } // procedure definition form void p(int a1, int b2, int *c3) { *c3 = a1 + b2; } int main() { int x1 = 2; int y2 = 3; int z3; z3 = f(x1, y2); // function call form p(x1, y2, &z3); // procedure call form return 0; }

Returning to the original problem, using call by value, the function add2 can be converted to a procedure as follows.
// add procedure using call by value and reference void add3v1(struct data a1, struct data b2, struct data *c3) { (*c3).value = a1.value + b2.value; }
The call needs to be changed appropriately to the following.
add3v1(x1,y2,&z3); printf("The sum of %d and %d is %d (procedure call v1)\n",x1.value,y2.value,z3.value);

The same changes can be made to this procedure. Note that const can be used with both value and reference parameters.
// add procedure using call by value and reference void add3v2(const struct data a1, const struct data b2, struct data *c3) { c3 -> value = a1.value + b2.value; }
Here is the call.
add3v2(x1,y2,&z3); printf("The sum of %d and %d is %d (procedure call v2)\n",x1.value,y2.value,z3.value);
By convention (and in most cases) all formal parameters into the function are at the beginning of the list and all formal parameters changed (by reference) are at the end of the parameter list.

Here is the C code.
#include <stdio.h> struct data { int value; }; // add function using call by value struct data add1(struct data a1, struct data b2) { struct data c3; c3.value = a1.value + b2.value; return c3; } // add function using call by reference struct data add2v1(struct data * a1, struct data * b2) { struct data c3; c3.value = (*a1) .value + (*b2) .value; return c3; } // add function using call by reference struct data add2v2(const struct data *a1, const struct data *b2) { struct data c3; c3.value = a1 -> value + b2 -> value; return c3; } // add procedure using call by value and reference void add3v1(struct data a1, struct data b2, struct data *c3) { (*c3).value = a1.value + b2.value; } // add procedure using call by value and reference void add3v2(const struct data a1, const struct data b2, struct data *c3) { c3 -> value = a1.value + b2.value; } int main() { // local variables struct data x1; struct data y2; struct data z3; // local assignment x1.value = 2; y2.value = 3; // explicit in-line coding z3.value = x1.value + y2.value; printf("The sum of %d and %d is %d (in-line code)\n",x1.value,y2.value,z3.value); // call by value z3 = add1(x1,y2); printf("The sum of %d and %d is %d (call by value)\n",x1.value,y2.value,z3.value); // call by reference z3 = add2v1(&x1,&y2); printf("The sum of %d and %d is %d (call by reference v1)\n",x1.value,y2.value,z3.value); // call by reference z3 = add2v2(&x1,&y2); printf("The sum of %d and %d is %d (call by reference v2)\n",x1.value,y2.value,z3.value); add3v1(x1,y2,&z3); printf("The sum of %d and %d is %d (procedure call v1)\n",x1.value,y2.value,z3.value); add3v2(x1,y2,&z3); printf("The sum of %d and %d is %d (procedure call v2)\n",x1.value,y2.value,z3.value); return 0; }
Here is the output of the C code.
The sum of 2 and 3 is 5 (in-line code) The sum of 2 and 3 is 5 (call by value) The sum of 2 and 3 is 5 (call by reference v1) The sum of 2 and 3 is 5 (call by reference v2) The sum of 2 and 3 is 5 (procedure call v1) The sum of 2 and 3 is 5 (procedure call v2)

When accessing a field of a record structure, the dot "." is usually used to access the desired field.

But, in certain cases when the record structure variable is a formal parameter and that formal parameter is called by reference, another notation is used. When field y of record structure is accessed of formal parameter x representing a record structure, the usual way is to use the asterisk "*" for the "pointer" formal parameter variable as follows.

Note: The form *x.y is ambiguous so the parentheses is used.

The shorthand notation for the above is as follows using the arrow "->" notation (dash followed by greater than character).

Bottom line:

• Use "." for variables (accessor).
• Use "->" for pointers (dereferencer and accessor).

Note for record structure variables:

• Local variables should use ".".
• Call by value formal parameter variables should use ".".
• Call by reference formal parameter variables should use "->".

1 questions omitted (login required)