By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
424,846 Members | 1,646 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 424,846 IT Pros & Developers. It's quick & easy.

how do you pass an array by value

P: n/a
I wrote a function foo(int arr[]) and its prototype
is declared as foo(int arr[]); I modify the values of the array in the
function and the values are getting modified in the main array which
is passed also. I understand that this way of passing the array is by
value and if the prototype is declared as foo(int *), it is by
reference in which case the value if modified in the function will get
reflected in the main function as well. I dont understand why the
values are getting modified in the main function though there is pass
by value. Is pass by value for arrays not there any more?
With Regards,
Abhishek S

Mar 24 '07 #1
Share this Question
Share on Google+
14 Replies


P: n/a
Abhi wrote:
I wrote a function foo(int arr[]) and its prototype
is declared as foo(int arr[]); I modify the values of the array in the
function and the values are getting modified in the main array which
is passed also. I understand that this way of passing the array is by
value and if the prototype is declared as foo(int *), it is by
reference in which case the value if modified in the function will get
reflected in the main function as well. I dont understand why the
values are getting modified in the main function though there is pass
by value. Is pass by value for arrays not there any more?
It was never there for arrays. For a function parameter (and /only/
for a function parameter), a declaration as an array type gets
converted to a declaration as a pointer type. This happens always, and
cannot be bypassed.

void f(int *p) { *p = 1; }

is equivalent to

void f(int p[]) { *p = 1; }

When you call a function, and you try to pass it an array, this array
will be converted to a pointer to the first element of the array.

void g(void) { int i[2]; f(i); }

is equivalent to

void g(void) { int i[2]; f(&i[0]); }

A workaround is to not use an array as a function parameter. You can
use a structure containing an array for that.

struct Array {
int element[100];
} a;

void f(struct Array arr) { arr.element[0] = 1; }

int main(void) {
a.element[0] = 0;
f(a);
return a.element[0];
}

This will return with an exit status of 0, because f is passed a copy
of a, so a.element[0] remains unmodified.

Mar 24 '07 #2

P: n/a
Abhi wrote:
I wrote a function foo(int arr[]) and its prototype
is declared as foo(int arr[]); I modify the values of the array in the
function and the values are getting modified in the main array which
is passed also. I understand that this way of passing the array is by
value and if the prototype is declared as foo(int *), it is by
reference in which case the value if modified in the function will get
reflected in the main function as well. I dont understand why the
values are getting modified in the main function though there is pass
by value. Is pass by value for arrays not there any more?
With Regards,
Abhishek S
Well, arrays can't be passed by value in C. What you believe as pass
by value is not so. What is actually passed to the function is a
pointer to the first element of the array. Therefore you modify the
original copy of the array through this pointer. The array indexing
notation is nothing but a form of syntactic sugar for the underlying
pointer arithmetic.

So, you're misinformed when you say that arrays are passed by value.
In fact the two forms of passing an array to a function, which you've
shown above, are virtually identical.

Mar 24 '07 #3

P: n/a

"Abhi" <ab*************@gmail.comha scritto nel messaggio
news:11**********************@p15g2000hsd.googlegr oups.com...
I wrote a function foo(int arr[]) and its prototype
is declared as foo(int arr[]); I modify the values of the array in the
function and the values are getting modified in the main array which
is passed also. I understand that this way of passing the array is by
value and if the prototype is declared as foo(int *), it is by
reference in which case the value if modified in the function will get
reflected in the main function as well. I dont understand why the
values are getting modified in the main function though there is pass
by value. Is pass by value for arrays not there any more?
With Regards,
Abhishek S
Try using malloc and memcpy to duplicate the array, perform the operations
on the copy, and then free it.
BTW I guess you need to pass the length of the array as a parameter, because
otherwise the function won't have any way to know how long the array is.
(int arr[] only passes &arr[0], period.)
Mar 24 '07 #4

P: n/a
Abhi wrote:
>
I wrote a function foo(int arr[]) and its prototype
is declared as foo(int arr[]); I modify the values of the array in the
function and the values are getting modified in the main array which
is passed also. I understand that this way of passing the array is by
value and if the prototype is declared as foo(int *), it is by
reference in which case the value if modified in the function will get
reflected in the main function as well. I dont understand why the
values are getting modified in the main function though there is pass
by value. Is pass by value for arrays not there any more?
"pass by value for arrays" was never there.

foo(int arr[]) means the exact same thing as foo(int *arr).

--
pete
Mar 24 '07 #5

P: n/a
Abhi wrote:
I wrote a function foo(int arr[]) and its prototype
is declared as foo(int arr[]); I modify the values of the array in the
function and the values are getting modified in the main array which
is passed also. I understand that this way of passing the array is by
value and if the prototype is declared as foo(int *), it is by
reference in which case the value if modified in the function will get
reflected in the main function as well. I dont understand why the
values are getting modified in the main function though there is pass
by value. Is pass by value for arrays not there any more?
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]

--
Saturday Hedgehog
Scoring, bah. If I want scoring I'll go play /Age of Steam/.

Mar 24 '07 #6

P: n/a
Chris Dollin wrote:
Abhi wrote:
> I wrote a function foo(int arr[]) and its prototype
is declared as foo(int arr[]); I modify the values of the array in the
function and the values are getting modified in the main array which
is passed also. I understand that this way of passing the array is by
value and if the prototype is declared as foo(int *), it is by
reference in which case the value if modified in the function will get
reflected in the main function as well. I dont understand why the
values are getting modified in the main function though there is pass
by value. Is pass by value for arrays not there any more?

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.
Mar 24 '07 #7

