Hello,
Thanks for all those enthusiastic responses. I came across this
answer to FAQs in one of the books on C programming and this is the
paer after reading which, I did the experiment. Please read this. Its
simple and now is it contrary to what you have told?
/////////////////////////////////////////////////////
VIII.6: How can you pass an array to a function by value?
Answer:
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[]);
C Programming: 168 Just the FAQs
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(cons t 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(cons t int* i)
{
int y;
/* Print the contents of the integer array. */
Chapter VIII · Functions 169
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(cons t 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.
///////////////////////////////////////////////////////////////////////////////////////////////////
What is this copy of the araay made on the stack all about?
:-)
With Regards,
Abhishek S
On Mar 26, 9:47 am, Chris Dollin <chris.dol...@h p.comwrote:
Tim Prince wrote:
Chris Dollin wrote:
It never was there: arrays are not [r]values in C and never have
been. In value context an array decays into a pointer to its
first element.
[And this is not the same as pass-by-reference, either]
Nevertheless, there is a widespread belief (based on limited experience)
that languages which are normally implemented with C ABI compatibility
(e.g. Fortran) require pass-by-reference.
Languages which require pass-by-reference implement pass-by-reference.
What that has to do with any C ABI I'm not sure: no such has pass-by-
reference arguments, although it may have pointers passed-by-value.
If some other language interfacing to that ABI uses its pass-by-reference
parameters to do so, that's its business.
--
second Jena user conference! http://hpl.hp.com/conferences/juc2007/
"You've spotted a flaw in my thinking, Trev." Big Al, /The Beiderbeck Connection/
Hewlett-Packard Limited registered no:
registered office: Cain Road, Bracknell, Berks RG12 1HN 690597 England
