为什么一个 function 对实际参数的副本进行操作？

Question

I want to understand what is happening behind when you pass a parameter by value to a function. How is this "the function copy the values" done?

I would like this to be a parallel between passing an array vs passing two variables.

I've searched some threads, from which I consider this would best fit, although I have some other question.

Here are two examples:

Ex1:

void function(int arr[])
{
    cout << arr << endl;                // The address of the first elm
    cout << sizeof(arr);                // 4 (bytes size of address on 32 bit)
}

int main()
{
    int vector[] = {1,2,3,4,5,6,7};
    function(vector);
    return 0;
}

Ex2:

void interChange(int a, int b)
{
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
}

int main()
{
    int a = 5, b = 3;
    interChange(a, b);
    return 0;
}

In the first one, I want to show that even if I pass an array by value it is still interpreted as a pointer (allowing modifications in function to alter the actual vector values), this is why printing the array will output an address, and printing its size will output the dimension of a pointer.

In the second example, the parameters are passed by value, but this time they do not alter the values of variables a and b . How does this process take place? Why are they copied instead of using their addresses too? Does the compiler take into account something about their addresses? If I print &a in main() and then inside the interChange, I get two addresses very close one to each other Eg: 0x69fed8 , 0x69fe80 .

Answer 1

See whenever you pass any argument to any function,generally it gets copied to the function parameter. But here is an exception in cases of array this thing doesn't happen. Whenever you pass array to any function compiler automatically convert it to pointer to first element of the array. Now let's come to two cases

Case 1: when you passed an array compiler converted it to pointer to first element of that array. Now array of int type so Ofc pointer will be of int type and size of int pointer it 4bytes which you can see.

Case 2: when you passed two ints in second function. The passing argument are copied to the function parameter. So remember whether you write name same in argument and parameter list as you did. Both are different variables. Whatever you do in function will not going to affect to the variables in main. So your interchange function is of no use as it is working on A and B of it's own function not on the end which are in main.

I hope it's clear now. Comment if you didn't get any part

Answer 2

Ok this is just the convention that C-programming language chose. C++ inherited it from C.

You gave two different but somewhat related examples. I am going to address them separately.

For the second example : When you declare a variable int a for example - machine need to store a value somewhere. That is there is certain amount of RAM allocated to store a value that can be interpreted as int . on x86, 32bit machine - this should be 32bit / 4 bytes of memory.

When a function is called with arguments - values must be passed to a function. THat is some memory must be allocated to store this values. C and C++ chose to copy values by default. That is the fist thing that happens when a function is called - some memory allocated. for its arguments and values are copied to that new memory. This works nice for ints as they can be stored in CPU registers - which are limited in size. If you want to modify values - you need to take an address of the memory where a value is stored - pass that address to a function. Note you have at copied the address. But having address - pointer - allows you to change values stored at that address.

// Copy two integers
void interChange(int a, int b) {
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
}

void interChangePtr(int* a, int* b) {
    int tmp;
    tmp = *a;
    a* = *b;
    b* = tmp;
}

int main() {
    int a = 5, b = 3;
    interChange(a, b);
    // a=5, b=3.

    interChangePtr(&a, &b);
    // a=3, b=5

    return 0;
}

As for your second example - this is another convention that C chose. When you type:

int main() {
 int arr[25]; // Allocates memory on the stack for 25 integers
 ...

Declaring an array (in C-style) informs the compiler that you'd like it to allocate memory for your array on the stack. An array is just a continues chunk of memory. So you can take a pointer to it and modify values using that pointer. And in C if you type arr - this is the pointer to memory allocated for you on the stack. So when you call a function void function(int arr[]) as function(arr) - this actually passes a pointer to your array not the actual block of memory. The reason for these conventions - is performance. It is faster to pass a single pointer to an array then to allocate a new array and copy data over.

Hope that gives you some pointer to reseach the topic further.

Answer 3

Copying by value means in fact the following pattern.

int a = 10;
int b = a;

In this simple example the value of a is copied into the variable b .

This function declaration from your first example

void function(int arr[]);

is equivalent to the declaration

void function(int *arr);

because the compiler implicitly adjusts a parameter having an array type to pointer to the array element type.

On the other hand, an array passed by value is implicitly converted to pointer to its first element.

This function definition

void function(int arr[])
{
    cout << arr << endl;                // The address of the first elm
    cout << sizeof(arr);                // 4 (bytes size of address on 32 bit)
}

and its call

function(vector);

you can imagine the following way

function(vector);
//...

void function( /*int arr[] */)
{
    int *arr = vector; 
    cout << arr << endl;                // The address of the first elm
    cout << sizeof(arr);                // 4 (bytes size of address on 32 bit)
}

That is function parameters are its local variables and if arguments are passed by value then these local variables get copies of the values of the arguments.

But take into account that elements of an array in fact are passed by reference through the pointer to the first element of the array.

It looks the same way as if you had the following function

void interChange(int *a, int *b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}

and

interChange( &a, &b);

To show the similarity with the passing an array as an argument that is converted to pointer to its first element you can rewrite the function definition the following way

void interChange(int *a, int *b)
{
    int tmp;
    tmp = a[0];
    a[0] = b[0];
    b[0] = tmp;
}

That is it looks like passing to the function arrays each of which contains only one element.