c++ - When pass a variable to a function, why the function only gets a duplicate of the variable?

Question

When pass a variable to a function, why the function only gets a copy/duplicate of the variable?

int n=1;

void foo(int i)
{
    i++;
}

As we all know, the function foo() can't change the value of n by using foo(n).

Of course we can pass the address of the variable to make some change to the parameter variable.
But don't you think that is a little bit inconvenient?

Why c/c++ is designed to only give a duplicate to the function instead of directly give the "real" variable itself to the function?
What't the pro/benefit of this paradigm?

---

Update:
I have read @paxdiablo's answer. I think his "encapsulation, modularity and localisation of effect" explanation is good.
But in my way, it can also preserve the parameter argument's value as well. It can also realize encapsulation. By this way:(assume the function can directly get the "real" variable instead of a duplicate by default )

void foo(int n)
{
    int temp=n;
    //Do something to temp...

}

And in my way, the complicated mechanism,such as "pass by reference" or pointer can be eliminated when you do want to change the value of parameters passed in. That's the benifit.

After a time of thought. I realise the reason why c/c++ isn't designed as I proposed is just because of the INCONVINIENCE of my way!
In my way, if a function has a long list of variables, it would to terrible. What I thougth is the more convenient way is infact inconvenient:
You must write like this:

void foo(int a,int b,double c,float d,char s...)
{
    int temp1=a;
    int temp2=b;
    double temp3=c;
    float temp4=d;
    char temp5=s;
    ...
    //Do something to temp{1,2,3,4,5....}

}

So the designers of c/c++ introduce complex mechanism to trade off with convenience.
Am I right?

Answer 1

The are basically two schools of thought on this matter.

The first is pass-by-value where a copy of the value is created for the called function.

The second is pass-by-reference where the parameter that appears in the called function is an "alias" of the original. That means changes you make to it are reflected in the original.

C is generally a pass-by-value language. You can emulate pass-by-reference by passing the address of a variable and then using that to modify the original:

void setTo42 (int *x) { *x = 42; }
:
int y;
setTo42 (&y);
// y is now 42

but that's more passing the pointer to a variable by value, than passing the variable itself by reference.

C++ has true reference types, possibly because so many people have trouble with C pointers :-) They're done as follows:

void setTo42 (int &x) { x = 42; }

:
int y;
setTo42 (y);
// y is now 42

Pass-by-value is usually preferable since it limits the effects that a function can have on the "outside world" - encapsulation, modularity and localisation of effect is usually a good thing.

Being able to arbitrarily modify any parameters passed in would be nearly as bad as global variables in terms on modularity and code management.

However, sometimes you need pass-by-reference since it might make sense to change one of the variables passed in.