Do you know that? Freelance work is the fastest growing sector of the labor market next

How can you pass an array to a function by value?

An array can be passed to a function by value by declaring in the called function the array name with square
brackets ([ and ]) attached to the end. When calling the function, simply pass the address of the array (that
is, the array's name) to the called function. For instance, the following program passes the array x[] to the
function named byval_func() by value:

#include <stdio.h>
void byval_func(int[]);       /* the byval_func() function is passed an
                                 integer array by value */
void main(void);
void main(void)
{
     int x[10];
     int y;
     /* Set up the integer array. */
     for (y=0; y<10; y++)
          x[y] = y;
     /* Call byval_func(), passing the x array by value. */
     byval_func(x);
}
/* The byval_function receives an integer array by value. */
void byval_func(int i[])
{
     int y;
     /* Print the contents of the integer array. */
     for (y=0; y<10; y++)
          printf("%d\n", i[y]);
}

In this example program, an integer array named x is defined and initialized with 10 values. The function
byval_func() is declared as follows:

int byval_func(int[]);

The int[] parameter tells the compiler that the byval_func() function will take one argument—an array
of integers. When the byval_func() function is called, you pass the address of the array to byval_func():
byval_func(x);

Because the array is being passed by value, an exact copy of the array is made and placed on the stack. The
called function then receives this copy of the array and can print it. Because the array passed to byval_func()
is a copy of the original array, modifying the array within the byval_func() function has no effect on the
original array.

Passing arrays of any kind to functions can be very costly in several ways. First, this approach is very inefficient
because an entire copy of the array must be made and placed on the stack. This takes up valuable program
time, and your program execution time is degraded. Second, because a copy of the array is made, more
memory (stack) space is required. Third, copying the array requires more code generated by the compiler,
so your program is larger.

Instead of passing arrays to functions by value, you should consider passing arrays to functions by reference:
this means including a pointer to the original array. When you use this method, no copy of the array is made.
Your programs are therefore smaller and more efficient, and they take up less stack space. To pass an array
by reference, you simply declare in the called function prototype a pointer to the data type you are holding
in the array.

Consider the following program, which passes the same array (x) to a function:

#include <stdio.h>
void const_func(const int*);
void main(void);
void main(void)
{
     int x[10];
     int y;
     /* Set up the integer array. */
     for (y=0; y<10; y++)
          x[y] = y;
     /* Call const_func(), passing the x array by reference. */
     const_func(x);
}
/* The const_function receives an integer array by reference.
   Notice that the pointer is declared as const, which renders
   it unmodifiable by the const_func() function. */
void const_func(const int* i)
{
     int y;
     /* Print the contents of the integer array. */
     for (y=0; y<10; y++)
          printf("%d\n", *(i+y));
}

In the preceding example program, an integer array named x is defined and initialized with 10 values. The
function const_func() is declared as follows:

int const_func(const int*);

The const int* parameter tells the compiler that the const_func() function will take one argument—a
constant pointer to an integer. When the const_func() function is called, you pass the address of the array
to const_func():

const_func(x);

Because the array is being passed by reference, no copy of the array is made and placed on the stack. The called
function receives simply a constant pointer to an integer. The called function must be coded to be smart
enough to know that what it is really receiving is a constant pointer to an array of integers. The  const modifier
is used to prevent the const_func() from accidentally modifying any elements of the original array.

The only possible drawback to this alternative method of passing arrays is that the called function must be
coded correctly to access the array—it is not readily apparent by the const_func() function prototype or
definition that it is being passed a reference to an array of integers. You will find, however, that this method
is much quicker and more efficient, and it is recommended when speed is of utmost importance.