P: n/a
"Abhi" <ab*************@gmail.comwrote:
# I wrote a function foo(int arr[]) and its prototype
# is declared as foo(int arr[]); I modify the values of the array in the
# function and the values are getting modified in the main array which
# is passed also. I understand that this way of passing the array is by
# value and if the prototype is declared as foo(int *), it is by
# reference in which case the value if modified in the function will get
# reflected in the main function as well. I dont understand why the
# values are getting modified in the main function though there is pass
# by value. Is pass by value for arrays not there any more?

What is passed by value is the pointer to the array contents.
Changes to this pointer (like a++ or --a) itself do not propagate
back to the caller. The array contents are not passed, just the
array pointer. Changes through the pointer (like *a = x) can be
visible to the caller. If you want the function to work on a copy
of the array, generally you pass the array pointer and length
and have the function explicitly copy to a local variable.

--
SM Ryan http://www.rawbw.com/~wyrmwif/
Raining down sulphur is like an endurance trial, man. Genocide is the
most exhausting activity one can engage in. Next to soccer.
Mar 24 '07 #8

P: n/a
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

Mar 26 '07 #9

P: n/a
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(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. */
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(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.
///////////////////////////////////////////////////////////////////////////////////////////////////
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...@hp.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

Mar 28 '07 #10

P: n/a
Abhi wrote:
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?
You can't (not as such [1]).
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 */
This is wrong.
Because the array is being passed by value, an exact copy of the array
is made and placed on the stack.
This is completely and utterly wrong.
What is this copy of the araay made on the stack all about?
Another language, I'd expect. Hope, even.
:-)
I'm hysterical.

[1] Put it in a struct.

--
The second Jena user conference! http://hpl.hp.com/conferences/juc2007/
"A facility for quotation covers the absence of original thought."/Gaudy Night/

Hewlett-Packard Limited registered office: Cain Road, Bracknell,
registered no: 690597 England Berks RG12 1HN

Mar 28 '07 #11

P: n/a
Abhi wrote:
>
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,
Hogwash.

.... snip more hogwash ...

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>
--
Posted via a free Usenet account from http://www.teranews.com

Mar 28 '07 #12

P: n/a
On Mar 28, 5:51 am, "Abhi" <abhisheksgum...@gmail.comwrote:
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?
/////////////////////////////////////////////////////
If the text below is copied from the book you are using, then THROW IT
IN THE TRASH. NOW. THIS INSTANT. I AM NOT KIDDING.

It is a sad fact that the majority of books and websites that claim to
teach C get basic facts wrong and teach bad programming habits. This
book was written by someone who doesn't know C anywhere near as well
as he believes he does, and by inflicting his ignorance on
unsuspecting students, he has helped create a situation where so much
C-based software is buggy and unstable.

Here are some *good* references:

"The C Programming Language", 2nd ed., Kernighan and Ritchie
"C: A Reference Manual", 5th ed., Harbison and Steele
"C Programming: A Modern Approach", King
VIII.6: How can you pass an array to a function by value?
Right answer: wrap it in a struct.
Answer:
WRONG 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.
This is utterly, completely, totally wrong. In a function
delcaration, array subscript notation (int i[]) is synonymous with
pointer notation (int *i); the array is passed by reference either
way.
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)
In a hosted implementation, main() returns int, not void. This is a
fundamental error, and yet another sign that this author doesn't
really know the language well enough to be writing books on it.
{
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);}
When an array identifier appears in any context other than as an
operand to the sizeof or address-of (&) operators, its type is
converted from "array of T" to "pointer to T", and its value is set to
the address of the first element in the array. This address is what
gets passed to the function. Using the array subscript notation in
the function declaration doesn't magically turn this address into a
whole new array.
>
/* The byval_function receives an integer array by value. */
void byval_func(int i[])
The function receives a pointer to the x, not a copy of the original
array.
{
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.
Once again, this is wrong. The array is not passed by value.
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.
Again, wrong, as you have found out for yourself. The more I think
about this specific error, the madder I get at the book's author, as
he obviously did *no* research to support this claim; this is
something he clearly pulled out of thin air, and yet he's passing it
off as gospel. That kind of incompetence should be criminal, as it
has a real impact on the software industry as a whole.
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 is a quality of implementation issue, not a language issue. Not
all implementations use a stack.

Snipping the rest.
Mar 28 '07 #13

P: n/a
Abhi wrote:
Hello,
Please don't top-post. Your replies belong following or interspersed
with properly trimmed quotes. See the majority of other posts in the
newsgroup, or:
<http://www.caliburn.nl/topposting.html>
Mar 28 '07 #14

P: n/a
Abhi wrote:
>
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?
/////////////////////////////////////////////////////
Yes, it is very contrary to what we 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
Wrong!
void byval_func(int[]); /* the byval_func() function is passed an
integer array by value */
void byval_func(int[]);
means the exact same thing as
void byval_func( *int);
Because the array is being passed by value, an exact copy of the array
is made and placed on the stack.
A copy of the array is not made.

--
pete
Mar 28 '07 #15

This discussion thread is closed

Replies have been disabled for this discussion.