Pass by value/ result/ value-result/ address/ name problem

[Annie Fox]

Hello there.
I had a chapter in my textbook loosely explaining passing parameters and at the end there is this exercise meant to test it.

#include <stdio.h>

int i;
int a[3];

void proc(int v){

v = v+1;
a[i]= 3;
v=v+1;
}


int main() {

for (i=1; i<=3;i++)
a[i]=0;

a[2]=10;
i=2;
proc(a[i]);

return 0;
}


I'm supposed to be able to tell the value of the elements of the array and the value of v (the formal parameter of the function) if the parameters are passed by:

a. value; possible answer: a[2] = 3, v = 12
b. result; possible answer: ?
c. value-result; possible answer: ?
d. address: a[2]=4, v = 4
e. name; possible answer: ?

The only ones I'm relatively sure of are the ones I tried to answer.

I also know that value-result usually gives results similar to address, so maybe a[2] is 4 again, but I don't know what happens to v and whether the updated value of a[2] can be seen properly.

I did not understand pass by result at all, other than knowing it can modify the actual value of the parameter (so that would make a[2]=4 again?). If anyone could shortly explain the functionality of the different ways to pass parameters based on this example, I'd be grateful.

[weaknessforcats]

This code shouldn't even compile.

First, this function:

void proc(int v){
 
   v = v+1;
   a[i]= 3;
   v=v+1;
}
 
 

Here v is a calling parameter. All calling parameters have the scope of the function so that int v is a COPY of whatever was used to call the function. That means all those changes to v stay inside the function. v is destroyed when the function completes making all v logic pointless. Take v away and all that remains is a[i]= 3. It appears all the function does is change an array element value to 3.

Second, this code:

for (i=1; i<=3;i++)
 a[i]=0;
etc...

crashes the program. The array has 3 elements identified as
a[0], a[1], and a[2]. So the loop misses a[0] and allows
a[3] which is outside the array. Changing a[3] to 0 corrupts your stack and down you go.

What is it you are trying to do?

[Annie Fox]

The for loop won't crash the program, it does compile. I have declared a as an array of three integers. It is, however, one-indexed, for whatever reason, so its elements will be a[1], a[2], a[3].

Sure, v will be destroyed, but its value before it is destroyed interested me insofar as it reflects, I think, exactly what I was trying to understand, namely what happens if you pass the parameter in all these different ways.

For instance, if you pass by address, v will be updated to that the second v = v + 1 will operate on the variable a[2] having the value 3. I guess things happen differently if you pass by value, for instance.

[Annie Fox]

"int v is a COPY of whatever was used to call the function" - that's strictly pass-by-copy.

[weaknessforcats]

@elements will be a[1], a[2], a[3].

You don't have a choice. Array elements are indexed from 0. A 3 element array has element 0, 1, and 2.

There is no pass by address. You pass in a variable whose contents are an address. A copy is made of the variable by the function. That is, the variables used by the function are not the ones used by the calling function.

There are only two ways to pass. Pass by value and pass by reference. C has only pass by value.

[Annie Fox]

Yes, the code is in C, but I'm supposed to simulate how it would work if all the other ways to pass a parameter could be applied. It could/should have been given in pseudocode, for all it matters. It would just have been harder to come up with snippets of code in different programming languages as an exercise.

About the indexing, I only checked the code on codepad.org, since I'm not at home and (for whatever wrong reasons) it compiled. I can see you're right, though.Thanks for the correction.

[weaknessforcats]

Ah, I see.

As to the code compiling a[3] when there is no a[3] in the array, this doesn't mean the code will work as you think. The compiler doesn't know the array ends with array[2]. All it knows is that int a[3]; is a valid array definition but it doesn't keep the 3 around to check on you later. If you decide a[100] is what you want and you use the correct syntax, the compiler will not stop you.

You are permitted in C to blow your foot off.