What happens to a parameter passed by value that is modified locally?

问题

I am well aware that modifying a function's argument that is passed by value is ineffective outside of the C/C++ function, but compilers allow it - but what happens? Is a local copy made of the argument and that is modifiable within the function?

#include <stdio.h>

void doSomething( int x )
{
    x = 42;
    printf( "The answer to Life, the Universe and Everything is (always): %i!\n", x );
}

int main( int argc, char **argv )
{
    int a = 0;
    doSomething( a );
    return -a;
}

Now this always exits without error, but where in the scheme of things (memory space) is the value represented in the function as x kept?

I imagine that should the (combined declaration and definition) begin:

void doSomething( const int x )

I would get my wrists slapped by any half-decent compiler.

回答1:

For the function doSomething(), x is local to the function. It has the similar scope of any other variable defined at the beginning of the function body.

In general terms, x exists only in the scope of doSomething() function. x is defined once doSomething() is called (and the argument is passed) and destroyed once the control returns. As long as the function call is being executed (i.e., the variable remains in scope), the parameter(s) are the same as any other variable, only initialized by the arguments supplied in the function call.

Quoting C11, chapter §6.2.1, Scopes of identifiers

[...] If the declarator or type specifier that declares the identifier appears inside a block or within the list of parameter declarations in a function definition, the identifier has block scope, which terminates at the end of the associated block. [...]

As you are already aware, x being the local copy of the actual argument passed to function call, any changes made to x inside the function will not reflect into the caller (actual argument), but there's no reason for the compiler to complain as long as the operation(s) on x inside the function is (are) valid.

回答2:

A value parameter of a function is effectively a local variable of the function, except that it is initialised in the function call. So these:

 void f( int n ) {
      n++;
   }

and:

 void g() {
      int n = 0;
      n++;
   }

are effectively the same, if the call to f() was made as f(0). In both cases, the variable will be discarded on function exit.

回答3:

The formal parameter x is a separate object in memory from the actual parameter a, so any changes to x are not reflected in a.

回答4:

As others have explained, x is local in function doSomething, any modifications only affect the local copy of the argument.

Note however that C++ allows passing by reference: a very small change in the definition of doSomething() would have significant consequences for this program:

void doSomething( int& x ) {
    x = 42;
    printf( "The answer to Life, the Universe and Everything is (always): %i!\n", x );
}

With the above function definition, variable a in main would indeed have its value changed to 42. Since the code in main() is identical, this C++ feature can lead to confusing code, especially for a C programmer.

回答5:

Value x is local and is kept in stack. Each function has it own part of stack which is reserved when program enters function. Value x will be located in this part of stack. And it is valid only in scope of function which defined it. If you change x it will be changed only for function where it is defined. if function ends (return from function), stack which was reserved for function is destroyed so also value x. So x won't be accessible because it doesn't exists anymore.

来源：https://stackoverflow.com/questions/42492905/what-happens-to-a-parameter-passed-by-value-that-is-modified-locally