call by value

[mdh]

Hi Group,
I know there have been many questions on this topic, but I wish to
clarify this very basic concept.

in:

int main(){
int j;
j = f(8);
.....}

int f(int i){

return i * i;

}

then in the depths of the computer, is this what occurs.

argument of f ie "8" is assigned to int i, a variable unique to f(int
i), which has been created to fulfill the obligations of f(int i), and
is destroyed once i * i is returned. ( which is described as passing a
copy of "8" to the function)

Sorry if this is really rudimentary, but I just saw the light when
arrays are passed as arguments ( I know, not the same as above) and
wanted to go back to the very basics for a moment.

Thanks

[Richard Heathfield]

mdh said:

Hi Group,
I know there have been many questions on this topic, but I wish to
clarify this very basic concept.

in:

int main(){
int j;
j = f(8);
....}

int f(int i){

return i * i;

}

then in the depths of the computer, is this what occurs.

argument of f ie "8" is assigned to int i, a variable unique to f(int
i), which has been created to fulfill the obligations of f(int i), and
is destroyed once i * i is returned. ( which is described as passing a
copy of "8" to the function)

Yes. To be more specific, 8 is ***evaluated*** . It turns out, after a
potentially long and tortuous calculation which in this case is
actually probably quite short, to have the value 8. That result is
stored in the i object that is created as part of the process of
invoking the f function. The return statement evaluates the return
expression, i * i, resulting in a value which is then stored in a place
appropriate for return values (quite possibly directly into main's j,
but perhaps via a register or something). Then the function returns
and, as part of the process of returning, the i object is destroyed.

Sorry if this is really rudimentary, but I just saw the light when
arrays are passed as arguments ( I know, not the same as above) and
wanted to go back to the very basics for a moment.

It's exactly the same as above, even with arrays. What you actually pass
is not an array, but an expression involving an array. That expression
is evaluated, and the result of the evaluation is stored in the
parameter object.

The trick is to realise that parameters are objects, but arguments are
expressions. Expressions are evaluated, and the values thus obtained
are stored in parameter objects.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[mdh]

On Jul 28, 3:51 am, Richard Heathfield :

mdh said:

int main(){
int j;
j = f(8);
....}

int f(int i){

return i * i;

}

Yes. To be more specific, 8 is ***evaluated*** .......snip.... ..

>
It's exactly the same as above, even with arrays. What you actually pass
is not an array, but an expression involving an array. That expression
is evaluated, and the result of the evaluation is stored in the
parameter object.

The trick is to realise that parameters are objects, but arguments are
expressions. Expressions are evaluated, and the values thus obtained
are stored in parameter objects.

I like that.
So, in the case of the "array as argument" example, it would be
evaluated, and the result ( the address of the first element) stored
in the Object parameter (of type pointer to Array-type), if I
understand you correctly.

[Richard Heathfield]

mdh said:

On Jul 28, 3:51 am, Richard Heathfield :

<snip>

>The trick is to realise that parameters are objects, but arguments
are expressions. Expressions are evaluated, and the values thus
obtained are stored in parameter objects.

I like that.
So, in the case of the "array as argument" example, it would be
evaluated, and the result ( the address of the first element) stored
in the Object parameter (of type pointer to Array-type), if I
understand you correctly.

Precisely so, yes.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[mdh]

On Jul 28, 4:03 am, Richard Heathfield <[e-mail].i nvalidwrote:

mdh said:

>

I like that.
So, in the case of the "array as argument" example, it would be
evaluated, and the result ( the address of the first element) stored
in the Object parameter (of type pointer to Array-type), if I
understand you correctly.

Precisely so, yes.

Thank you Richard.

[christian.bau]

On Jul 28, 11:57 am, mdh <m...@comcast.n etwrote:

On Jul 28, 3:51 am, Richard Heathfield :

mdh said:

int main(){
int j;
j = f(8);
....}

int f(int i){

return i * i;

}

Yes. To be more specific, 8 is ***evaluated*** .......snip.... ..

It's exactly the same as above, even with arrays. What you actually pass
is not an array, but an expression involving an array. That expression
is evaluated, and the result of the evaluation is stored in the
parameter object.

The trick is to realise that parameters are objects, but arguments are
expressions. Expressions are evaluated, and the values thus obtained
are stored in parameter objects.

I like that.
So, in the case of the "array as argument" example, it would be
evaluated, and the result ( the address of the first element) stored
in the Object parameter (of type pointer to Array-type), if I
understand you correctly.

With arrays, there are two rules that are not very obvious. The first
is what you said, if you have an expression whose result would be an
array, then in most situations that array will be converted to a
pointer to the first element (the exceptions are sizeof (array) which
gives the size of the whole array as you would hope, not the size of a
pointer to the first element, and &array, which gives the address of
the array, not the address of the first element). That rule is used in
the caller of the function.

The other rule is within function definitions: Whenever you define a
function parameter whose type looks like an array of type T, the
compiler automatically replaces this with a parameter of type "pointer
to T". So if you write "int f (int array[100])" then the compiler
automatically replaces it with "int f (int* array)"; both function
declarations behave absolutely identical. So you can't actually have
arrays as parameters. You can write a function declaration that
_looks_ as if you had array parameters, but you actually get a pointer
parameter instead.

[Keith Thompson]

mdh <md**@comcast.n etwrites:
[...]

So, in the case of the "array as argument" example, it would be
evaluated, and the result ( the address of the first element) stored
in the Object parameter (of type pointer to Array-type), if I
understand you correctly.

Almost. An array expression is converted to a pointer to its first
element, not to a pointer to the array. For example:

int array1[10];
int array2[20][30];

func1(array1);
/* The argument is of type pointer to int. */

func2(array2);
/* The argument is of type pointer to array 30 of int. */

Pointers to arrays actually aren't used very often. In most contexts,
it's more useful to have a pointer to an element of the array, so you
can use it to traverse the elements.

(I presume you've read section 6 of the comp.lang.c FAQ.)

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Richard Heathfield]

Keith Thompson said:

mdh <md**@comcast.n etwrites:
[...]

>So, in the case of the "array as argument" example, it would be
evaluated, and the result ( the address of the first element) stored
in the Object parameter (of type pointer to Array-type), if I
understand you correctly.

Almost. An array expression is converted to a pointer to its first
element, not to a pointer to the array.

FWIW, I read mdh's "pointer to Array-type" as meaning "pointer to a type
of whatever the heck it is that it's an array of". In other words, if
it's an array of int it becomes pointer to int, if it's an array of
char it becomes pointer to char, etc.

That is, I don't think mdh is confused on this matter, and merely worded
his reply a touch carelessly. Nevertheless, your interpretation is a
reasonable one and therefore your correction is useful.

<snip>

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Malcolm McLean]

"Richard Heathfield" <rj*@see.sig.in validwrote in message
news:9q******** *************** *******@bt.com. ..

Keith Thompson said:

>Almost. An array expression is converted to a pointer to its first
element, not to a pointer to the array.

FWIW, I read mdh's "pointer to Array-type" as meaning "pointer to a type
of whatever the heck it is that it's an array of". In other words, if
it's an array of int it becomes pointer to int, if it's an array of
char it becomes pointer to char, etc.

That is, I don't think mdh is confused on this matter, and merely worded
his reply a touch carelessly. Nevertheless, your interpretation is a
reasonable one and therefore your correction is useful.

People are going to say "pointer to an array" when they mean "pointer to the
first element of an array". Humans are very intolerant of syntactic bloat.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[Keith Thompson]

"Malcolm McLean" <re*******@btin ternet.comwrite s:

"Richard Heathfield" <rj*@see.sig.in validwrote in message
news:9q******** *************** *******@bt.com. ..

>Keith Thompson said:

>>Almost. An array expression is converted to a pointer to its first
element, not to a pointer to the array.

FWIW, I read mdh's "pointer to Array-type" as meaning "pointer to a type
of whatever the heck it is that it's an array of". In other words, if
it's an array of int it becomes pointer to int, if it's an array of
char it becomes pointer to char, etc.

That is, I don't think mdh is confused on this matter, and merely worded
his reply a touch carelessly. Nevertheless, your interpretation is a
reasonable one and therefore your correction is useful.

People are going to say "pointer to an array" when they mean "pointer
to the first element of an array". Humans are very intolerant of
syntactic bloat.

Yes, they are, but it's incorrect, because "pointer to an array"
already has a distinct and useful meaning.

The standard uses the term "pointer to a string" to mean a pointer to
the first element of a string. It's able to do this only because a
"pointer to a string" didn't already have a meaning (since a "string"
in C is a data format, not a data type).

If we use the phrase "pointer to an array" to mean a pointer to its
first element, how are we going to talk about actual pointers to
arrays? It's not syntactic bloat at all; it's necessary for
correctness.

If you can come up with an unambiguous shorthand for "pointer to the
first element of an array", I'll consider using it.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"